__foldwin32sstuff __foldwin32sstuff;
foldstyleinitialization = true;


enablemapdirect1632 = true;
defaultholdwin16lock = true;

#include "types.thk"
#include "ImmTypes.thk"

BOOL Imm32Init(LPBYTE lpDGroup)
{
}

BOOL Imm32LoadIME(DWORD dwThreadLink, DWORD dwIMELink, DWORD dwIMEDDIs)
{
    releasewin16lock = true;
}

BOOL Imm32Configure(DWORD, HKL, HWND, DWORD, LPVOID, DWORD, BOOL)
{
    body=special;
    releasewin16lock = true;
}

DWORD Imm32ConversionList(DWORD, DWORD, HIMC, LPSTR, LPCANDIDATELIST lpDest, DWORD, UINT, BOOL)
{
    releasewin16lock = true;
    lpDest = output;
}

BOOL Imm32Destroy(DWORD, UINT)
{
    releasewin16lock = true;
}

LRESULT Imm32Escape(DWORD, HIMC, UINT, LPVOID lpData, DWORD, BOOL)
{
    releasewin16lock = true;
    lpData = output;
}

BOOL Imm32Notify(DWORD, HIMC, DWORD, DWORD, DWORD)
{
    releasewin16lock = true;
}

BOOL Imm32ProcessKey(DWORD, HIMC, UINT, LPARAM, LPBYTE)
{
    releasewin16lock = true;
}

BOOL Imm32Select(DWORD, HIMC, BOOL)
{
}

BOOL Imm32SetActiveContext(DWORD, HIMC, BOOL)
{
}

UINT Imm32SetCompositionString(DWORD, HIMC, DWORD, LPVOID, DWORD, LPVOID, DWORD)
{
    releasewin16lock = true;
}

UINT Imm32ToAsciiEx(DWORD, UINT, UINT, LPBYTE, LPDWORD lpTarnsKey, UINT, HIMC)
{
    releasewin16lock = true;
}

BOOL Imm32RegisterWord(DWORD, LPSTR, DWORD, LPSTR, DWORD, BOOL)
{
    releasewin16lock = true;
}

BOOL Imm32UnregisterWord(DWORD, LPSTR, DWORD, LPSTR, DWORD, BOOL)
{
    releasewin16lock = true;
}

UINT Imm32GetRegisterWordStyle(DWORD, UINT, LPSTYLEBUFA lpStyleBuf, DWORD, BOOL)
{
    releasewin16lock = true;
    lpStyleBuf = output;
}

UINT Imm32EnumRegisterWord(DWORD, DWORD, LPSTR, DWORD, LPSTR, LPVOID lpData, DWORD, BOOL)
{
    releasewin16lock = true;
    lpData = output;
}

DWORD ImmLockIMCLinear(HIMC)
{
    target = ImmLockIMC;
}

BOOL ImmUnlockIMCLinear(HIMC)
{
    target = ImmUnlockIMC;
}

DWORD ImmGetIMCSize(HIMC)
{
}

DWORD ImmGetIMCLockCount(HIMC)
{
}

HIMCC ImmCreateIMCC(DWORD)
{
}

HIMCC ImmDestroyIMCC(HIMCC)
{
}

DWORD ImmLockIMCCLinear(HIMCC)
{
    target = ImmLockIMCC;
}

BOOL ImmUnlockIMCCLinear(HIMCC)
{
    target = ImmUnlockIMCC;
}

DWORD ImmGetIMCCLockCount(HIMCC)
{
}

HIMCC ImmReSizeIMCC(HIMCC, DWORD)
{
}

DWORD ImmGetIMCCSize(HIMCC)
{
}

DWORD Imm32GlobalAlloc(UINT, DWORD)
{
}

DWORD Imm32GlobalFree(DWORD)
{
}

DWORD Imm32GlobalLockLinear(DWORD)
{
}

BOOL Imm32GlobalUnlockLinear(DWORD)
{
}

DWORD Imm32GlobalLockIMCLinear(HIMC, LPDWORD lplpIMC, LPDWORD lplpCompStr, LPDWORD lplpCandInfo, LPDWORD lplpPrivate, LPDWORD lplpMsgBuf)
{
    lplpIMC = output;
    lplpCompStr = output;
    lplpCandInfo = output;
    lplpPrivate = output;
    lplpMsgBuf = output;
}

DWORD Imm32GlobalUnlockIMCLinear(HIMC, HIMCC, HIMCC, HIMCC, HIMCC)
{
}

DWORD Imm32GetProcessHeap()
{
    releasewin16lock = true;
}

HIMC Imm32CreateContext(DWORD, DWORD, BOOL, DWORD, DWORD)
{
}

BOOL Imm32DestroyContext(HIMC, DWORD)
{
}

BOOL Imm32SelectContext(HIMC, DWORD)
{
}

LONG ImmGetCompositionStringA(HIMC, DWORD, LPVOID lpBuf, DWORD)
{
    releasewin16lock = true;
    lpBuf = output;
}

DWORD ImmGetCandidateListCountA(HIMC, LPDWORD lpNumList)
{
    releasewin16lock = true;
    lpNumList = output;
}

DWORD ImmGetCandidateListA(HIMC, DWORD, LPCANDIDATELIST lpCandList, DWORD)
{
    releasewin16lock = true;
    lpCandList = output;
}

BOOL ImmGetConversionStatus(HIMC, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence)
{
    releasewin16lock = true;
    lpfdwConversion = output;
    lpfdwSentence = output;
}

BOOL ImmGetOpenStatus(HIMC)
{
    releasewin16lock = true;
}

BOOL ImmGetCompositionFontA(HIMC, LPLOGFONT lpLogFont)
{
    releasewin16lock = true;
    lpLogFont = output;
}

DWORD ImmGetGuideLineA(HIMC, DWORD, LPSTR lpStr, DWORD)
{
    releasewin16lock = true;
    lpStr = output;
}

BOOL ImmGetStatusWindowPos(HIMC, LPPOINT lpptPos)
{
    releasewin16lock = true;
    lpptPos = output;
}

BOOL ImmGetCompositionWindow(HIMC, LPCOMPOSITIONFORM lpCompForm)
{
    releasewin16lock = true;
    lpCompForm = output;
}

BOOL ImmGetCandidateWindow(HIMC, DWORD, LPCANDIDATEFORM lpCandForm)
{
    releasewin16lock = true;
    lpCandForm = output;
}

UINT ImmGetVirtualKey(HWND)
{
    releasewin16lock = true;
}

DWORD ImmGetImeMenuItems32(HIMC, DWORD, DWORD, LPVOID, LPVOID lpBuf, DWORD) = 
DWORD ImmGetImeMenuItemsA(HIMC, DWORD, DWORD, LPVOID, LPVOID lpBuf, DWORD)
{
    releasewin16lock = true;
    lpBuf = output;
}

UINT ImmSetCompositionStringA(HIMC, DWORD, LPVOID, DWORD, LPVOID, DWORD)
{
    releasewin16lock = true;
}

INT ImmMultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPSTR lpSrc, int cchSrc, LPSTR lpDst, int cchDst )
{}

INT ImmWideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPSTR lpSrc, int cchSrc, LPSTR lpDst, int cchDst, LPSTR lpDefaultChar, LPINT lpUsedDefaultChar )
{}