to all dupers out here

[sNAKOR]

today`s news in offi forum:

Exploiters Banned

After several weeks of investigation we have found a group of accounts involved in performing serious exploits within the game.

Responsible for duplicating items and flooding the game’s economy with currency and high level items, these accounts have now been permanently removed from ArchLord and all of our services.

Any account found to be involved in such activity will be banned from the game.

Dnote



anyone duper acc get already banned?

[rantottmacska]

lol... i just sent a ticket with 17 charnames... thats all flooded the chat,but that was unless... next day that noobs created the spambots again...

[5hoursez]

dupe the f out of everything.. everything is rediculously priced anyway and i am sure lotsa kids and adults fork out money to buy credits anyway lol... thinking of a quote..

"A fool and his money are soon parted" / "It's morally wrong to let a sucker keep his money."
:P

[rantottmacska]

Well, i just finished all the tests. The item duping is not possible. Not with wpe, not with other tools. Thats all server sided. As i wrote many times everything happens in server. The client gets codes only with definited items.
Why is not possible the duping? First just think in: if you kill a mob the drop is divided by server, whats cannot possible to affect.
One way to dupe items, but thats not hack or exploit,etc: get a GM father or friend.
Thats the only one way...
Some ppl said: go try when lag... no, that isn't work. You need serverside lag, but you cant affect that. You can affect only your client's lag.
And one more thing: please don't open many more threads about duping, thats not possible, try to understand!
And an advice for finish: go and play legit instead uses hacks, exploits.
Regards:
Rantottmacska

[InfinityBoT]

there is a way to get server side lag...

will only say

"when harpoons and airstrikes and nukes wont work"

will mean something to those that understand it

get one peice of infomation on there servers that's name is 2 letters long and you can cause some server lag

but just remember .. dont get caught

[gaiahon_seller]

[InfinityBoT]

GTFO AND LEARN TO PHOTO SHOP


SITE IS FAKE... PICS ARE PHOTO SHOPPED

LOOK FIRST IMAGE...

the stoage does not have the same boarder around the rings like the ones in CHAR mnu ... GTFO .. .

mod is needed here

[InfinityBoT]

/* NOTE: All functions in this file are assumed to be PASCAL calling convention
  (hard coded in FrontEnd::readLibraryCatalog()) */

typedef unsigned int UINT;
typedef int INT;
typedef unsigned int SIZE_T;
typedef unsigned int LONG;
typedef unsigned char BYTE;
typedef BYTE *LPBYTE;
typedef LONG *LPLONG;
typedef const void *LPCVOID;
typedef void *LPVOID;
typedef void *PVOID;
typedef const char *LPCSTR;
typedef char *LPSTR;
typedef const short *LPCWSTR;
typedef short *LPWSTR;
typedef short wchar_t;
typedef unsigned int DWORD;
typedef unsigned short WORD;
typedef int HWND;
typedef int HMENU;
typedef int HFONT;
typedef int HLOCAL;
typedef int HINSTANCE;
typedef int HICON;
typedef int HCURSOR;
typedef int HBRUSH;
typedef int HACCEL;
typedef int HDC;
typedef int HGDIOBJ;
typedef int WPARAM;
typedef int LPARAM;
typedef int LRESULT;
typedef int ATOM;
typedef int BOOL;
typedef int HRSRC;
typedef int HMODULE;
typedef int HGLOBAL;
typedef unsigned int ULONG;
typedef unsigned char BYTE;
typedef char CHAR;
typedef int HRESULT;
typedef LRESULT WndProc(	  
	HWND hwnd,
	UINT uMsg,
	WPARAM wParam,
	LPARAM lParam
);
typedef WndProc *WNDPROC;
typedef int CRITICAL_SECTION;
typedef CRITICAL_SECTION *LPCRITICAL_SECTION;

typedef int WinMain(	  
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nCmdShow
);

HLOCAL LocalFree(HLOCAL hMem);
DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, va_list* Arguments);
LPSTR CharNextA(	  
	LPCSTR lpsz
);
LPWSTR CharNextW(	   
	LPCWSTR lpsz
);
LPSTR GetCommandLineA(void);
LPWSTR GetCommandLineW(void);

typedef struct {
	UINT cbSize;
	UINT style;
	WNDPROC lpfnWndProc;
	int cbClsExtra;
	int cbWndExtra;
	HINSTANCE hInstance;
	HICON hIcon;
	HCURSOR hCursor;
	HBRUSH hbrBackground;
	LPCSTR lpszMenuName;
	LPCSTR lpszClassName;
	HICON hIconSm;
} WNDCLASSEX;
typedef struct {
	UINT cbSize;
	UINT style;
	WNDPROC lpfnWndProc;
	int cbClsExtra;
	int cbWndExtra;
	HINSTANCE hInstance;
	HICON hIcon;
	HCURSOR hCursor;
	HBRUSH hbrBackground;
	LPCWSTR lpszMenuName;
	LPCWSTR lpszClassName;
	HICON hIconSm;
} WNDCLASSEXw;


ATOM RegisterClassExW(WNDCLASSEXw *lpwcx);
ATOM RegisterClassExA(WNDCLASSEX *lpwcx);

int LoadStringA(	  
	HINSTANCE hInstance,
	UINT uID,
	LPSTR lpBuffer,
	int nBufferMax
);

int LoadStringW(	  
	HINSTANCE hInstance,
	UINT uID,
	LPWSTR lpBuffer,
	int nBufferMax
);

HACCEL LoadAcceleratorsA(	   
	HINSTANCE hInstance,
	LPCSTR lpTableName
);

HACCEL LoadAcceleratorsW(	   
	HINSTANCE hInstance,
	LPCWSTR lpTableName
);

typedef struct {
	int x;
	int y;
} POINT;
typedef POINT *LPPOINT;

typedef struct {
	int cx;
	int cy;
} SIZE;

typedef struct {
	HWND hwnd;
	UINT message;
	WPARAM wParam;
	LPARAM lParam;
	DWORD time;
	POINT pt;
} MSG;
typedef MSG *LPMSG;

BOOL GetMessageA(	   
	LPMSG lpMsg,
	HWND hWnd,
	UINT wMsgFilterMin,
	UINT wMsgFilterMax
);
BOOL GetMessageW(
	LPMSG lpMsg,
	HWND hWnd,
	UINT wMsgFilterMin,
	UINT wMsgFilterMax
);

int TranslateAcceleratorA(		
	HWND hWnd,
	HACCEL hAccTable,
	LPMSG lpMsg
);

int TranslateAcceleratorW(		
	HWND hWnd,
	HACCEL hAccTable,
	LPMSG lpMsg
);

BOOL TranslateMessage(		
	const MSG *lpMsg
);

LRESULT DispatchMessageA(	   
	const MSG *lpmsg
);

LRESULT DispatchMessageW(	   
	const MSG *lpmsg
);

HICON LoadIconW(	  
	HINSTANCE hInstance,
	LPCWSTR lpIconName
);

HCURSOR LoadCursorW(	  
	HINSTANCE hInstance,
	LPCWSTR lpCursorName
);

HICON LoadIconA(	  
	HINSTANCE hInstance,
	LPCSTR lpIconName
);

HCURSOR LoadCursorA(	  
	HINSTANCE hInstance,
	LPCSTR lpCursorName
);

HWND CreateWindowExA(	   
	DWORD dwExStyle,
	LPCSTR lpClassName,
	LPCSTR lpWindowName,
	DWORD dwStyle,
	int x,
	int y,
	int nWidth,
	int nHeight,
	HWND hWndParent,
	HMENU hMenu,
	HINSTANCE hInstance,
	LPVOID lpParam
);

HWND CreateWindowExW(	   
	DWORD dwExStyle,
	LPCWSTR lpClassName,
	LPCWSTR lpWindowName,
	DWORD dwStyle,
	int x,
	int y,
	int nWidth,
	int nHeight,
	HWND hWndParent,
	HMENU hMenu,
	HINSTANCE hInstance,
	LPVOID lpParam
);

BOOL ShowWindow(	  
	HWND hWnd,
	int nCmdShow
);

BOOL UpdateWindow(
  HWND hWnd
);

int MessageBoxA(	  
	HWND hWnd,
	LPCSTR lpText,
	LPCSTR lpCaption,
	UINT uType
);

int MessageBoxW(	  
	HWND hWnd,
	LPCWSTR lpText,
	LPCWSTR lpCaption,
	UINT uType
);

BOOL GetProcessDefaultLayout(DWORD *pdwDefaultLayout);
BOOL SetProcessDefaultLayout(DWORD dwDefaultLayout);

HLOCAL LocalAlloc(
  UINT uFlags,
  SIZE_T uBytes
);

BOOL IsDialogMessageA(HWND hDlg, LPMSG lpMsg);
BOOL IsDialogMessageW(HWND hDlg, LPMSG lpMsg);

BOOL IsChild(HWND hWndParent, HWND hWnd);

HBRUSH GetSysColorBrush(int nIndex);

BOOL SystemParametersInfoA(
  UINT uiAction,
  UINT uiParam,
  PVOID pvParam,
  UINT fWinIni
);

BOOL SystemParametersInfoW(
  UINT uiAction,
  UINT uiParam,
  PVOID pvParam,
  UINT fWinIni
);

BOOL SetMenu(HWND hWnd, HMENU hMenu);
BOOL DestroyWindow(HWND hWnd);
BOOL DestroyMenu(HMENU hMenu);

typedef int INT_PTR;
typedef INT_PTR DlgProc(	  
	HWND hwndDlg,
	UINT uMsg,
	WPARAM wParam,
	LPARAM lParam
);
typedef DlgProc *DLGPROC;

HWND CreateDialogParamA(	  
	HINSTANCE hInstance,
	LPCSTR lpTemplateName,
	HWND hWndParent,
	DLGPROC lpDialogFunc,
	LPARAM dwInitParam
);

HWND CreateDialogParamW(	  
	HINSTANCE hInstance,
	LPCWSTR lpTemplateName,
	HWND hWndParent,
	DLGPROC lpDialogFunc,
	LPARAM dwInitParam
);

LRESULT DefWindowProcA(		 
	HWND hWnd,
	UINT Msg,
	WPARAM wParam,
	LPARAM lParam
);

void PostQuitMessage(	   
	int nExitCode
);

typedef struct { 
  LONG left; 
  LONG top; 
  LONG right; 
  LONG bottom; 
} RECT;
typedef RECT *LPRECT;

typedef struct { 
  HDC  hdc; 
  BOOL fErase; 
  RECT rcPaint; 
  BOOL fRestore; 
  BOOL fIncUpdate; 
  BYTE rgbReserved[32]; 
} PAINTSTRUCT;
typedef PAINTSTRUCT *LPPAINTSTRUCT;

HDC BeginPaint(
  HWND hwnd,
  LPPAINTSTRUCT lpPaint
);

BOOL EndPaint(
  HWND hWnd,
  LPPAINTSTRUCT lpPaint
);

BOOL GetClientRect(		 
	HWND hWnd,
	LPRECT lpRect
);

int DrawTextA(
  HDC hDC,
  LPCSTR lpString,
  int nCount,
  LPRECT lpRect,
  UINT uFormat
);

int DrawTextW(
  HDC hDC,
  LPCWSTR lpString,
  int nCount,
  LPRECT lpRect,
  UINT uFormat
);

BOOL GetTextExtentPointA(
	HDC		hDC,
	LPCSTR	lpStr,
	int		len,
	SIZE*	sz
);

HGDIOBJ SelectObject(
	HDC hDC,
	HGDIOBJ hObj
);

INT_PTR DialogBoxParamA(	  
	HINSTANCE hInstance,
	LPCSTR lpTemplateName,
	HWND hWndParent,
	DLGPROC lpDialogFunc,
	LPARAM dwInitParam
);

INT_PTR DialogBoxParamW(	  
	HINSTANCE hInstance,
	LPCWSTR lpTemplateName,
	HWND hWndParent,
	DLGPROC lpDialogFunc,
	LPARAM dwInitParam
);

BOOL EndDialog(		 
	HWND hDlg,
	INT_PTR nResult
);

int wsprintfA(
	LPSTR lpOut,
	LPCSTR lpFmt,
	...
);

char *_gcvt(double value, int digits, char *buffer);  /* Convert flt to str */
int MulDiv(int number, int numerator, int denominator);
HFONT CreateFontIndirectA(void* lf);
HFONT CreateFontA(
  int nHeight,				 // height of font
  int nWidth,				 // average character width
  int nEscapement,			 // angle of escapement
  int nOrientation,			 // base-line orientation angle
  int fnWeight,				 // font weight
  DWORD fdwItalic,			 // italic attribute option
  DWORD fdwUnderline,		 // underline attribute option
  DWORD fdwStrikeOut,		 // strikeout attribute option
  DWORD fdwCharSet,			 // character set identifier
  DWORD fdwOutputPrecision,	 // output precision
  DWORD fdwClipPrecision,	 // clipping precision
  DWORD fdwQuality,			 // output quality
  DWORD fdwPitchAndFamily,	 // pitch and family
  LPCTSTR lpszFace			 // typeface name
);

typedef DWORD LCID;
LCID GetThreadLocale();
HLOCAL LocalReAlloc(
  HLOCAL hMem,
  SIZE_T uBytes,
  UINT uFlags
);
UINT GetProfileIntA(
  LPCSTR lpAppName,
  LPCSTR lpKeyName,
  INT nDefault
);
UINT GetProfileIntW(
  LPCWSTR lpAppName,
  LPCWSTR lpKeyName,
  INT nDefault
);
DWORD GetProfileStringA(
  LPCSTR lpAppName,
  LPCSTR lpKeyName,
  LPCSTR lpDefault,
  LPSTR lpReturnedString,
  DWORD nSize
);
DWORD GetProfileStringW(
  LPCWSTR lpAppName,
  LPCWSTR lpKeyName,
  LPCWSTR lpDefault,
  LPWSTR lpReturnedString,
  DWORD nSize
);
DWORD GetSysColor(
  int nIndex
);
BOOL GetWindowRect(		 
	HWND hWnd,
	LPRECT lpRect
);
LONG GetWindowLongA(
    HWND hWnd,
    int nIndex
);
LONG GetWindowLongW(
    HWND hWnd,
    int nIndex
);
LONG SetWindowLongA(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong
);
LONG SetWindowLongW(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong
);
HMENU LoadMenuA(
    HINSTANCE hInstance,
    LPCSTR lpMenuName
);
HMENU LoadMenuW(
    HINSTANCE hInstance,
    LPCWSTR lpMenuName
);
LRESULT SendMessageA(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam
);
LRESULT SendMessageW(
    HWND hWnd,
    UINT Msg,
    WPARAM wParam,
    LPARAM lParam
);
BOOL InvalidateRect(
  HWND hWnd,
  LPRECT lpRect,
  BOOL bErase
);
HWND GetDlgItem(	  
	HWND hDlg,
	int nIDDlgItem
);
BOOL EnableWindow(		
	HWND hWnd,
	BOOL bEnable
);
int MapWindowPoints(
  HWND hWndFrom,
  HWND hWndTo,
  LPPOINT lpPoints,
  UINT cPoints
);
BOOL OffsetRect(
  LPRECT lprc,
  int dx,
  int dy
);
BOOL SetWindowPos(		
	HWND hWnd,
	HWND hWndInsertAfter,
	int X,
	int Y,
	int cx,
	int cy,
	UINT uFlags
);
HMENU GetMenu(		
	HWND hWnd
);
HMENU GetSubMenu(	   
	HMENU hMenu,
	int nPos
);
DWORD CheckMenuItem(	  
	HMENU hmenu,
	UINT uIDCheckItem,
	UINT uCheck
);
BOOL SetDlgItemTextA(
	HWND hDlg,
	int nIDDlgItem,
	LPCSTR lpString
);
BOOL SetDlgItemTextW(
	HWND hDlg,
	int nIDDlgItem,
	LPCWSTR lpString
);
BOOL CheckRadioButton(		
	HWND hDlg,
	int nIDFirstButton,
	int nIDLastButton,
	int nIDCheckButton
);
HCURSOR SetCursor(		
	HCURSOR hCursor
);
BOOL TextOutA(
	HDC hDC,
	int x, int y,
	char* sz, int len);

int FillRect(
  HDC hDC,			// handle to DC
  RECT *lprc,		// rectangle
  HBRUSH hbr		// handle to brush
);

struct SLIST_ENTRY {
  SLIST_ENTRY *Next;
};

typedef SLIST_ENTRY *PSLIST_ENTRY;

PSLIST_ENTRY InterlockedPushEntrySList(
  PSLIST_HEADER ListHead,
  PSLIST_ENTRY ListEntry
);

PSLIST_ENTRY InterlockedPopEntrySList(
  PSLIST_HEADER ListHead
);

ULONGLONG VerSetConditionMask(
  ULONGLONG dwlConditionMask,
  DWORD dwTypeBitMask,
  BYTE dwConditionMask
);

int FreeLibrary(unsigned int hModule);
int VirtualFree(void* lpAddress, int dwSize, unsigned int dwFreeType);

HRSRC FindResourceA(HMODULE hModule, LPCSTR lpName, LPCSTR lpType);
HGLOBAL LoadResource(HMODULE hModule, HRSRC hResInfo);
LPVOID LockResource(HGLOBAL hResData);
DWORD GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer);
DWORD SizeofResource(HMODULE hModule, HRSRC hResInfo);
HINSTANCE ShellExecuteA(HWND hwnd, LPCSTR lpOperation, LPCSTR lpFile, LPCSTR lpParameters, LPCSTR lpDirectory, INT nShowCmd);

typedef struct {
  DWORD dwOSVersionInfoSize;
  DWORD dwMajorVersion;
  DWORD dwMinorVersion;
  DWORD dwBuildNumber;
  DWORD dwPlatformId;
  CHAR  szCSDVersion[128];
} OSVERSIONINFOA;

typedef struct {
  DWORD dwOSVersionInfoSize;
  DWORD dwMajorVersion;
  DWORD dwMinorVersion;
  DWORD dwBuildNumber;
  DWORD dwPlatformId;
  WCHAR szCSDVersion[128];
} OSVERSIONINFOW;

BOOL GetVersionExA(OSVERSIONINFOA *v);
BOOL GetVersionExW(OSVERSIONINFOW *v);

typedef struct {
  DWORD  dwOemId;
  DWORD  dwPageSize;
  LPVOID lpMinimumApplicationAddress;
  LPVOID lpMaximumApplicationAddress;
  DWORD  dwActiveProcessorMask;
  DWORD  dwNumberOfProcessors;
  DWORD  dwProcessorType;
  DWORD  dwReserved1;
  DWORD  dwReserved2;
} SYSTEM_INFO;

void GetSystemInfo(SYSTEM_INFO *sinf);

typedef struct {
  DWORD dwLength;      // sizeof(MEMORYSTATUS)
  DWORD dwMemoryLoad;  // % in use
  DWORD dwTotalPhys;
  DWORD dwAvailPhys;
  DWORD dwTotalPageFile;
  DWORD dwAvailPageFile;
  DWORD dwTotalVirtual;
  DWORD dwAvailVirtual;
} MEMORYSTATUS;

void GlobalMemoryStatus(MEMORYSTATUS *mst);

typedef struct {
  UINT MaxCharSize;
  BYTE DefaultChar[2]; // MAX_DEFAULTCHAR
  BYTE LeadByte[12];   // MAX_LEADBYTES
} CPINFO;

BOOL GetCPInfo(UINT uCodePage, CPINFO *lpCPInfo);

typedef void *HANDLE;

HANDLE RegisterEventSourceA(char *uncServerName, char *sourceName);
BOOL DeregisterEventSource(HANDLE eventLog);

typedef void *FARPROC;

FARPROC GetProcAddress(HANDLE module, char *procName);

LONG InterlockedExchange(LONG *target, LONG *val);

HINSTANCE LoadLibraryExA(LPCSTR lib, HANDLE file, DWORD flags);
HINSTANCE LoadLibraryExW(LPCWSTR lib, HANDLE file, DWORD flags);

int MultiByteToWideChar(UINT CodePage, DWORD dwFlags,
                        LPCSTR lpMultiByteStr, int cbMultiByte,
                        LPWSTR lpWideCharStr, int cchWideChar);

// long name causes assertion failure
// typedef DWORD ACCESS_MASK;
typedef DWORD ACC_MSK;

LONG RegOpenKeyExA(HANDLE hKey, LPCTSTR lpSubKey, DWORD ulOptions,
                  ACC_MSK regsam, HANDLE *phkResult);
LONG RegOpenKeyExW(HANDLE hKey, LPCTSTR lpSubKey, DWORD ulOptions,
                  ACC_MSK regsam, HANDLE *phkResult);
LONG RegCloseKey(HANDLE hKey);

void SetLastError(DWORD error);

void Sleep(DWORD milliseconds);

LPVOID HeapAlloc(HANDLE hHeap, DWORD dwFlags, DWORD dwBytes);

BOOL HeapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem);

DWORD GetModuleFileNameA(HMODULE hModule, LPSTR lpFilename, DWORD nSize);
DWORD GetModuleFileNameW(HMODULE hModule, LPWSTR lpFilename, DWORD nSize);

HANDLE GetStdHandle(DWORD nStdHandle);
BOOL   SetStdHandle(DWORD nStdHandle, HANDLE hHandle);

BOOL WriteFile(
    HANDLE hFile,
    LPCVOID lpBuffer,
    DWORD nNumberOfBytesToWrite,
    LPDWORD lpNumberOfBytesWritten,
    LPOVERLAPPED lpOverlapped
    );

LPVOID VirtualAlloc(
    LPVOID lpAddress,
    DWORD dwSize,
    DWORD flAllocationType,
    DWORD flProtect
    );

BOOL FlushFileBuffers(HANDLE hFile);

DWORD GetLastError(void);

DWORD
SetFilePointer(
    HANDLE hFile,
    LONG lDistanceToMove,
    PLONG lpDistanceToMoveHigh,
    DWORD dwMoveMethod
    );

BOOL CloseHandle(HANDLE hObject);
BOOL CheckMenuRadioItem(
    HMENU hmenu,
    UINT idFirst,
    UINT idLast,
    UINT idCheck,
    UINT uFlags
);

BOOL SetWindowTextA(
    HWND hWnd,
    LPCSTR lpString
);

BOOL SetWindowTextW(
    HWND hWnd,
    LPCWSTR lpString
);

HWND SetFocus(
    HWND hWnd
);

LPSTR lstrcpynA(
    LPSTR lpString1,
    LPCSTR lpString2,
    int iMaxLength
);

LPWSTR lstrcpynW(
    LPWSTR lpString1,
    LPCWSTR lpString2,
    int iMaxLength
);

LPSTR lstrcatA(
    LPSTR lpString1,
    LPSTR lpString2
);

LPWSTR lstrcatW(
    LPWSTR lpString1,
    LPWSTR lpString2
);

wchar_t *lstrcpyW(wchar_t *dst, wchar_t *src);

int lstrlenW( const wchar_t *string );

void _CxxThrowException(int a, int b);

BOOL DisableThreadLibraryCalls(
  HMODULE hModule
);

BOOL HeapDestroy(
  HANDLE hHeap
);

void DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
);

void InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection
);

typedef struct {
  DWORD cb;
  LPSTR lpReserved;
  LPSTR lpDesktop;
  LPSTR lpTitle;
  DWORD dwX;
  DWORD dwY;
  DWORD dwXSize;
  DWORD dwYSize;
  DWORD dwXCountChars;
  DWORD dwYCountChars;
  DWORD dwFillAttribute;
  DWORD dwFlags;
  WORD wShowWindow;
  WORD cbReserved2;
  LPBYTE lpReserved2;
  HANDLE hStdInput;
  HANDLE hStdOutput;
  HANDLE hStdError;
} STARTUPINFO;
typedef STARTUPINFO *LPSTARTUPINFO;

typedef struct {
  DWORD cb;
  LPWSTR lpReserved;
  LPWSTR lpDesktop;
  LPWSTR lpTitle;
  DWORD dwX;
  DWORD dwY;
  DWORD dwXSize;
  DWORD dwYSize;
  DWORD dwXCountChars;
  DWORD dwYCountChars;
  DWORD dwFillAttribute;
  DWORD dwFlags;
  WORD wShowWindow;
  WORD cbReserved2;
  LPBYTE lpReserved2;
  HANDLE hStdInput;
  HANDLE hStdOutput;
  HANDLE hStdError;
} STARTUPINFOW;
typedef STARTUPINFOW *LPSTARTUPINFOW;

void GetStartupInfo(LPSTARTUPINFO lpStartupInfo);
void GetStartupInfoW(LPSTARTUPINFOW lpStartupInfo);

HMODULE GetModuleHandle(LPCSTR lpModuleName);
HMODULE GetModuleHandleW(LPCWSTR lpModuleName);

void ExitProcess(UINT uExitCode);

BOOL PostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
BOOL PostMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);

typedef void *REFCLSID;
HRESULT SHLoadInProc(REFCLSID rclsid);

HWND FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName);
HWND FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName);

void Sleep(DWORD dwMilliseconds);

HMODULE LoadLibraryA(LPCSTR lpFileName);
HMODULE LoadLibraryW(LPCWSTR lpFileName);

ATOM FindAtomA(LPCSTR lpString);
ATOM FindAtomW(LPCWSTR lpString);
ATOM AddAtomA(LPCSTR lpString);
ATOM AddAtomW(LPCWSTR lpString);
UINT GetAtomNameA(ATOM nAtom, LPSTR lpBuffer, int nSize);
UINT GetAtomNameA(ATOM nAtom, LPWSTR lpBuffer, int nSize);

LONG InterlockedIncrement(LONG *Addend);

LONG InterlockedDecrement(LONG *Addend);


// guessed LPR functions

void CloseLPR(int a);
int GetShortQueue(int a, int b);
int GetLongQueue(int a, int b);
int OpenLPR(int a, int b);

LPVOID TlsGetValue(DWORD dwTlsIndex);
DWORD TlsAlloc(void);

BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue);

DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);

BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);

what my team could drag from the .exe in little time as we are pretty busy.. have fun
we will get the pure source code later and provide if you wish proof

[_Emme_]

#closed

[InfinityBoT]

ermm.. you forgot to actually close it ? :P

[<†>Minera<†>]

XD

[InfinityBoT]

inb4close

[Fir3andIc3]

Well well ppl donwload that **** and than cry in forum that someone hacked them ***** XD


SO LAST WARNING! THERE ARE NO DUPER TOOLS LIKE THIS ONE! AND IF U STILL DOWNLOAD IT .. STOP CRYING IN FORUMS !! ^^

[InfinityBoT]

no one cried in this thread yet :S.. but yhh in general i gues it applies XD

[Fir3andIc3]

Originally Posted by InfinityBoT

no one cried in this thread yet :S.. but yhh in general i gues it applies XD

in general i mean XD