diff --git a/app-emulation/wine/Manifest b/app-emulation/wine/Manifest
new file mode 100644
index 0000000..79d4233
--- /dev/null
+++ b/app-emulation/wine/Manifest
@@ -0,0 +1,9 @@
+AUX wine-1.1.15-winegcc.patch 1556 RMD160 ca7e0df0a45507e7d31ed81c5712111b83ed9bfa SHA1 4b155fe7cb5e831b7f92757d52aa1ab12569b232 SHA256 dbd89db561d7583faf317d795b8c11231575d885e21c6414add39079604dbd0d
+AUX wine-1.3.24-raw_input_mod.patch 26185 RMD160 dad5a38dfebb4dc7a8ee075e4290fa3c68e8501a SHA1 f8f02d66b06d9af56b2831b13747cb0972955ce4 SHA256 0bced642118e91955ea04b02964dde799065ecfb3ce9817b82319ff15333fd0f
+DIST wine-1.3.24.tar.bz2 19525444 RMD160 6567c8cbc646f5f447375046c3f25b4036689a58 SHA1 cc0dfc2255d1bc19e1975e5e2f680740d9c2825a SHA256 5ded950c14989feb248333d2ed43e35c06fe13c55db35c4c8baa54d9b298ee9b
+DIST wine_gecko-1.2.0-x86.msi 12604928 RMD160 089447eb59eea81c7b1b3d1896a20fe68586cd96 SHA1 6964d1877668ab7da07a60f6dcf23fb0e261a808 SHA256 d6ccdb32b5867df207c7cd89513297ceb89cfa93696bece470467845c6c4d3ee
+DIST wine_gecko-1.2.0-x86_64.msi 12841472 RMD160 7a6a82772da22a1bc77a2edd7e96b4345b082150 SHA1 3ac3c3e880e40f7763824866372ffc56128f0abd SHA256 ef6a105bcd5a66c0ebe28e8c813de284453a62b277af544e7710a8de8c4e8d8d
+DIST winepulse-0.40.patch 103596 RMD160 3681b5bc5886d9b8e3891d0d86c904b252e32c52 SHA1 cffdaea529f6a085bbf47d911c0733c8338d39e6 SHA256 ac38d617ed44bab4f8cb78f6b23bde0c376d555bd2f2546653cbe68503cfe80f
+DIST winepulse-configure.ac-1.3.22.patch 2763 RMD160 cc10e67124ac429c9b1d75e90643835b7f521b46 SHA1 143017cdfdd4270b7da0eea3283bc2098789a0b3 SHA256 691438f7c04e33ce1d43acb47dc26129b41d46cd4a1461bd3fc4d3becc7e7b14
+DIST winepulse-winecfg-1.3.11.patch 1781 RMD160 1659eaaa43ab630e29a1542f97c158aad1cd8a80 SHA1 212f436367c75bbf3060874739a08e0741a3d711 SHA256 2458c3b52b92587a93161b0d07e4fbef4f621a37ae63981007ec5a9ac8edabae
+EBUILD wine-1.3.24-r9999.ebuild 6275 RMD160 27e505c090cc423652048e639855bdd7ad3825c1 SHA1 0502269899a3eea229829ae73a38f6b176e036bb SHA256 dcb78f945b47ca2c67e7d67c6590f87f7768ddd1aa9a2a24db5ac5881938038d
diff --git a/app-emulation/wine/files/wine-1.1.15-winegcc.patch b/app-emulation/wine/files/wine-1.1.15-winegcc.patch
new file mode 100644
index 0000000..a1cd890
--- /dev/null
+++ b/app-emulation/wine/files/wine-1.1.15-winegcc.patch
@@ -0,0 +1,55 @@
+http://bugs.gentoo.org/260726
+
+--- wine-1.1.15/tools/winegcc/winegcc.c
++++ wine-1.1.15/tools/winegcc/winegcc.c
+@@ -215,10 +215,13 @@
+     strarray* files;
+ };
+ 
++#undef FORCE_POINTER_SIZE
+ #ifdef __i386__
+ static const enum target_cpu build_cpu = CPU_x86;
++#define FORCE_POINTER_SIZE
+ #elif defined(__x86_64__)
+ static const enum target_cpu build_cpu = CPU_x86_64;
++#define FORCE_POINTER_SIZE
+ #elif defined(__sparc__)
+ static const enum target_cpu build_cpu = CPU_SPARC;
+ #elif defined(__ALPHA__)
+@@ -968,6 +971,9 @@
+     opts.linker_args = strarray_alloc();
+     opts.compiler_args = strarray_alloc();
+     opts.winebuild_args = strarray_alloc();
++#ifdef FORCE_POINTER_SIZE
++    opts.force_pointer_size = sizeof(size_t);
++#endif
+ 
+     /* determine the processor type */
+     if (strendswith(argv[0], "winecpp")) opts.processor = proc_cpp;
+--- wine-1.1.15/tools/winebuild/main.c
++++ wine-1.1.15/tools/winebuild/main.c
+@@ -50,10 +50,13 @@
+ int link_ext_symbols = 0;
+ int force_pointer_size = 0;
+ 
++#undef FORCE_POINTER_SIZE
+ #ifdef __i386__
+ enum target_cpu target_cpu = CPU_x86;
++#define FORCE_POINTER_SIZE
+ #elif defined(__x86_64__)
+ enum target_cpu target_cpu = CPU_x86_64;
++#define FORCE_POINTER_SIZE
+ #elif defined(__sparc__)
+ enum target_cpu target_cpu = CPU_SPARC;
+ #elif defined(__ALPHA__)
+@@ -574,6 +577,10 @@
+     signal( SIGTERM, exit_on_signal );
+     signal( SIGINT, exit_on_signal );
+ 
++#ifdef FORCE_POINTER_SIZE
++    force_pointer_size = sizeof(size_t);
++#endif
++
+     output_file = stdout;
+     argv = parse_options( argc, argv, spec );
+ 
diff --git a/app-emulation/wine/files/wine-1.3.24-raw_input_mod.patch b/app-emulation/wine/files/wine-1.3.24-raw_input_mod.patch
new file mode 100644
index 0000000..5f0de26
--- /dev/null
+++ b/app-emulation/wine/files/wine-1.3.24-raw_input_mod.patch
@@ -0,0 +1,924 @@
+diff --git a/dlls/user32/Makefile.in b/dlls/user32/Makefile.in
+index d2cdc92..7fd804e 100644
+--- a/dlls/user32/Makefile.in
++++ b/dlls/user32/Makefile.in
+@@ -1,7 +1,7 @@
+ EXTRADEFS = -D_USER32_ -D_WINABLE_
+ MODULE    = user32.dll
+ IMPORTLIB = user32
+-IMPORTS   = gdi32 version advapi32
++IMPORTS   = gdi32 version advapi32 dinput8 dinput dxguid
+ DELAYIMPORTS = imm32
+ 
+ C_SRCS = \
+diff --git a/dlls/user32/input.c b/dlls/user32/input.c
+index 06553a4..a8ed77e 100644
+--- a/dlls/user32/input.c
++++ b/dlls/user32/input.c
+@@ -22,6 +22,15 @@
+  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+  */
+ 
++/*
++ * Updated by Vincas Miliūnas 2011
++ * Modififed by Reco 2009
++ * patch is based on
++ * http://win2kgaming.site90.com/phpBB2/viewtopic.php?f=6&t=7
++ * OldCigarettes Windows 2000 XP API Wrapper Pack
++ * Released under LGPL
++ */
++
+ #include "config.h"
+ #include "wine/port.h"
+ 
+@@ -48,6 +57,383 @@
+ #include "wine/server.h"
+ #include "wine/debug.h"
+ #include "wine/unicode.h"
++#include "dinput.h"
++
++
++static HANDLE hHeap = NULL;
++
++typedef struct _myNode
++{
++    DWORD data;
++    struct _myNode * next;
++} myNode;
++
++typedef struct
++{
++    myNode * head;
++    myNode * tail;
++    long length;
++    HANDLE lockMutex;
++} myList;
++
++
++__inline void GetLock(myList * l)
++{
++    WaitForSingleObject(l->lockMutex, INFINITE);
++}
++
++__inline void ReleaseLock(myList * l)
++{
++    ReleaseMutex(l->lockMutex);
++}
++
++
++__inline void InitializeList(myList ** l)
++{
++    *l = HeapAlloc(hHeap, 0, sizeof(myList));
++    (*l)->head = NULL;
++    (*l)->tail = NULL;
++    (*l)->length = 0;
++    (*l)->lockMutex = CreateMutexA(NULL, FALSE, NULL);
++}
++
++
++__inline void PushFrontByAddr(myList * l, myNode * nouv)
++{
++    if(!l->head)
++        l->tail = nouv;
++
++    nouv->next = l->head;
++    l->head = nouv;
++    l->length++;
++}
++
++__inline void PushBackByAddr(myList * l, myNode * nouv)
++{
++    if(!l->head)
++    {
++        nouv->next = NULL;
++        l->tail = nouv;
++        l->head = nouv;
++    }
++    else
++    {
++        nouv->next = NULL;
++        l->tail->next = nouv;
++        l->tail = nouv;
++    }
++    l->length++;
++}
++
++__inline void PushFrontByVal(myList * l, DWORD data)
++{
++    myNode * nouv = NULL;
++    nouv = HeapAlloc(hHeap, 0, sizeof(myNode));
++    nouv->next = l->head;
++    nouv->data = data;
++
++    if(!l->head)
++        l->tail = nouv;
++
++    l->head = nouv;
++    l->length++;
++}
++
++__inline void PushBackByVal(myList * l, DWORD data)
++{
++    myNode * nouv = NULL;
++    nouv = HeapAlloc(hHeap, 0, sizeof(myNode));
++    nouv->data = data;
++
++    if(!l->head)
++    {
++        nouv->next = NULL;
++        l->tail = nouv;
++        l->head = nouv;
++    }
++    else
++    {
++        nouv->next = NULL;
++        l->tail->next = nouv;
++        l->tail = nouv;
++    }
++    l->length++;
++}
++
++__inline void RemoveNodeByVal(myList * l, DWORD data)
++{
++    myNode * temp = NULL;
++    myNode * cour = NULL;
++    myNode ** prec = NULL;
++
++    cour = l->head;
++    prec = &l->head;
++
++    while(cour)
++    {
++        if(cour->data == data)
++        {
++            temp = cour->next;
++
++            HeapFree(hHeap, 0, cour);
++
++            *prec = temp;
++            cour = temp;
++            l->length--;
++        }
++        else
++        {
++            prec = &(cour->next);
++            cour = cour->next;
++        }
++    }
++}
++
++__inline void RemoveNodeByAddr(myList * l, myNode * node)
++{
++    myNode * temp = NULL;
++    myNode * cour = NULL;
++    myNode ** prec = NULL;
++
++    cour = l->head;
++    prec = &l->head;
++
++    while(cour)
++    {
++        if(cour == node)
++        {
++            temp = cour->next;
++
++            HeapFree(hHeap, 0, cour);
++
++            *prec = temp;
++            cour = temp;
++            l->length--;
++        }
++        else
++        {
++            prec = &(cour->next);
++            cour = cour->next;
++        }
++    }
++}
++
++
++__inline DWORD PopFrontAndFree(myList * l)
++{
++    myNode * res = NULL;
++	DWORD data = 0;
++
++    if(l->head && l->head == l->tail)
++    {
++        res = l->head;
++        l->head = NULL;
++        l->tail = NULL;
++        l->length = 0;
++    }
++    else if(l->head)
++    {
++        res = l->head;
++        l->head = res->next;
++        l->length--;
++    }
++
++	//win2000 finds bug here!!!!
++
++    if(res) {
++		data = res->data;
++        HeapFree(hHeap, 0, res);
++	}
++
++	return data;
++}
++
++
++__inline void PopBackAndFree(myList * l)
++{
++    myNode *res = NULL, *cour = NULL, *prec = NULL;
++
++    if(l->head && l->head == l->tail)
++    {
++        res = l->head;
++        l->head = NULL;
++        l->tail = NULL;
++        l->length = 0;
++    }
++    else if(l->tail)
++    {
++        cour = l->head;
++        prec = l->head;
++        while(cour->next)
++        {
++            prec = cour;
++            cour = cour->next;
++        }
++
++        res = l->tail;
++        l->tail = prec;
++        l->length--;
++    }
++
++    if(res)
++        HeapFree(hHeap, 0, res);
++}
++
++
++
++__inline myNode * PopFront(myList * l)
++{
++    myNode * res = NULL;
++
++    if(l->head && l->head == l->tail)
++    {
++        res = l->head;
++        l->head = NULL;
++        l->tail = NULL;
++        l->length = 0;
++    }
++    else if(l->head)
++    {
++        res = l->head;
++        l->head = res->next;
++        l->length--;
++    }
++
++    return res;
++}
++
++
++__inline myNode * PopBack(myList * l)
++{
++    myNode *res = NULL, *cour = NULL, *prec = NULL;
++
++    if(l->head && l->head == l->tail)
++    {
++        res = l->head;
++        l->head = NULL;
++        l->tail = NULL;
++        l->length = 0;
++    }
++    else if(l->tail)
++    {
++        cour = l->head;
++        prec = l->head;
++        while(cour->next)
++        {
++            prec = cour;
++            cour = cour->next;
++        }
++
++        res = l->tail;
++        prec->next = NULL;
++        l->tail = prec;
++        l->length--;
++    }
++
++    return res;
++}
++
++
++__inline BOOL IsInListByVal(myList * l, DWORD data)
++{
++    myNode * cour = NULL;
++    BOOL found = FALSE;
++
++    cour = l->head;
++    while(cour && !found)
++    {
++        found = (cour->data == data);
++        cour = cour->next;
++    }
++
++    return found;
++}
++
++
++__inline BOOL IsInListByAddr(myList * l, myNode * node)
++{
++    myNode * cour = NULL;
++    BOOL found = FALSE;
++
++    cour = l->head;
++    while(cour && !found)
++    {
++        found = (cour == node);
++        cour = cour->next;
++    }
++
++    return found;
++}
++
++
++__inline void FreeList(myList ** l)
++{
++    while((*l)->length)
++        PopFrontAndFree(*l);
++
++    CloseHandle((*l)->lockMutex);
++    HeapFree(hHeap, 0, *l);
++    *l = NULL;
++}
++
++/*Mode select*/
++BOOL UseDirectInput = TRUE;
++
++/*List of raw input data for each window*/
++static myList * rawMouseInputWindowList    = NULL;
++static myList * rawKeyboardInputWindowList = NULL;
++static myList * rawInputHandleList         = NULL;
++
++/*HOOK HANDLES*/
++static HHOOK rawInputMouseHook    = NULL;
++static HHOOK rawInputKeyboardHook = NULL;
++static BOOL  mouseFirstRun        = TRUE;
++
++//X,Y coords to create relative movement of mouse from low level hook
++static LONG mouseHookLastX = 0, mouseHookLastY = 0;
++
++/*DirectInput data*/
++LPDIRECTINPUT8A         lpdi            = NULL;
++LPDIRECTINPUTDEVICE8A   m_mouse         = NULL;
++LPDIRECTINPUTDEVICE8A   m_keyboard      = NULL;
++HANDLE                 mouseInputEvent = NULL;
++
++BOOL                   b_registered_mouse;
++BOOL                   b_registered_keyboard;
++RAWINPUTDEVICE         rid_mouse;
++RAWINPUTDEVICE         rid_keyboard;
++
++//Only keep so many rawinput structures
++#define RAWINPUTHANDLETABLESIZE     32
++
++#define RIM_TYPEMOUSE        0
++#define RIM_INPUT          0x00000000
++#define MOUSE_MOVE_RELATIVE      0x00000000
++#define MOUSE_MOVE_ABSOLUTE      0x00000001
++#define MOUSE_VIRTUAL_DESKTOP	 0x00000002
++#define RI_MOUSE_LEFT_BUTTON_DOWN  0x0001
++#define RI_MOUSE_LEFT_BUTTON_UP    0x0002
++#define RI_MOUSE_RIGHT_BUTTON_DOWN 0x0004
++#define RI_MOUSE_RIGHT_BUTTON_UP 0x0008
++#define RI_MOUSE_MIDDLE_BUTTON_DOWN  0x0010
++#define RI_MOUSE_MIDDLE_BUTTON_UP  0x0020
++#define RI_MOUSE_BUTTON_1_DOWN     RI_MOUSE_LEFT_BUTTON_DOWN
++#define RI_MOUSE_BUTTON_1_UP   RI_MOUSE_LEFT_BUTTON_UP
++#define RI_MOUSE_BUTTON_2_DOWN   RI_MOUSE_RIGHT_BUTTON_DOWN
++#define RI_MOUSE_BUTTON_2_UP   RI_MOUSE_RIGHT_BUTTON_UP
++#define RI_MOUSE_BUTTON_3_DOWN   RI_MOUSE_MIDDLE_BUTTON_DOWN
++#define RI_MOUSE_BUTTON_3_UP   RI_MOUSE_MIDDLE_BUTTON_UP
++#define RI_MOUSE_BUTTON_4_DOWN   0x0040
++#define RI_MOUSE_BUTTON_4_UP   0x0080
++#define RI_MOUSE_BUTTON_5_DOWN   0x0100
++#define RI_MOUSE_BUTTON_5_UP   0x0200
++#define RI_MOUSE_WHEEL       0x0400
++#define RIDEV_INPUTSINK        0x00000100
++#define MOUSE_DEVICE_HANDLE      0x1337
++#define RID_INPUT 0x10000003
++#define RID_HEADER 0x10000005
++#define RIDEV_REMOVE 0x00000001
++#define RIDEV_CAPTUREMOUSE 0x00000200
+ 
+ WINE_DEFAULT_DEBUG_CHANNEL(win);
+ WINE_DECLARE_DEBUG_CHANNEL(keyboard);
+@@ -490,30 +876,439 @@ UINT WINAPI GetRawInputDeviceList(PRAWINPUTDEVICELIST pRawInputDeviceList, PUINT
+     return 0;
+ }
+ 
++void SetRawInputMouseHeader(RAWINPUT *ri) {
++	ri->header.dwType = RIM_TYPEMOUSE;
++    ri->header.dwSize = sizeof(RAWINPUT);
++    ri->header.hDevice = MOUSE_DEVICE_HANDLE;
++    ri->header.wParam = RIM_INPUT;
++	return;
++}
++
++RAWINPUT *GetDirectInputMouseData() {
++	static DIMOUSESTATE2 mouse_state;
++	static DIMOUSESTATE2 mouse_state_prev;
++	RAWINPUT *raw;
++	HRESULT hr;
++	int i;
++
++	raw = (RAWINPUT*)HeapAlloc(hHeap, 0, sizeof(RAWINPUT));
++	SetRawInputMouseHeader(raw);
++
++	//Try to get input, and maybe reaquire input
++	hr = m_mouse->lpVtbl->GetDeviceState(m_mouse, sizeof(DIMOUSESTATE2), (LPVOID)&mouse_state);
++	if(FAILED(hr)) {
++		m_mouse->lpVtbl->Acquire(m_mouse);
++		while(hr == DIERR_INPUTLOST) {
++			hr = m_mouse->lpVtbl->Acquire(m_mouse);
++		}
++		if(FAILED(hr)) {
++			HeapFree(hHeap, 0, raw);
++			return NULL;
++		}
++		m_mouse->lpVtbl->GetDeviceState(m_mouse, sizeof(DIMOUSESTATE2), (LPVOID)&mouse_state);
++	}
++
++	raw->data.mouse.usFlags = MOUSE_MOVE_RELATIVE;
++	raw->data.mouse.lLastX = mouse_state.lX;
++	raw->data.mouse.lLastY = mouse_state.lY;
++	raw->data.mouse.usButtonData = mouse_state.lZ & 0xFFFF;
++	raw->data.mouse.usButtonFlags = 0;
++	raw->data.mouse.ulRawButtons = 0;
++
++	if(raw->data.mouse.usButtonData != 0) raw->data.mouse.usButtonFlags |= RI_MOUSE_WHEEL;
++
++	for(i = 0; i < 8; i++) {
++		if(mouse_state.rgbButtons[i] & 0x80) {
++			raw->data.mouse.ulRawButtons |= 1<<i;
++		}
++	}
++
++	if(mouse_state.rgbButtons[0] & 0x80 && !(mouse_state_prev.rgbButtons[0] & 0x80))
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_LEFT_BUTTON_DOWN;
++
++	if(!(mouse_state.rgbButtons[0] & 0x80) && mouse_state_prev.rgbButtons[0] & 0x80)
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_LEFT_BUTTON_UP;
++
++	if(mouse_state.rgbButtons[1] & 0x80 && !(mouse_state_prev.rgbButtons[1] & 0x80))
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_RIGHT_BUTTON_DOWN;
++
++	if(!(mouse_state.rgbButtons[1] & 0x80) && mouse_state_prev.rgbButtons[1] & 0x80)
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_RIGHT_BUTTON_UP;
++
++	if(mouse_state.rgbButtons[2] & 0x80 && !(mouse_state_prev.rgbButtons[2] & 0x80))
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_MIDDLE_BUTTON_DOWN;
++
++	if(!(mouse_state.rgbButtons[2] & 0x80) && mouse_state_prev.rgbButtons[2] & 0x80)
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_MIDDLE_BUTTON_UP;
++
++	if(mouse_state.rgbButtons[3] & 0x80 && !(mouse_state_prev.rgbButtons[3] & 0x80))
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_4_DOWN;
++
++	if(!(mouse_state.rgbButtons[3] & 0x80) && mouse_state_prev.rgbButtons[3] & 0x80)
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_4_UP;
++
++	if(mouse_state.rgbButtons[4] & 0x80 && !(mouse_state_prev.rgbButtons[4] & 0x80))
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_5_DOWN;
++
++	if(!(mouse_state.rgbButtons[4] & 0x80) && mouse_state_prev.rgbButtons[4] & 0x80)
++		raw->data.mouse.usButtonFlags |= RI_MOUSE_BUTTON_5_UP;
++
++	memcpy(&mouse_state_prev, &mouse_state, sizeof(DIMOUSESTATE2));
++
++	return raw;
++}
++
++VOID AddRawInputToWindowList(RAWINPUT *ri, myList *windowList) {
++	myNode * cour = NULL;
++	GetLock(rawInputHandleList);
++
++	//Remove old rawinputs
++	if(rawInputHandleList && rawInputHandleList->length > RAWINPUTHANDLETABLESIZE)
++		HeapFree(hHeap, 0, (RAWINPUT *)PopFrontAndFree(rawInputHandleList));
++
++	//Add this new RAWINPUT
++    PushBackByVal(rawInputHandleList, (DWORD)ri);
++
++    GetLock(windowList);
++    for(cour = windowList->head; cour; cour = cour->next) {
++		PostMessageA((HWND)cour->data, WM_INPUT, RIM_INPUT, (LPARAM)ri);
++    }
++    ReleaseLock(windowList);
++	ReleaseLock(rawInputHandleList);
++	return;
++}
++
++//Mouse and Keyboard seperate just to simplify things a bit
++DWORD WINAPI PollDirectInputMouse(PVOID data) {
++	RAWINPUT *raw;
++	for(;;) {
++		if(WaitForSingleObject(mouseInputEvent, 1000*2) != WAIT_ABANDONED) {
++			raw = GetDirectInputMouseData();
++			if(raw) AddRawInputToWindowList(raw, rawMouseInputWindowList);
++		}
++	}
++	return 0;
++}
++
++BOOL RegisterDirectInputMouse(PRAWINPUTDEVICE pRawInputDevices, HWND hWnd) {
++	HRESULT hr;
++	DWORD flags;
++
++	//Try to map these flags to DirectX
++	flags = 0;
++	if(pRawInputDevices->dwFlags & RIDEV_INPUTSINK) flags |= DISCL_BACKGROUND;
++	else                                            flags |= DISCL_FOREGROUND;
++	flags |= DISCL_NONEXCLUSIVE;
++
++	//Init DirectInput if nessecary
++	if (lpdi == NULL && FAILED(DirectInput8Create(GetModuleHandleA(NULL), DIRECTINPUT_VERSION, &IID_IDirectInput8A, (void**)&lpdi, NULL))) {
++		ERR("user32: Failed to create DirectInput interface\n");
++		return FALSE;
++	}
++
++	//Init MouseDevice if nessecary
++	if (m_mouse == NULL && FAILED(lpdi->lpVtbl->CreateDevice(lpdi, &GUID_SysMouse, &m_mouse, NULL))) {
++		ERR("user32: Failed to create DirectInput mouse device\n");
++		return FALSE;
++	}
++
++	//Make friendly with this hWnd
++	if (FAILED(m_mouse->lpVtbl->SetCooperativeLevel(m_mouse, hWnd, flags))) {
++		ERR("user32: Failed to set cooperative level on DirectInput mouse device\n");
++		return FALSE;
++	}
++
++	if (FAILED(m_mouse->lpVtbl->SetDataFormat(m_mouse, &c_dfDIMouse2))) {
++		ERR("user32: Failed to set data format on DirectInput mouse device\n");
++		return FALSE;
++	}
++
++	if(!mouseInputEvent) {
++		HANDLE handle;
++
++		mouseInputEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
++		if(!mouseInputEvent) {
++			ERR("user32: Failed to create event for DirectInput mouse\n");
++			return FALSE;
++		}
++
++		handle = CreateThread(NULL, 0, PollDirectInputMouse, NULL, 0, NULL);
++		if(!handle) {
++			ERR("user32: Failed to create polling thread for DirectInput mouse\n");
++			return FALSE;
++		}
++
++		if(!SetThreadAffinityMask(handle, 1)) {
++			ERR("user32: Failed to set thread affinity mask for the DirectInput mouse polling thread\n");
++			return FALSE;
++		}
++
++	}
++
++	//Must be NOT be acquired to SetEventNotification
++	m_mouse->lpVtbl->Unacquire(m_mouse);
++	if(FAILED(m_mouse->lpVtbl->SetEventNotification(m_mouse, mouseInputEvent))) {
++		ERR("user32: Failed to SetEventNotification for DirectInput mouse\n");
++		return FALSE;
++	}
++
++	return TRUE;
++}
++
++//SetWindowsHookEx WH_MOUSE_LL handler
++LRESULT CALLBACK myLowLevelMouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
++    static ULONG ulRawButtons = 0;
++    RAWMOUSE *rm = NULL;
++    RAWINPUT *ri = NULL;
++    MSLLHOOKSTRUCT * hs = (MSLLHOOKSTRUCT*)lParam;
++
++    if(nCode == HC_ACTION) { //Should always be true
++        ri = (RAWINPUT*)HeapAlloc(hHeap, 0, sizeof(RAWINPUT));
++        if(ri) {
++			SetRawInputMouseHeader(ri);
++
++            rm = &ri->data.mouse;
++            if(mouseFirstRun) { //first time around give the absolute position
++                rm->usFlags = MOUSE_MOVE_ABSOLUTE;
++                rm->lLastX = hs->pt.x;
++                rm->lLastY = hs->pt.y;
++            } else {
++                rm->usFlags = MOUSE_MOVE_RELATIVE;
++                if(hs->flags & LLMHF_INJECTED) {
++                    rm->lLastX = 0;
++                    rm->lLastY = 0;
++                } else {
++                    rm->lLastX = (LONG)hs->pt.x - mouseHookLastX;
++                    rm->lLastY = (LONG)hs->pt.y - mouseHookLastY;
++                }
++            }
++
++            mouseHookLastX = hs->pt.x;
++            mouseHookLastY = hs->pt.y;
++
++            rm->ulButtons = 0;
++            rm->usButtonData = 0;
++            rm->usButtonFlags = 0;
++            rm->ulExtraInformation = 0;
++
++			//note ulRawButtons is static and we keep track of the state of the buttons this way
++            switch(wParam)
++            {
++                case WM_LBUTTONDOWN:
++                    rm->usButtonFlags |= RI_MOUSE_LEFT_BUTTON_DOWN;
++                    ulRawButtons |= 0x00000001;
++                    break;
++
++                case WM_LBUTTONUP:
++                    rm->usButtonFlags |= RI_MOUSE_LEFT_BUTTON_UP;
++                    ulRawButtons &= ~0x00000001;
++                    break;
++
++                case WM_RBUTTONDOWN:
++                    rm->usButtonFlags |= RI_MOUSE_RIGHT_BUTTON_DOWN;
++                    ulRawButtons |= 0x00000002;
++                    break;
++
++                case WM_RBUTTONUP:
++                    rm->usButtonFlags |= RI_MOUSE_RIGHT_BUTTON_UP;
++                    ulRawButtons &= ~0x00000002;
++                    break;
++
++                case WM_MBUTTONDOWN:
++                    rm->usButtonFlags |= RI_MOUSE_MIDDLE_BUTTON_DOWN;
++                    ulRawButtons |= 0x00000004;
++                    break;
++
++                case WM_MBUTTONUP:
++                    rm->usButtonFlags |= RI_MOUSE_MIDDLE_BUTTON_UP;
++                    ulRawButtons &= ~0x00000004;
++                    break;
++
++                case WM_MOUSEWHEEL:
++                    rm->usButtonFlags |= RI_MOUSE_WHEEL;
++                    rm->usButtonData = HIWORD(hs->mouseData);
++                    break;
++
++				case WM_XBUTTONDOWN:
++					if(HIWORD(hs->mouseData) == XBUTTON1)      rm->usButtonFlags |= RI_MOUSE_BUTTON_4_DOWN;
++					else if(HIWORD(hs->mouseData) == XBUTTON2) rm->usButtonFlags |= RI_MOUSE_BUTTON_5_DOWN;
++					ulRawButtons |= (1 << (HIWORD(hs->mouseData) + 2));
++					break;
++
++				case WM_XBUTTONUP:
++					if(HIWORD(hs->mouseData) == XBUTTON1)      rm->usButtonFlags |= RI_MOUSE_BUTTON_4_UP;
++					else if(HIWORD(hs->mouseData) == XBUTTON2) rm->usButtonFlags |= RI_MOUSE_BUTTON_5_UP;
++					ulRawButtons &= ~(1 << (HIWORD(hs->mouseData) + 2));
++					break;
++            }
++            rm->ulRawButtons = ulRawButtons;
++
++            if(!mouseFirstRun) {
++				AddRawInputToWindowList(ri, rawMouseInputWindowList);
++            } else {
++				mouseFirstRun = FALSE;
++			}
++        }
++    }
++
++    return CallNextHookEx(rawInputMouseHook, nCode, wParam, lParam);
++}
++
++VOID DeRegisterDirectInputMouse() {
++	m_mouse->lpVtbl->Unacquire(m_mouse);
++	m_mouse->lpVtbl->SetEventNotification(m_mouse, NULL);
++}
+ 
+ /******************************************************************
+ *		RegisterRawInputDevices (USER32.@)
+ */
+-BOOL WINAPI DECLSPEC_HOTPATCH RegisterRawInputDevices(PRAWINPUTDEVICE pRawInputDevices, UINT uiNumDevices, UINT cbSize)
+-{
+-    FIXME("(pRawInputDevices=%p, uiNumDevices=%d, cbSize=%d) stub!\n", pRawInputDevices, uiNumDevices, cbSize);
++BOOL WINAPI RegisterRawInputDevices(PRAWINPUTDEVICE pRawInputDevices, UINT uiNumDevices, UINT cbSize) {
++    int i;
++	HWND hWnd;
++
++	hHeap = GetProcessHeap();
++	if(!rawMouseInputWindowList) InitializeList(&rawMouseInputWindowList);
++	if(!rawKeyboardInputWindowList) InitializeList(&rawKeyboardInputWindowList);
++	if(!rawInputHandleList) InitializeList(&rawInputHandleList);
++
++    if(!pRawInputDevices || !uiNumDevices || !cbSize) {
++        SetLastError(ERROR_INVALID_PARAMETER);
++        return FALSE;
++    }
++
++    for(i=0; i<uiNumDevices; i++) {
++		//Get the window handle if we need to
++		hWnd = pRawInputDevices[i].hwndTarget;
++		if(!hWnd) hWnd = GetFocus();
++		if(!hWnd) hWnd = GetForegroundWindow(); //try this too
++		if(!hWnd) {
++			ERR("user32: couldn't get HWND for RegisterRawInputDevices\n");
++			return FALSE;
++		}
++
++        // Mouse input
++        if(pRawInputDevices[i].usUsagePage==1 && pRawInputDevices[i].usUsage==2) { //Mouse should match this
++          GetLock(rawMouseInputWindowList);
++          if(!(pRawInputDevices[i].dwFlags & RIDEV_REMOVE)) {
++				//Add
++				TRACE("user32: Adding a RAWINPUT mouse\n");
++
++                if(pRawInputDevices[i].dwFlags & RIDEV_CAPTUREMOUSE)
++                    SetCapture(hWnd);
++				//Add the hWnd to the list
++                if(!IsInListByVal(rawMouseInputWindowList, (DWORD)hWnd))
++                    PushFrontByVal(rawMouseInputWindowList, (DWORD)hWnd);
++
++				//If not getting low level data yet activate
++				if(UseDirectInput) {
++					if(!RegisterDirectInputMouse(&pRawInputDevices[i], hWnd))
++						ERR("user32: Could not register DirectInput mouse\n");
++                } else if(!rawInputMouseHook) {
++                    rawInputMouseHook = SetWindowsHookExA(WH_MOUSE_LL, myLowLevelMouseProc, GetModuleHandleA("user32.dll"), 0);
++					if(!rawInputMouseHook)
++						ERR("user32: Could not SetWindowsHookEx WH_MOUSE_LL LastError=0x%X\n", GetLastError());
++				}
++				//Save this structure to return with GetRegisteredRawInputDevices
++				b_registered_mouse = TRUE;
++				memcpy(&rid_mouse, &pRawInputDevices[i], sizeof(RAWINPUTDEVICE));
++            } else {
++				//Remove
++				TRACE("user32: Removing a RAWINPUT mouse\n");
++
++                if(pRawInputDevices[i].hwndTarget) {
++					//This actually is not allowed
++                    RemoveNodeByVal(rawMouseInputWindowList, (DWORD)pRawInputDevices[i].hwndTarget);
++                } else {
++					//Remove dem all!
++                    while(rawMouseInputWindowList->length)
++                        PopFrontAndFree(rawMouseInputWindowList);
++                }
++
++                ReleaseCapture();
++
++				if(rawMouseInputWindowList->length==0) {
++					if(UseDirectInput) {
++						DeRegisterDirectInputMouse();
++					} else if(rawInputMouseHook) {
++						UnhookWindowsHookEx(rawInputMouseHook);
++						rawInputMouseHook = NULL;
++					}
++				}
++
++				b_registered_mouse = FALSE;
++            }
++          ReleaseLock(rawMouseInputWindowList);
++        }
++
++    }
+ 
+     return TRUE;
+ }
+ 
+-
+ /******************************************************************
+ *		GetRawInputData (USER32.@)
+ */
+-UINT WINAPI GetRawInputData(HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader)
+-{
+-    FIXME("(hRawInput=%p, uiCommand=%d, pData=%p, pcbSize=%p, cbSizeHeader=%d) stub!\n",
+-            hRawInput, uiCommand, pData, pcbSize, cbSizeHeader);
++UINT WINAPI GetRawInputData(HRAWINPUT hRawInput, UINT uiCommand, LPVOID pData, PUINT pcbSize, UINT cbSizeHeader) {
++    UINT res = 0;
++    RAWINPUT *ri = (RAWINPUT*)hRawInput;
++
++	if(cbSizeHeader != sizeof(RAWINPUTHEADER)) {
++		ERR("user32: sizeof(RAWINPUTHEADER) does not match expected\n");
++	}
++
++  GetLock(rawInputHandleList);
++
++	//Ain't in the list no more
++    if(!hRawInput || !IsInListByVal(rawInputHandleList, (DWORD)hRawInput)) {
++        ReleaseLock(rawInputHandleList);
++        return ((UINT)-1);
++	}
++
++    if(!pData) {
++        switch(uiCommand) {
++            case RID_INPUT:
++                *pcbSize = sizeof(RAWINPUT);
++                res = 0;
++                break;
++
++            case RID_HEADER:
++                *pcbSize = sizeof(RAWINPUTHEADER);
++                res = 0;
++                break;
++
++            default:
++                *pcbSize = 0;
++                res = (UINT)-1;
++        }
++    } else {
++        switch(uiCommand) {
++            case RID_INPUT:
++                if(*pcbSize >= sizeof(RAWINPUT)) {
++                    res = *pcbSize;
++                    RtlCopyMemory(pData, ri, sizeof(RAWINPUT));
++                } else {
++					res = (UINT)-1;
++				}
++                break;
++
++            case RID_HEADER:
++                if(*pcbSize >= sizeof(RAWINPUTHEADER)) {
++                    res = *pcbSize;
++                    RtlCopyMemory(pData, &ri->header, sizeof(RAWINPUTHEADER));
++                } else {
++					res = (UINT)-1;
++				}
++                break;
++
++            default:
++                res = (UINT)-1;
++        }
++    }
+ 
+-    return 0;
++    ReleaseLock(rawInputHandleList);
++    return res;
+ }
+ 
+-
+ /******************************************************************
+ *		GetRawInputBuffer (USER32.@)
+ */
+@@ -550,11 +1345,36 @@ UINT WINAPI GetRawInputDeviceInfoW(HANDLE hDevice, UINT uiCommand, LPVOID pData,
+ /******************************************************************
+ *		GetRegisteredRawInputDevices (USER32.@)
+ */
+-UINT WINAPI GetRegisteredRawInputDevices(PRAWINPUTDEVICE pRawInputDevices, PUINT puiNumDevices, UINT cbSize)
+-{
+-    FIXME("(pRawInputDevices=%p, puiNumDevices=%p, cbSize=%d) stub!\n", pRawInputDevices, puiNumDevices, cbSize);
+-
+-    return 0;
++UINT WINAPI GetRegisteredRawInputDevices(
++  PRAWINPUTDEVICE pRawInputDevices, PUINT puiNumDevices, UINT cbSize) {
++	UINT nd;
++	if(cbSize != sizeof(RAWINPUTDEVICE)) {
++			ERR("user32: GetRegisteredRawInputDevices expected structure size %d got %d\n",
++				sizeof(RAWINPUTDEVICE), cbSize);
++	}
++
++	//Since we only can the keyboard and mouse there should only ever be two
++	//devices.  This will just return whatever structure they were registered
++	//with in this application.  If you register more than once, you get the last.
++	nd = (b_registered_mouse?1:0) + (b_registered_keyboard?1:0);
++
++	if(nd > *puiNumDevices || !pRawInputDevices) {
++		SetLastError(ERROR_INSUFFICIENT_BUFFER);
++		*puiNumDevices = nd;
++		return -1;
++	}
++
++	if(b_registered_mouse) {
++		memcpy(pRawInputDevices, &rid_mouse, sizeof(RAWINPUTDEVICE));
++		pRawInputDevices = (PRAWINPUTDEVICE)((PBYTE)pRawInputDevices + cbSize);
++	}
++
++	if(b_registered_keyboard) {
++		memcpy(pRawInputDevices, &rid_keyboard, sizeof(RAWINPUTDEVICE));
++	}
++
++	*puiNumDevices = nd;
++	return nd;
+ }
+ 
+ 
+diff --git a/include/winuser.h b/include/winuser.h
+index a8b2c93..393939d 100644
+--- a/include/winuser.h
++++ b/include/winuser.h
+@@ -491,8 +491,8 @@ typedef struct tagRAWMOUSE {
+         struct {
+             USHORT usButtonFlags;
+             USHORT usButtonData;
+-        } DUMMYSTRUCTNAME;
+-    } DUMMYUNIONNAME;
++        };
++    };
+     ULONG ulRawButtons;
+     LONG  lLastX;
+     LONG  lLastY;
diff --git a/app-emulation/wine/wine-1.3.24-r9999.ebuild b/app-emulation/wine/wine-1.3.24-r9999.ebuild
new file mode 100644
index 0000000..6cea82e
--- /dev/null
+++ b/app-emulation/wine/wine-1.3.24-r9999.ebuild
@@ -0,0 +1,224 @@
+# Copyright 1999-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/app-emulation/wine/wine-1.3.24.ebuild,v 1.6 2011/09/18 09:08:12 ssuominen Exp $
+
+EAPI="2"
+
+inherit eutils flag-o-matic multilib
+
+if [[ ${PV} == "9999" ]] ; then
+	EGIT_REPO_URI="git://source.winehq.org/git/wine.git"
+	inherit git-2 autotools
+	SRC_URI=""
+	#KEYWORDS=""
+else
+	AUTOTOOLS_AUTO_DEPEND="no"
+	inherit autotools
+	MY_P="${PN}-${PV/_/-}"
+	SRC_URI="mirror://sourceforge/${PN}/${MY_P}.tar.bz2"
+	KEYWORDS="-* ~amd64 ~x86 ~x86-fbsd"
+	S=${WORKDIR}/${MY_P}
+fi
+
+pulse_patches() { echo "$1"/winepulse-{0.40,configure.ac-1.3.22,winecfg-1.3.11}.patch ; }
+GV="1.2.0"
+DESCRIPTION="free implementation of Windows(tm) on Unix"
+HOMEPAGE="http://www.winehq.org/"
+SRC_URI="${SRC_URI}
+	gecko? (
+		mirror://sourceforge/wine/wine_gecko-${GV}-x86.msi
+		win64? ( mirror://sourceforge/wine/wine_gecko-${GV}-x86_64.msi )
+	)
+	pulseaudio? ( `pulse_patches http://art.ified.ca/downloads/winepulse` )"
+
+LICENSE="LGPL-2.1"
+SLOT="0"
+IUSE="alsa capi cups custom-cflags dbus esd fontconfig +gecko gnutls gphoto2 gsm gstreamer hardened jack jpeg lcms ldap mp3 nas ncurses nls openal opencl +opengl +oss +perl png pulseaudio samba scanner ssl test +threads +truetype v4l +win32 +win64 +X xcomposite xinerama xml"
+RESTRICT="test" #72375
+
+MLIB_DEPS="amd64? (
+	truetype? ( >=app-emulation/emul-linux-x86-xlibs-2.1 )
+	X? (
+		>=app-emulation/emul-linux-x86-xlibs-2.1
+		>=app-emulation/emul-linux-x86-soundlibs-2.1[pulseaudio?]
+	)
+	mp3? ( app-emulation/emul-linux-x86-soundlibs )
+	openal? ( app-emulation/emul-linux-x86-sdl )
+	opengl? ( app-emulation/emul-linux-x86-opengl )
+	scanner? ( app-emulation/emul-linux-x86-medialibs )
+	v4l? ( app-emulation/emul-linux-x86-medialibs )
+	app-emulation/emul-linux-x86-baselibs
+	>=sys-kernel/linux-headers-2.6
+	)"
+RDEPEND="truetype? ( >=media-libs/freetype-2.0.0 media-fonts/corefonts )
+	perl? ( dev-lang/perl dev-perl/XML-Simple )
+	capi? ( net-dialup/capi4k-utils )
+	ncurses? ( >=sys-libs/ncurses-5.2 )
+	fontconfig? ( media-libs/fontconfig )
+	gphoto2? ( media-libs/libgphoto2 )
+	jack? ( media-sound/jack-audio-connection-kit )
+	openal? ( media-libs/openal )
+	dbus? ( sys-apps/dbus )
+	gnutls? ( net-libs/gnutls )
+	gstreamer? ( media-libs/gstreamer media-libs/gst-plugins-base )
+	X? (
+		x11-libs/libXcursor
+		x11-libs/libXrandr
+		x11-libs/libXi
+		x11-libs/libXmu
+		x11-libs/libXxf86vm
+		x11-apps/xmessage
+	)
+	xinerama? ( x11-libs/libXinerama )
+	alsa? ( media-libs/alsa-lib )
+	esd? ( media-sound/esound )
+	nas? ( media-libs/nas )
+	cups? ( net-print/cups )
+	opencl? ( x11-drivers/nvidia-drivers >=dev-util/nvidia-cuda-toolkit-3.1 )
+	opengl? ( virtual/opengl )
+	pulseaudio? ( media-sound/pulseaudio )
+	gsm? ( media-sound/gsm )
+	jpeg? ( virtual/jpeg )
+	ldap? ( net-nds/openldap )
+	lcms? ( =media-libs/lcms-1* )
+	mp3? ( >=media-sound/mpg123-1.5.0 )
+	nls? ( sys-devel/gettext )
+	samba? ( >=net-fs/samba-3.0.25 )
+	xml? ( dev-libs/libxml2 dev-libs/libxslt )
+	scanner? ( media-gfx/sane-backends )
+	ssl? ( dev-libs/openssl )
+	png? ( media-libs/libpng )
+	v4l? ( media-libs/libv4l )
+	!win64? ( ${MLIB_DEPS} )
+	win32? ( ${MLIB_DEPS} )
+	xcomposite? ( x11-libs/libXcomposite )"
+DEPEND="${RDEPEND}
+	pulseaudio? ( ${AUTOTOOLS_DEPEND} )
+	X? (
+		x11-proto/inputproto
+		x11-proto/xextproto
+		x11-proto/xf86vidmodeproto
+	)
+	xinerama? ( x11-proto/xineramaproto )
+	!hardened? ( sys-devel/prelink )
+	virtual/yacc
+	sys-devel/flex"
+
+src_unpack() {
+	if use win64 ; then
+		[[ $(( $(gcc-major-version) * 100 + $(gcc-minor-version) )) -lt 404 ]] \
+			&& die "you need gcc-4.4+ to build 64bit wine"
+	fi
+
+	if [[ ${PV} == "9999" ]] ; then
+		git-2_src_unpack
+	else
+		unpack ${MY_P}.tar.bz2
+	fi
+}
+
+src_prepare() {
+	if use pulseaudio ; then
+		EPATCH_OPTS=-p1 epatch `pulse_patches "${DISTDIR}"`
+		eautoreconf
+	fi
+	epatch "${FILESDIR}"/${PN}-1.1.15-winegcc.patch #260726
+	# Pinkbyte: hack for properly hook RawInput methods
+	epatch "${FILESDIR}"/${P}-raw_input_mod.patch
+	#
+	epatch_user #282735
+	sed -i '/^UPDATE_DESKTOP_DATABASE/s:=.*:=true:' tools/Makefile.in || die
+	sed -i '/^MimeType/d' tools/wine.desktop || die #117785
+}
+
+do_configure() {
+	local builddir="${WORKDIR}/wine$1"
+	mkdir -p "${builddir}"
+	pushd "${builddir}" >/dev/null
+
+	ECONF_SOURCE=${S} \
+	econf \
+		--sysconfdir=/etc/wine \
+		$(use_with alsa) \
+		$(use_with capi) \
+		$(use_with lcms cms) \
+		$(use_with cups) \
+		$(use_with ncurses curses) \
+		$(use_with esd) \
+		$(use_with fontconfig) \
+		$(use_with gnutls) \
+		$(use_with gphoto2 gphoto) \
+		$(use_with gsm) \
+		$(use_with gstreamer) \
+		--without-hal \
+		$(use_with jack) \
+		$(use_with jpeg) \
+		$(use_with ldap) \
+		$(use_with mp3 mpg123) \
+		$(use_with nas) \
+		$(use_with nls gettextpo) \
+		$(use_with openal) \
+		$(use_with opencl) \
+		$(use_with opengl) \
+		$(use_with ssl openssl) \
+		$(use_with oss) \
+		$(use_with png) \
+		$(use_with threads pthread) \
+		$(use pulseaudio && use_with pulseaudio pulse) \
+		$(use_with scanner sane) \
+		$(use_enable test tests) \
+		$(use_with truetype freetype) \
+		$(use_with v4l) \
+		$(use_with X x) \
+		$(use_with xcomposite) \
+		$(use_with xinerama) \
+		$(use_with xml) \
+		$(use_with xml xslt) \
+		$2
+
+	emake -j1 depend || die "depend"
+
+	popd >/dev/null
+}
+src_configure() {
+	export LDCONFIG=/bin/true
+	use custom-cflags || strip-flags
+
+	if use win64 ; then
+		do_configure 64 --enable-win64
+		use win32 && ABI=x86 do_configure 32 --with-wine64=../wine64
+	else
+		ABI=x86 do_configure 32 --disable-win64
+	fi
+}
+
+src_compile() {
+	local b
+	for b in 64 32 ; do
+		local builddir="${WORKDIR}/wine${b}"
+		[[ -d ${builddir} ]] || continue
+		emake -C "${builddir}" all || die
+	done
+}
+
+src_install() {
+	local b
+	for b in 64 32 ; do
+		local builddir="${WORKDIR}/wine${b}"
+		[[ -d ${builddir} ]] || continue
+		emake -C "${builddir}" install DESTDIR="${D}" || die
+	done
+	dodoc ANNOUNCE AUTHORS README
+	if use gecko ; then
+		insinto /usr/share/wine/gecko
+		doins "${DISTDIR}"/wine_gecko-${GV}-x86.msi || die
+		use win64 && { doins "${DISTDIR}"/wine_gecko-${GV}-x86_64.msi || die ; }
+	fi
+	if ! use perl ; then
+		rm "${D}"/usr/bin/{wine{dump,maker},function_grep.pl} "${D}"/usr/share/man/man1/wine{dump,maker}.1 || die
+	fi
+}
+
+pkg_postinst() {
+	paxctl -psmr "${ROOT}"/usr/bin/wine{,-preloader} 2>/dev/null #255055
+}