diff --git a/Scylla/MainGui.cpp b/Scylla/MainGui.cpp
index 7df9538..265c315 100644
--- a/Scylla/MainGui.cpp
+++ b/Scylla/MainGui.cpp
@@ -1,1444 +1,1448 @@
 #include "MainGui.h"
 
 #include "Architecture.h"
 //#include "PluginLoader.h"
 //#include "ConfigurationHolder.h"
 #include "PeParser.h"
 #include "DllInjectionPlugin.h"
 #include "DisassemblerGui.h"
 #include "PickApiGui.h"
 //#include "NativeWinApi.h"
 #include "ImportRebuilder.h"
 #include "SystemInformation.h"
 #include "Scylla.h"
 #include "AboutGui.h"
 #include "OptionsGui.h"
 #include "TreeImportExport.h"
 
 extern CAppModule _Module; // o_O
 
 const WCHAR MainGui::filterExe[]    = L"Executable (*.exe)\0*.exe\0All files\0*.*\0";
 const WCHAR MainGui::filterDll[]    = L"Dynamic Link Library (*.dll)\0*.dll\0All files\0*.*\0";
 const WCHAR MainGui::filterExeDll[] = L"Executable (*.exe)\0*.exe\0Dynamic Link Library (*.dll)\0*.dll\0All files\0*.*\0";
 const WCHAR MainGui::filterTxt[]    = L"Text file (*.txt)\0*.txt\0All files\0*.*\0";
 const WCHAR MainGui::filterXml[]    = L"XML file (*.xml)\0*.xml\0All files\0*.*\0";
 const WCHAR MainGui::filterMem[]    = L"MEM file (*.mem)\0*.mem\0All files\0*.*\0";
 
 MainGui::MainGui() : selectedProcess(0), isProcessSuspended(false), importsHandling(TreeImports), TreeImportsSubclass(this, IDC_TREE_IMPORTS)
 {
 	/*
 	Logger::getDebugLogFilePath();
 	ConfigurationHolder::loadConfiguration();
 	PluginLoader::findAllPlugins();
 	NativeWinApi::initialize();
 	SystemInformation::getSystemInformation();
 
 	if(ConfigurationHolder::getConfigObject(DEBUG_PRIVILEGE)->isTrue())
 	{
 		processLister.setDebugPrivileges();
 	}
 	
 
 	ProcessAccessHelp::getProcessModules(GetCurrentProcessId(), ProcessAccessHelp::ownModuleList);
 	*/
 
 	Scylla::init();
 
 	hIcon.LoadIcon(IDI_ICON_SCYLLA);
 	hMenuImports.LoadMenu(IDR_MENU_IMPORTS);
 	hMenuLog.LoadMenu(IDR_MENU_LOG);
 	accelerators.LoadAccelerators(IDR_ACCELERATOR_MAIN);
 
 	hIconCheck.LoadIcon(IDI_ICON_CHECK, 16, 16);
 	hIconWarning.LoadIcon(IDI_ICON_WARNING, 16, 16);
 	hIconError.LoadIcon(IDI_ICON_ERROR, 16, 16);
 }
 
 BOOL MainGui::PreTranslateMessage(MSG* pMsg)
 {
 	if(accelerators.TranslateAccelerator(m_hWnd, pMsg))
 	{
 		return TRUE; // handled keyboard shortcuts
 	}
 	else if(IsDialogMessage(pMsg))
 	{
 		return TRUE; // handled dialog messages
 	}
 
 	return FALSE;
 }
 
 BOOL MainGui::OnInitDialog(CWindow wndFocus, LPARAM lInitParam)
 {
 	if (SystemInformation::currenOS == UNKNOWN_OS)
 	{
 		if(IDCANCEL == MessageBox(L"Operating System is not supported\r\nContinue anyway?", L"Scylla", MB_ICONWARNING | MB_OKCANCEL))
 		{
 			SendMessage(WM_CLOSE);
 			return FALSE;
 		}
 	}
 
 	// register ourselves to receive PreTranslateMessage
 	CMessageLoop* pLoop = _Module.GetMessageLoop();
 	pLoop->AddMessageFilter(this);
 
 	setupStatusBar();
 
 	DoDataExchange(); // attach controls
 	DlgResize_Init(true, true); // init CDialogResize
 
 	Scylla::windowLog.setWindow(ListLog);
 
 	appendPluginListToMenu(hMenuImports.GetSubMenu(0));
 	appendPluginListToMenu(CMenuHandle(GetMenu()).GetSubMenu(MenuImportsOffsetTrace));
 
 	enableDialogControls(FALSE);
 	setIconAndDialogCaption();
 	return TRUE;
 }
 
 void MainGui::OnDestroy()
 {
 	PostQuitMessage(0);
 }
 
 void MainGui::OnSize(UINT nType, CSize size)
 {
 	StatusBar.SendMessage(WM_SIZE);
 	SetMsgHandled(FALSE);
 }
 
 void MainGui::OnContextMenu(CWindow wnd, CPoint point)
 { 
 	switch(wnd.GetDlgCtrlID())
 	{
 	case IDC_TREE_IMPORTS:
 		DisplayContextMenuImports(wnd, point);
 		return;
 	case IDC_LIST_LOG:
 		DisplayContextMenuLog(wnd, point);
 		return;
 	}
 
 	SetMsgHandled(FALSE);
 }
 
 void MainGui::OnCommand(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	// Handle plugin trace menu selection
 	if(uNotifyCode == 0 && !wndCtl.IsWindow()) // make sure it's a menu
 	{
 		if ((nID >= PLUGIN_MENU_BASE_ID) && (nID <= (int)(Scylla::plugins.getScyllaPluginList().size() + Scylla::plugins.getImprecPluginList().size() + PLUGIN_MENU_BASE_ID)))
 		{
 			pluginActionHandler(nID);
 			return;
 		}
 	}
 	SetMsgHandled(FALSE);
 }
 
 LRESULT MainGui::OnTreeImportsDoubleClick(const NMHDR* pnmh)
 {
 	if(TreeImports.GetCount() < 1)
 		return 0;
 
 	// Get item under cursor
 	CTreeItem over = findTreeItem(CPoint(GetMessagePos()), true);
 	if(over && importsHandling.isImport(over))
 	{
 		pickApiActionHandler(over);
 	}
 
 	return 0;
 }
 
 LRESULT MainGui::OnTreeImportsKeyDown(const NMHDR* pnmh)
 {
 	const NMTVKEYDOWN * tkd = (NMTVKEYDOWN *)pnmh;
 	switch(tkd->wVKey)
 	{
 	case VK_RETURN:
 		{
 			CTreeItem selected = TreeImports.GetFocusItem();
 			if(!selected.IsNull() && importsHandling.isImport(selected))
 			{
 				pickApiActionHandler(selected);
 			}
 		}
 		return 1;
 	case VK_DELETE:
 		deleteSelectedImportsActionHandler();
 		return 1;
 	}
 
 	SetMsgHandled(FALSE);
 	return 0;
 }
 
 UINT MainGui::OnTreeImportsSubclassGetDlgCode(const MSG * lpMsg)
 {
 	if(lpMsg)
 	{
 		switch(lpMsg->wParam)
 		{
 		case VK_RETURN:
 			return DLGC_WANTMESSAGE;
 		}
 	}
 
 	SetMsgHandled(FALSE);
 	return 0;
 }
 
 void MainGui::OnTreeImportsSubclassChar(UINT nChar, UINT nRepCnt, UINT nFlags)
 {
 	switch(nChar)
 	{
 		case VK_RETURN:
 			break;
 		default:
 			SetMsgHandled(FALSE);
 			break;
 	}
 }
 
 void MainGui::OnProcessListDrop(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	fillProcessListComboBox(ComboProcessList);
 }
 
 void MainGui::OnProcessListSelected(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	processSelectedActionHandler(ComboProcessList.GetCurSel());
 }
 
 void MainGui::OnPickDLL(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	pickDllActionHandler();
 }
 
 void MainGui::OnOptions(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	optionsActionHandler();
 }
 
 void MainGui::OnDump(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	dumpActionHandler();
 }
 
 void MainGui::OnDumpMemory(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	dumpMemoryActionHandler();
 }
 
 void MainGui::OnDumpSection(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	dumpSectionActionHandler();
 }
 
 void MainGui::OnFixDump(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	dumpFixActionHandler();
 }
 
 void MainGui::OnPERebuild(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	peRebuildActionHandler();
 }
 
 void MainGui::OnDLLInject(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	dllInjectActionHandler();
 }
 void MainGui::OnDisassembler(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	disassemblerActionHandler();
 }
 
 void MainGui::OnIATAutoSearch(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	iatAutosearchActionHandler();
 }
 
 void MainGui::OnGetImports(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	getImportsActionHandler();
 }
 
 void MainGui::OnInvalidImports(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	showInvalidImportsActionHandler();
 }
 
 void MainGui::OnSuspectImports(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	showSuspectImportsActionHandler();
 }
 
 void MainGui::OnClearImports(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	clearImportsActionHandler();
 }
 
 void MainGui::OnInvalidateSelected(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	invalidateSelectedImportsActionHandler();
 }
 
 void MainGui::OnCutSelected(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	deleteSelectedImportsActionHandler();
 }
 
 void MainGui::OnSaveTree(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	saveTreeActionHandler();
 }
 
 void MainGui::OnLoadTree(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	loadTreeActionHandler();
 }
 
 void MainGui::OnAutotrace(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	// TODO
 }
 
 void MainGui::OnExit(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	if (isProcessSuspended)
 	{
 		int msgboxID = MessageBox(L"Process is suspended. Do you want to terminate the process?\r\n\r\nYES = Terminate Process\r\nNO = Try to resume the process\r\nCancel = Do nothing", L"Information", MB_YESNOCANCEL|MB_ICONINFORMATION);
 		
 		switch (msgboxID)
 		{
 		case IDYES:
 			ProcessAccessHelp::terminateProcess();
 			break;
 		case IDNO:
 			ProcessAccessHelp::resumeProcess();
 			break;
 		default:
 			break;
 		}
 	}
 
 	DestroyWindow();
 }
 
 void MainGui::OnAbout(UINT uNotifyCode, int nID, CWindow wndCtl)
 {
 	showAboutDialog();
 }
 
 void MainGui::setupStatusBar()
 {
 	StatusBar.Create(m_hWnd, NULL, L"", WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | SBARS_TOOLTIPS, NULL, IDC_STATUS_BAR);
 
 	CRect rcMain, rcStatus;
 	GetClientRect(&rcMain);
 	StatusBar.GetWindowRect(&rcStatus);
 
 	const int PARTS = 4;
 	int widths[PARTS];
 
 	widths[PART_COUNT]     = rcMain.Width() / 5;
 	widths[PART_INVALID]   = widths[PART_COUNT] + rcMain.Width() / 5;
 	widths[PART_IMAGEBASE] = widths[PART_INVALID] + rcMain.Width() / 3;
 	widths[PART_MODULE]    = -1;
 
 	StatusBar.SetParts(PARTS, widths);
 
 	ResizeClient(rcMain.Width(), rcMain.Height() + rcStatus.Height(), FALSE);
 }
 
 void MainGui::updateStatusBar()
 {
 	// Rewrite ImportsHandling so we get these easily
 	unsigned int totalImports = importsHandling.thunkCount();
 	unsigned int invalidImports = importsHandling.invalidThunkCount();
 
 	// \t = center, \t\t = right-align
 	swprintf_s(stringBuffer, L"\tImports: %u", totalImports);
 	StatusBar.SetText(PART_COUNT, stringBuffer);
 
 	if(invalidImports > 0)
 	{
 		StatusBar.SetIcon(PART_INVALID, hIconError);
 	}
 	else
 	{
 		StatusBar.SetIcon(PART_INVALID, hIconCheck);
 	}
 
 	swprintf_s(stringBuffer, L"\tInvalid: %u", invalidImports);
 	StatusBar.SetText(PART_INVALID, stringBuffer);
 
 	if(selectedProcess)
 	{
 		DWORD_PTR imageBase = 0;
 		const WCHAR * fileName = 0;
 
 		if(ProcessAccessHelp::selectedModule)
 		{
 			imageBase = ProcessAccessHelp::selectedModule->modBaseAddr;
 			fileName = ProcessAccessHelp::selectedModule->getFilename();
 		}
 		else
 		{
 			imageBase = selectedProcess->imageBase;
 			fileName = selectedProcess->filename;
 		}
 
 		swprintf_s(stringBuffer, L"\tImagebase: " PRINTF_DWORD_PTR_FULL, imageBase);
 		StatusBar.SetText(PART_IMAGEBASE, stringBuffer);
 		StatusBar.SetText(PART_MODULE, fileName);
 		StatusBar.SetTipText(PART_MODULE, fileName);
 	}
 	else
 	{
 		StatusBar.SetText(PART_IMAGEBASE, L"");
 		StatusBar.SetText(PART_MODULE, L"");
 	}
 }
 
 bool MainGui::showFileDialog(WCHAR * selectedFile, bool save, const WCHAR * defFileName, const WCHAR * filter, const WCHAR * defExtension, const WCHAR * directory)
 {
 OPENFILENAME ofn = {0};
 
 	// WTL doesn't support new explorer styles on Vista and up
 	// This is because it uses a custom hook, we could remove it or derive
 	// from CFileDialog but this solution is easier and allows more control anyway (e.g. initial dir)
 
 	if(defFileName)
 	{
 		wcscpy_s(selectedFile, MAX_PATH, defFileName);
 	}
 	else
 	{
 		selectedFile[0] = L'\0';
 	}
 
 	ofn.lStructSize     = sizeof(ofn);
 	ofn.hwndOwner       = m_hWnd;
 	ofn.lpstrFilter     = filter;
 	ofn.lpstrDefExt     = defExtension; // only first 3 chars are used, no dots!
 	ofn.lpstrFile       = selectedFile;
 	ofn.lpstrInitialDir = directory;
 	ofn.nMaxFile        = MAX_PATH;
 	ofn.Flags           = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
 
 	/*
 	 *OFN_EXPLORER is automatically used, it only has to be specified
 	 *if using a custom hook
 	 *OFN_LONGNAMES is automatically used by explorer-style dialogs
 	 */
 
 	if(save)
 		ofn.Flags |= OFN_OVERWRITEPROMPT;
 	else
 		ofn.Flags |= OFN_FILEMUSTEXIST;
 
 	if(save)
 		return 0 != GetSaveFileName(&ofn);
 	else
 		return 0 != GetOpenFileName(&ofn);
 }
 
 void MainGui::setIconAndDialogCaption()
 {
 	SetIcon(hIcon, TRUE);
 	SetIcon(hIcon, FALSE);
 
 	SetWindowText(APPNAME L" " ARCHITECTURE L" " APPVERSION);
 }
 
 void MainGui::pickDllActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	PickDllGui dlgPickDll(ProcessAccessHelp::moduleList);
 	if(dlgPickDll.DoModal())
 	{
 		//get selected module
 		ProcessAccessHelp::selectedModule = dlgPickDll.getSelectedModule();
 
 		ProcessAccessHelp::targetImageBase = ProcessAccessHelp::selectedModule->modBaseAddr;
 
+		DWORD modEntryPoint = ProcessAccessHelp::getEntryPointFromFile(ProcessAccessHelp::selectedModule->fullPath);
+
+		EditOEPAddress.SetValue(modEntryPoint + ProcessAccessHelp::targetImageBase);
+
 		Scylla::windowLog.log(L"->>> Module %s selected.", ProcessAccessHelp::selectedModule->getFilename());
-		Scylla::windowLog.log(L"Imagebase: " PRINTF_DWORD_PTR_FULL L" Size: %08X", ProcessAccessHelp::selectedModule->modBaseAddr, ProcessAccessHelp::selectedModule->modBaseSize);
+		Scylla::windowLog.log(L"Imagebase: " PRINTF_DWORD_PTR_FULL L" Size: %08X EntryPoint: %08X", ProcessAccessHelp::selectedModule->modBaseAddr, ProcessAccessHelp::selectedModule->modBaseSize, modEntryPoint);
 	}
 	else
 	{
 		ProcessAccessHelp::selectedModule = 0;
 	}
 
 	updateStatusBar();
 }
 
 void MainGui::pickApiActionHandler(CTreeItem item)
 {
 	if(!importsHandling.isImport(item))
 		return;
 
 	// TODO: new node when user picked an API from another DLL?
 
 	PickApiGui dlgPickApi(ProcessAccessHelp::moduleList);
 	if(dlgPickApi.DoModal())
 	{
 		const ApiInfo* api = dlgPickApi.getSelectedApi();
 		if(api && api->module)
 		{
 			importsHandling.setImport(item, api->module->getFilename(), api->name, api->ordinal, api->hint, true, api->isForwarded);
 		}
 	}
 
 	updateStatusBar();
 }
 
 void MainGui::startDisassemblerGui(CTreeItem selectedTreeNode)
 {
 	if(!selectedProcess)
 		return;
 
 	DWORD_PTR address = importsHandling.getApiAddressByNode(selectedTreeNode);
 	if (address)
 	{
 		BYTE test;
 		if(!ProcessAccessHelp::readMemoryFromProcess(address, sizeof(test), &test))
 		{
 			swprintf_s(stringBuffer, L"Can't read memory at " PRINTF_DWORD_PTR_FULL, address);
 			MessageBox(stringBuffer, L"Failure", MB_ICONERROR);
 		}
 		else
 		{
 			DisassemblerGui dlgDisassembler(address, &apiReader);
 			dlgDisassembler.DoModal();
 		}
 	}
 }
 
 void MainGui::processSelectedActionHandler(int index)
 {
 	std::vector<Process>& processList = Scylla::processLister.getProcessList();
 	Process &process = processList.at(index);
 	selectedProcess = 0;
 
 	clearImportsActionHandler();
 
 	Scylla::windowLog.log(L"Analyzing %s", process.fullPath);
 
 	if (ProcessAccessHelp::hProcess != 0)
 	{
 		ProcessAccessHelp::closeProcessHandle();
 		apiReader.clearAll();
 	}
 
 	if (!ProcessAccessHelp::openProcessHandle(process.PID))
 	{
 		enableDialogControls(FALSE);
 		Scylla::windowLog.log(L"Error: Cannot open process handle.");
 		updateStatusBar();
 		return;
 	}
 
 	ProcessAccessHelp::getProcessModules(process.PID, ProcessAccessHelp::moduleList);
 
 	apiReader.readApisFromModuleList();
 
 	Scylla::windowLog.log(L"Loading modules done.");
 
 	//TODO improve
 	ProcessAccessHelp::selectedModule = 0;
 	ProcessAccessHelp::targetSizeOfImage = process.imageSize;
 	ProcessAccessHelp::targetImageBase = process.imageBase;
 
 	ProcessAccessHelp::getSizeOfImageCurrentProcess();
 
 	process.imageSize = (DWORD)ProcessAccessHelp::targetSizeOfImage;
 
 
 	Scylla::windowLog.log(L"Imagebase: " PRINTF_DWORD_PTR_FULL L" Size: %08X", process.imageBase, process.imageSize);
 
 	process.entryPoint = ProcessAccessHelp::getEntryPointFromFile(process.fullPath);
 
 	EditOEPAddress.SetValue(process.entryPoint + process.imageBase);
 
 	selectedProcess = &process;
 	enableDialogControls(TRUE);
 
 	updateStatusBar();
 }
 
 void MainGui::fillProcessListComboBox(CComboBox& hCombo)
 {
 	hCombo.ResetContent();
 
 	std::vector<Process>& processList = Scylla::processLister.getProcessListSnapshot();
 
 	for (size_t i = 0; i < processList.size(); i++)
 	{
 		swprintf_s(stringBuffer, L"0x%04X - %s - %s", processList[i].PID, processList[i].filename, processList[i].fullPath);
 		hCombo.AddString(stringBuffer);
 	}
 }
 
 /*
 void MainGui::addTextToOutputLog(const WCHAR * text)
 {
 	if (m_hWnd)
 	{
 		ListLog.SetCurSel(ListLog.AddString(text));
 	}
 }
 */
 
 void MainGui::clearOutputLog()
 {
 	if (m_hWnd)
 	{
 		ListLog.ResetContent();
 	}
 }
 
 bool MainGui::saveLogToFile(const WCHAR * file)
 {
 	const BYTE BOM[] = {0xFF, 0xFE}; // UTF-16 little-endian
 	const WCHAR newLine[] = L"\r\n";
 	bool success = true;
 
 	HANDLE hFile = CreateFile(file, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 	if(hFile != INVALID_HANDLE_VALUE)
 	{
 		ProcessAccessHelp::writeMemoryToFileEnd(hFile, sizeof(BOM), BOM);
 
 		WCHAR * buffer = 0;
 		size_t bufsize = 0;
 		for(int i = 0; i < ListLog.GetCount(); i++)
 		{
 			size_t size = ListLog.GetTextLen(i);
 			size += _countof(newLine)-1;
 			if(size+1 > bufsize)
 			{
 				bufsize = size+1;
 				delete[] buffer;
 				try
 				{
 					buffer = new WCHAR[bufsize];
 				}
 				catch(std::bad_alloc&)
 				{
 					buffer = 0;
 					success = false;
 					break;
 				}
 			}
 
 			ListLog.GetText(i, buffer);
 			wcscat_s(buffer, bufsize, newLine);
 
 			ProcessAccessHelp::writeMemoryToFileEnd(hFile, (DWORD)(size * sizeof(WCHAR)), buffer);
 		}
 		delete[] buffer;
 		CloseHandle(hFile);
 	}
 	return success;
 }
 
 void MainGui::showInvalidImportsActionHandler()
 {
 	importsHandling.selectImports(true, false);
 	GotoDlgCtrl(TreeImports);
 }
 
 void MainGui::showSuspectImportsActionHandler()
 {
 	importsHandling.selectImports(false, true);
 	GotoDlgCtrl(TreeImports);
 }
 
 void MainGui::deleteSelectedImportsActionHandler()
 {
 	CTreeItem selected = TreeImports.GetFirstSelectedItem();
 	while(!selected.IsNull())
 	{
 		if(importsHandling.isModule(selected))
 		{
 			importsHandling.cutModule(selected);
 		}
 		else
 		{
 			importsHandling.cutImport(selected);
 		}
 		selected = TreeImports.GetNextSelectedItem(selected);
 	}
 	updateStatusBar();
 }
 
 void MainGui::invalidateSelectedImportsActionHandler()
 {
 	CTreeItem selected = TreeImports.GetFirstSelectedItem();
 	while(!selected.IsNull())
 	{
 		if(importsHandling.isImport(selected))
 		{
 			importsHandling.invalidateImport(selected);
 		}
 		selected = TreeImports.GetNextSelectedItem(selected);
 	}
 	updateStatusBar();
 }
 
 void MainGui::loadTreeActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	WCHAR selectedFilePath[MAX_PATH];
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if(showFileDialog(selectedFilePath, false, NULL, filterXml, NULL, stringBuffer))
 	{
 		TreeImportExport treeIO(selectedFilePath);
 		DWORD_PTR addrOEP = 0;
 		DWORD_PTR addrIAT = 0;
 		DWORD sizeIAT = 0;
 
 		if(!treeIO.importTreeList(importsHandling.moduleList, &addrOEP, &addrIAT, &sizeIAT))
 		{
 			Scylla::windowLog.log(L"Loading tree file failed %s", selectedFilePath);
 			MessageBox(L"Loading tree file failed.", L"Failure", MB_ICONERROR);
 		}
 		else
 		{
 			EditOEPAddress.SetValue(addrOEP);
 			EditIATAddress.SetValue(addrIAT);
 			EditIATSize.SetValue(sizeIAT);
 
 			importsHandling.displayAllImports();
 			updateStatusBar();
 
 			Scylla::windowLog.log(L"Loaded tree file %s", selectedFilePath);
 			Scylla::windowLog.log(L"-> OEP: " PRINTF_DWORD_PTR_FULL, addrOEP);
 			Scylla::windowLog.log(L"-> IAT: " PRINTF_DWORD_PTR_FULL L" Size: " PRINTF_DWORD_PTR, addrIAT, sizeIAT);
 		}
 	}
 }
 
 void MainGui::saveTreeActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	WCHAR selectedFilePath[MAX_PATH];
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if(showFileDialog(selectedFilePath, true, NULL, filterXml, L"xml", stringBuffer))
 	{
 		TreeImportExport treeIO(selectedFilePath);
 		DWORD_PTR addrOEP = EditOEPAddress.GetValue();
 		DWORD_PTR addrIAT = EditIATAddress.GetValue();
 		DWORD sizeIAT = EditIATSize.GetValue();
 
 		if(!treeIO.exportTreeList(importsHandling.moduleList, selectedProcess, addrOEP, addrIAT, sizeIAT))
 		{
 			Scylla::windowLog.log(L"Saving tree file failed %s", selectedFilePath);
 			MessageBox(L"Saving tree file failed.", L"Failure", MB_ICONERROR);
 		}
 		else
 		{
 			Scylla::windowLog.log(L"Saved tree file %s", selectedFilePath);
 		}
 	}
 }
 
 void MainGui::iatAutosearchActionHandler()
 {
 	DWORD_PTR searchAddress = 0;
 	DWORD_PTR addressIAT = 0;
 	DWORD sizeIAT = 0;
 	IATSearch iatSearch;
 
 	if(!selectedProcess)
 		return;
 
 	if(EditOEPAddress.GetWindowTextLength() > 0)
 	{
 		searchAddress = EditOEPAddress.GetValue();
 		if (searchAddress)
 		{
 			if (iatSearch.searchImportAddressTableInProcess(searchAddress, &addressIAT, &sizeIAT))
 			{
 				Scylla::windowLog.log(L"IAT found at VA " PRINTF_DWORD_PTR_FULL L" RVA " PRINTF_DWORD_PTR_FULL L" Size 0x%04X (%d)", addressIAT, addressIAT - ProcessAccessHelp::targetImageBase, sizeIAT, sizeIAT);
 
 				EditIATAddress.SetValue(addressIAT);
 				EditIATSize.SetValue(sizeIAT);
 
 				swprintf_s(stringBuffer, L"IAT found:\r\n\r\nStart: " PRINTF_DWORD_PTR_FULL L"\r\nSize: 0x%04X (%d) ", addressIAT, sizeIAT, sizeIAT);
 				MessageBox(stringBuffer, L"IAT found", MB_ICONINFORMATION);
 			}
 			else
 			{
 				Scylla::windowLog.log(L"IAT not found at OEP " PRINTF_DWORD_PTR_FULL L"!", searchAddress);
 			}
 		}
 	}
 }
 
 void MainGui::getImportsActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	DWORD_PTR addressIAT = EditIATAddress.GetValue();
 	DWORD sizeIAT = EditIATSize.GetValue();
 
 	if (addressIAT && sizeIAT)
 	{
 		apiReader.readAndParseIAT(addressIAT, sizeIAT, importsHandling.moduleList);
 		importsHandling.displayAllImports();
 
 		updateStatusBar();
 	}
 }
 
 void MainGui::SetupImportsMenuItems(CTreeItem item)
 {
 	bool isItem, isImport = false;
 	isItem = !item.IsNull();
 	if(isItem)
 	{
 		isImport = importsHandling.isImport(item);
 	}
 
 	CMenuHandle hSub = hMenuImports.GetSubMenu(0);
 
 	UINT itemOnly = isItem ? MF_ENABLED : MF_GRAYED;
 	UINT importOnly = isImport ? MF_ENABLED : MF_GRAYED;
 
 	hSub.EnableMenuItem(ID__INVALIDATE, itemOnly);
 	hSub.EnableMenuItem(ID__DISASSEMBLE, importOnly);
 	hSub.EnableMenuItem(ID__CUTTHUNK, importOnly);
 
 	hSub.EnableMenuItem(ID__DELETETREENODE, itemOnly);
 }
 
 void MainGui::DisplayContextMenuImports(CWindow hwnd, CPoint pt)
 {
 	if(TreeImports.GetCount() < 1)
 		return;
 
 	CTreeItem over, parent;
 
 	if(pt.x == -1 && pt.y == -1) // invoked by keyboard
 	{
 		CRect pos;
 		over = TreeImports.GetFocusItem();
 		if(over)
 		{
 			over.EnsureVisible();
 			over.GetRect(&pos, TRUE);
 			TreeImports.ClientToScreen(&pos);
 		}
 		else
 		{
 			TreeImports.GetWindowRect(&pos);
 		}
 		pt = pos.TopLeft();
 	}
 	else
 	{
 		// Get item under cursor
 		over = findTreeItem(pt, true);
 	}
 
 	SetupImportsMenuItems(over);
 
 	CMenuHandle hSub = hMenuImports.GetSubMenu(0);
 	BOOL menuItem = hSub.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, hwnd);
 	if (menuItem)
 	{
 		if ((menuItem >= PLUGIN_MENU_BASE_ID) && (menuItem <= (int)(Scylla::plugins.getScyllaPluginList().size() + Scylla::plugins.getImprecPluginList().size() + PLUGIN_MENU_BASE_ID)))
 		{
 			//wsprintf(stringBuffer, L"%d %s\n",menuItem,pluginList[menuItem - PLUGIN_MENU_BASE_ID].pluginName);
 			//MessageBox(stringBuffer, L"plugin selection");
 
 			pluginActionHandler(menuItem);
 			return;
 		}
 		switch (menuItem)
 		{
 		case ID__INVALIDATE:
 			if(importsHandling.isModule(over))
 				importsHandling.invalidateModule(over);
 			else
 				importsHandling.invalidateImport(over);
 			break;
 		case ID__DISASSEMBLE:
 			startDisassemblerGui(over);
 			break;
 		case ID__EXPANDALLNODES:
 			importsHandling.expandAllTreeNodes();
 			break;
 		case ID__COLLAPSEALLNODES:
 			importsHandling.collapseAllTreeNodes();
 			break;
 		case ID__CUTTHUNK:
 			importsHandling.cutImport(over);
 			break;
 		case ID__DELETETREENODE:
 			importsHandling.cutModule(importsHandling.isImport(over) ? over.GetParent() : over);
 			break;
 		}
 	}
 
 	updateStatusBar();
 }
 
 void MainGui::DisplayContextMenuLog(CWindow hwnd, CPoint pt)
 {
 	if(pt.x == -1 && pt.y == -1) // invoked by keyboard
 	{
 		CRect pos;
 		ListLog.GetWindowRect(&pos);
 		pt = pos.TopLeft();
 	}
 
 	CMenuHandle hSub = hMenuLog.GetSubMenu(0);
 	BOOL menuItem = hSub.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, hwnd);
 	if (menuItem)
 	{
 		switch (menuItem)
 		{
 		case ID__SAVE:
 			WCHAR selectedFilePath[MAX_PATH];
 			getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 			if(showFileDialog(selectedFilePath, true, NULL, filterTxt, L"txt", stringBuffer))
 			{
 				saveLogToFile(selectedFilePath);
 			}
 			break;
 		case ID__CLEAR:
 			clearOutputLog();
 			break;
 		}
 	}
 }
 
 void MainGui::appendPluginListToMenu(CMenuHandle hMenu)
 {
 	std::vector<Plugin> &scyllaPluginList = Scylla::plugins.getScyllaPluginList();
 	std::vector<Plugin> &imprecPluginList = Scylla::plugins.getImprecPluginList();
 
 	if (scyllaPluginList.size() > 0)
 	{
 		CMenuHandle newMenu;
 		newMenu.CreatePopupMenu();
 
 		for (size_t i = 0; i < scyllaPluginList.size(); i++)
 		{
 			newMenu.AppendMenu(MF_STRING, i + PLUGIN_MENU_BASE_ID, scyllaPluginList[i].pluginName);
 		}
 
 		hMenu.AppendMenu(MF_MENUBARBREAK);
 		hMenu.AppendMenu(MF_POPUP, newMenu, L"Scylla Plugins");
 	}
 
 	if (imprecPluginList.size() > 0)
 	{
 		CMenuHandle newMenu;
 		newMenu.CreatePopupMenu();
 
 		for (size_t i = 0; i < imprecPluginList.size(); i++)
 		{
 			newMenu.AppendMenu(MF_STRING, scyllaPluginList.size() + i + PLUGIN_MENU_BASE_ID, imprecPluginList[i].pluginName);
 		}
 
 		hMenu.AppendMenu(MF_MENUBARBREAK);
 		hMenu.AppendMenu(MF_POPUP, newMenu, L"ImpREC Plugins");
 	}
 }
 
 void MainGui::dumpMemoryActionHandler()
 {
 	WCHAR selectedFilePath[MAX_PATH];
 	DumpMemoryGui dlgDumpMemory;
 
 	if(dlgDumpMemory.DoModal())
 	{
 		getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 		if(showFileDialog(selectedFilePath, true, dlgDumpMemory.dumpFilename, filterMem, L"mem", stringBuffer))
 		{
 			if (ProcessAccessHelp::writeMemoryToNewFile(selectedFilePath,dlgDumpMemory.dumpedMemorySize,dlgDumpMemory.dumpedMemory))
 			{
 				Scylla::windowLog.log(L"Memory dump saved %s", selectedFilePath);
 			}
 			else
 			{
 				Scylla::windowLog.log(L"Error! Cannot write memory dump to disk");
 			}
 		}
 	}
 }
 
 void MainGui::dumpSectionActionHandler()
 {
 	WCHAR selectedFilePath[MAX_PATH];
 	DumpSectionGui dlgDumpSection;
 	const WCHAR * fileFilter;
 	const WCHAR * defExtension;
 	PeParser * peFile = 0;
 
 	dlgDumpSection.entryPoint = EditOEPAddress.GetValue();
 
 	if (ProcessAccessHelp::selectedModule)
 	{
 		//dump DLL
 		fileFilter = filterDll;
 		defExtension = L"dll";
 
 		dlgDumpSection.imageBase = ProcessAccessHelp::selectedModule->modBaseAddr;
 		//get it from gui
 		wcscpy_s(dlgDumpSection.fullpath, ProcessAccessHelp::selectedModule->fullPath);
 	}
 	else
 	{
 		fileFilter = filterExe;
 		defExtension = L"exe";
 
 		dlgDumpSection.imageBase = ProcessAccessHelp::targetImageBase;
 		//get it from gui
 		wcscpy_s(dlgDumpSection.fullpath, selectedProcess->fullPath);
 	}
 
 	if(dlgDumpSection.DoModal())
 	{
 		getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 		if(showFileDialog(selectedFilePath, true, NULL, fileFilter, defExtension, stringBuffer))
 		{
 			checkSuspendProcess();
 
 			if (Scylla::config[USE_PE_HEADER_FROM_DISK].isTrue())
 			{
 				peFile = new PeParser(dlgDumpSection.fullpath, true);
 			}
 			else
 			{
 				peFile = new PeParser(dlgDumpSection.imageBase, true);
 			}
 
 			std::vector<PeSection> & sectionList = dlgDumpSection.getSectionList();
 
 			if (peFile->dumpProcess(dlgDumpSection.imageBase, dlgDumpSection.entryPoint, selectedFilePath, sectionList))
 			{
 				Scylla::windowLog.log(L"Dump success %s", selectedFilePath);
 			}
 			else
 			{
 				Scylla::windowLog.log(L"Error: Cannot dump image.");
 				MessageBox(L"Cannot dump image.", L"Failure", MB_ICONERROR);
 			}
 
 			delete peFile;
 		}
 	}
 }
 
 void MainGui::dumpActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	WCHAR selectedFilePath[MAX_PATH];
 	const WCHAR * fileFilter;
 	const WCHAR * defExtension;
 	DWORD_PTR modBase = 0;
 	DWORD_PTR entrypoint = 0;
 	WCHAR * filename = 0;
 	PeParser * peFile = 0;
 
 	if (ProcessAccessHelp::selectedModule)
 	{
 		fileFilter = filterDll;
 		defExtension = L"dll";
 	}
 	else
 	{
 		fileFilter = filterExe;
 		defExtension = L"exe";
 	}
 
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if(showFileDialog(selectedFilePath, true, NULL, fileFilter, defExtension, stringBuffer))
 	{
 		entrypoint = EditOEPAddress.GetValue();
 
 		checkSuspendProcess();
 
 		if (ProcessAccessHelp::selectedModule)
 		{
 			//dump DLL
 			modBase = ProcessAccessHelp::selectedModule->modBaseAddr;
 			filename = ProcessAccessHelp::selectedModule->fullPath;
 		}
 		else
 		{
 			//dump exe
 			modBase = ProcessAccessHelp::targetImageBase;
 			filename = selectedProcess->fullPath;
 		}
 
 		if (Scylla::config[USE_PE_HEADER_FROM_DISK].isTrue())
 		{
 			peFile = new PeParser(filename, true);
 		}
 		else
 		{
 			peFile = new PeParser(modBase, true);
 		}
 
 		if (peFile->dumpProcess(modBase, entrypoint, selectedFilePath))
 		{
 			Scylla::windowLog.log(L"Dump success %s", selectedFilePath);
 		}
 		else
 		{
 			Scylla::windowLog.log(L"Error: Cannot dump image.");
 			MessageBox(L"Cannot dump image.", L"Failure", MB_ICONERROR);
 		}
 
 		delete peFile;
 	}
 }
 
 void MainGui::peRebuildActionHandler()
 {
 	DWORD newSize = 0;
 	WCHAR selectedFilePath[MAX_PATH];
 
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if(showFileDialog(selectedFilePath, false, NULL, filterExeDll, NULL, stringBuffer))
 	{
 		if (Scylla::config[CREATE_BACKUP].isTrue())
 		{
 			if (!ProcessAccessHelp::createBackupFile(selectedFilePath))
 			{
 				Scylla::windowLog.log(L"Creating backup file failed %s", selectedFilePath);
 			}
 		}
 
 		DWORD fileSize = (DWORD)ProcessAccessHelp::getFileSize(selectedFilePath);
 
 		PeParser peFile(selectedFilePath, true);
 
 		if (!peFile.isValidPeFile())
 		{
 			Scylla::windowLog.log(L"This is not a valid PE file %s", selectedFilePath);
 			MessageBox(L"Not a valid PE file.", L"Failure", MB_ICONERROR);
 			return;
 		}
 
 		if (peFile.readPeSectionsFromFile())
 		{
 			peFile.setDefaultFileAlignment();
 
 			if (Scylla::config[REMOVE_DOS_HEADER_STUB].isTrue())
 			{
 				peFile.removeDosStub();
 			}
 			
 			peFile.alignAllSectionHeaders();
 			peFile.fixPeHeader();
 
 			if (peFile.savePeFileToDisk(selectedFilePath))
 			{
 				newSize = (DWORD)ProcessAccessHelp::getFileSize(selectedFilePath);
 
 				if (Scylla::config[UPDATE_HEADER_CHECKSUM].isTrue())
 				{
 					Scylla::windowLog.log(L"Generating PE header checksum");
 					if (!PeParser::updatePeHeaderChecksum(selectedFilePath, newSize))
 					{
 						Scylla::windowLog.log(L"Generating PE header checksum FAILED!");
 					}
 				}
 
 				Scylla::windowLog.log(L"Rebuild success %s", selectedFilePath);
 				Scylla::windowLog.log(L"-> Old file size 0x%08X new file size 0x%08X (%d %%)", fileSize, newSize, ((newSize * 100) / fileSize) );
 			}
 			else
 			{
 				Scylla::windowLog.log(L"Rebuild failed, cannot save file %s", selectedFilePath);
 				MessageBox(L"Rebuild failed. Cannot save file.", L"Failure", MB_ICONERROR);
 			}
 		}
 		else
 		{
 			Scylla::windowLog.log(L"Rebuild failed, cannot read file %s", selectedFilePath);
 			MessageBox(L"Rebuild failed. Cannot read file.", L"Failure", MB_ICONERROR);
 		}
 
 	}
 }
 
 void MainGui::dumpFixActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	if (TreeImports.GetCount() < 2)
 	{
 		Scylla::windowLog.log(L"Nothing to rebuild");
 		return;
 	}
 
 	WCHAR newFilePath[MAX_PATH];
 	WCHAR selectedFilePath[MAX_PATH];
 	const WCHAR * fileFilter;
 	DWORD_PTR modBase = 0;
 	DWORD_PTR entrypoint = EditOEPAddress.GetValue();
 
 	if (ProcessAccessHelp::selectedModule)
 	{
 		modBase = ProcessAccessHelp::selectedModule->modBaseAddr;
 		fileFilter = filterDll;
 	}
 	else
 	{
 		modBase = ProcessAccessHelp::targetImageBase;
 		fileFilter = filterExe;
 	}
 
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if (showFileDialog(selectedFilePath, false, NULL, fileFilter, NULL, stringBuffer))
 	{
 		wcscpy_s(newFilePath, selectedFilePath);
 
 		const WCHAR * extension = 0;
 
 		WCHAR* dot = wcsrchr(newFilePath, L'.');
 		if (dot)
 		{
 			*dot = L'\0';
 			extension = selectedFilePath + (dot - newFilePath); //wcsrchr(selectedFilePath, L'.');
 		}
 
 		wcscat_s(newFilePath, L"_SCY");
 
 		if(extension)
 		{
 			wcscat_s(newFilePath, extension);
 		}
 
 		ImportRebuilder importRebuild(selectedFilePath);
 
 		if (Scylla::config[IAT_FIX_AND_OEP_FIX].isTrue())
 		{
 			importRebuild.setEntryPointRva((DWORD)(entrypoint - modBase));
 		}
 
 		if (Scylla::config[OriginalFirstThunk_SUPPORT].isTrue())
 		{
 			importRebuild.enableOFTSupport();
 		}
 
 		if (importRebuild.rebuildImportTable(newFilePath, importsHandling.moduleList))
 		{
 			Scylla::windowLog.log(L"Import Rebuild success %s", newFilePath);
 		}
 		else
 		{
 			Scylla::windowLog.log(L"Import Rebuild failed %s", selectedFilePath);
 			MessageBox(L"Import Rebuild failed", L"Failure", MB_ICONERROR);
 		}
 	}
 }
 
 void MainGui::enableDialogControls(BOOL value)
 {
 	BOOL valButton = value ? TRUE : FALSE;
 
 	GetDlgItem(IDC_BTN_PICKDLL).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_DUMP).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_FIXDUMP).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_IATAUTOSEARCH).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_GETIMPORTS).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_SUSPECTIMPORTS).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_INVALIDIMPORTS).EnableWindow(valButton);
 	GetDlgItem(IDC_BTN_CLEARIMPORTS).EnableWindow(valButton);
 
 	CMenuHandle menu = GetMenu();
 
 	UINT valMenu = value ? MF_ENABLED : MF_GRAYED;
 
 	menu.EnableMenuItem(ID_FILE_DUMP, valMenu);
 	menu.EnableMenuItem(ID_FILE_DUMPMEMORY, valMenu);
 	menu.EnableMenuItem(ID_FILE_DUMPSECTION, valMenu);
 	menu.EnableMenuItem(ID_FILE_FIXDUMP, valMenu);
 	menu.EnableMenuItem(ID_IMPORTS_INVALIDATESELECTED, valMenu);
 	menu.EnableMenuItem(ID_IMPORTS_CUTSELECTED, valMenu);
 	menu.EnableMenuItem(ID_IMPORTS_SAVETREE, valMenu);
 	menu.EnableMenuItem(ID_IMPORTS_LOADTREE, valMenu);
 	menu.EnableMenuItem(ID_MISC_DLLINJECTION, valMenu);
 	menu.EnableMenuItem(ID_MISC_DISASSEMBLER, valMenu);
 	menu.GetSubMenu(MenuImportsOffsetTrace).EnableMenuItem(MenuImportsTraceOffsetScylla, MF_BYPOSITION | valMenu);
 	menu.GetSubMenu(MenuImportsOffsetTrace).EnableMenuItem(MenuImportsTraceOffsetImpRec, MF_BYPOSITION | valMenu);
 
 	//not yet implemented
 	GetDlgItem(IDC_BTN_AUTOTRACE).EnableWindow(FALSE);
 	menu.EnableMenuItem(ID_TRACE_AUTOTRACE, MF_GRAYED);
 }
 
 CTreeItem MainGui::findTreeItem(CPoint pt, bool screenCoordinates)
 {
 	if(screenCoordinates)
 	{
 		TreeImports.ScreenToClient(&pt);
 	}
 
 	UINT flags;
 	CTreeItem over = TreeImports.HitTest(pt, &flags);
 	if(over)
 	{
 		if(!(flags & TVHT_ONITEM))
 		{
 			over.m_hTreeItem = NULL;
 		}
 	}
 
 	return over;
 }
 
 void MainGui::showAboutDialog()
 {
 	AboutGui dlgAbout;
 	dlgAbout.DoModal();
 }
 
 void MainGui::dllInjectActionHandler()
 {
 	if(!selectedProcess)
 		return;
 
 	WCHAR selectedFilePath[MAX_PATH];
 	HMODULE hMod = 0;
 	DllInjection dllInjection;
 
 	getCurrentModulePath(stringBuffer, _countof(stringBuffer));
 	if (showFileDialog(selectedFilePath, false, NULL, filterDll, NULL, stringBuffer))
 	{
 		hMod = dllInjection.dllInjection(ProcessAccessHelp::hProcess, selectedFilePath);
 		if (hMod && Scylla::config[DLL_INJECTION_AUTO_UNLOAD].isTrue())
 		{
 			if (!dllInjection.unloadDllInProcess(ProcessAccessHelp::hProcess, hMod))
 			{
 				Scylla::windowLog.log(L"DLL unloading failed, target %s", selectedFilePath);
 			}
 		}
 
 		if (hMod)
 		{
 			Scylla::windowLog.log(L"DLL Injection was successful, target %s", selectedFilePath);
 		}
 		else
 		{
 			Scylla::windowLog.log(L"DLL Injection failed, target %s", selectedFilePath);
 		}
 	}
 }
 
 void MainGui::disassemblerActionHandler()
 {
 	DWORD_PTR oep = EditOEPAddress.GetValue();
 	DisassemblerGui disGuiDlg(oep, &apiReader);
 	disGuiDlg.DoModal();
 }
 
 void MainGui::optionsActionHandler()
 {
 	OptionsGui dlgOptions;
 	dlgOptions.DoModal();
 }
 
 void MainGui::clearImportsActionHandler()
 {
 	importsHandling.clearAllImports();
 	updateStatusBar();
 }
 
 void MainGui::pluginActionHandler( int menuItem )
 {
 	if(!selectedProcess)
 		return;
 
 	DllInjectionPlugin dllInjectionPlugin;
 
 	std::vector<Plugin> &scyllaPluginList = Scylla::plugins.getScyllaPluginList();
 	std::vector<Plugin> &imprecPluginList = Scylla::plugins.getImprecPluginList();
 
 	menuItem -= PLUGIN_MENU_BASE_ID;
 
 	dllInjectionPlugin.hProcess = ProcessAccessHelp::hProcess;
 	dllInjectionPlugin.apiReader = &apiReader;
 
 	if (menuItem < (int)scyllaPluginList.size())
 	{
 		//scylla plugin
 		dllInjectionPlugin.injectPlugin(scyllaPluginList[menuItem], importsHandling.moduleList,selectedProcess->imageBase, selectedProcess->imageSize);
 	}
 	else
 	{
 #ifndef _WIN64
 
 		menuItem -= (int)scyllaPluginList.size();
 		//imprec plugin
 		dllInjectionPlugin.injectImprecPlugin(imprecPluginList[menuItem], importsHandling.moduleList,selectedProcess->imageBase, selectedProcess->imageSize);
 
 #endif
 	}
 
 	importsHandling.scanAndFixModuleList();
 	importsHandling.displayAllImports();
 	updateStatusBar();
 }
 
 bool MainGui::getCurrentModulePath(WCHAR * buffer, size_t bufferSize)
 {
 	if(!selectedProcess)
 		return false;
 
 	if(ProcessAccessHelp::selectedModule)
 	{
 		wcscpy_s(buffer, bufferSize, ProcessAccessHelp::selectedModule->fullPath);
 	}
 	else
 	{
 		wcscpy_s(buffer, bufferSize, selectedProcess->fullPath);
 	}
 
 	WCHAR * slash = wcsrchr(buffer, L'\\');
 	if(slash)
 	{
 		*(slash+1) = L'\0';
 	}
 
 	return true;
 }
 
 void MainGui::checkSuspendProcess()
 {
 	if (Scylla::config[SUSPEND_PROCESS_FOR_DUMPING].isTrue())
 	{
 		if (!ProcessAccessHelp::suspendProcess())
 		{
 			Scylla::windowLog.log(L"Error: Cannot suspend process.");
 		}
 		else
 		{
 			isProcessSuspended = true;
 			Scylla::windowLog.log(L"Suspending process successful, please resume manually.");
 		}
 	}
 }
\ No newline at end of file
diff --git a/Scylla/Scylla.vcxproj b/Scylla/Scylla.vcxproj
index f533d27..eaba037 100644
--- a/Scylla/Scylla.vcxproj
+++ b/Scylla/Scylla.vcxproj
@@ -1,248 +1,261 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{710434C9-FC4B-4F1D-B318-E10ADC78499F}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>Scylla</RootNamespace>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
     <PlatformToolset>v90</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
     <PlatformToolset>v90</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LinkIncremental>true</LinkIncremental>
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir>$(Platform)\$(Configuration)\</IntDir>
     <IncludePath>$(SolutionDir)WTL81_9127_Include;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
     <IncludePath>$(SolutionDir)WTL81_9127_Include;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
     <OutDir>$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir>$(Platform)\$(Configuration)\</IntDir>
     <IncludePath>$(SolutionDir)WTL81_9127_Include;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>$(SolutionDir)WTL81_9127_Include;$(IncludePath)</IncludePath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>$(SolutionDir)tinyxml;$(SolutionDir)diStorm\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\diStorm.lib;$(SolutionDir)$(Platform)\$(Configuration)\tinyxml.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalManifestDependencies>type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' </AdditionalManifestDependencies>
       <GenerateMapFile>true</GenerateMapFile>
       <MapFileName>$(TargetDir)$(TargetName).map</MapFileName>
+      <EntryPointSymbol>
+      </EntryPointSymbol>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>$(SolutionDir)tinyxml;$(SolutionDir)diStorm\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\diStorm.lib;$(SolutionDir)$(Platform)\$(Configuration)\tinyxml.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalManifestDependencies>type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' </AdditionalManifestDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalIncludeDirectories>$(SolutionDir)tinyxml;$(SolutionDir)diStorm\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>true</MinimalRebuild>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\diStorm.lib;$(SolutionDir)$(Platform)\$(Configuration)\tinyxml.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalManifestDependencies>type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' </AdditionalManifestDependencies>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <EntryPointSymbol>
+      </EntryPointSymbol>
+      <GenerateMapFile>true</GenerateMapFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <Optimization>MaxSpeed</Optimization>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalIncludeDirectories>$(SolutionDir)tinyxml;$(SolutionDir)diStorm\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <MinimalRebuild>true</MinimalRebuild>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>false</GenerateDebugInformation>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\diStorm.lib;$(SolutionDir)$(Platform)\$(Configuration)\tinyxml.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <AdditionalManifestDependencies>type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' </AdditionalManifestDependencies>
+      <EntryPointSymbol>
+      </EntryPointSymbol>
+      <ModuleDefinitionFile>
+      </ModuleDefinitionFile>
+      <GenerateMapFile>true</GenerateMapFile>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="AboutGui.cpp" />
     <ClCompile Include="ApiReader.cpp" />
     <ClCompile Include="Architecture.cpp" />
     <ClCompile Include="Configuration.cpp" />
     <ClCompile Include="ConfigurationHolder.cpp" />
     <ClCompile Include="DeviceNameResolver.cpp" />
     <ClCompile Include="DisassemblerGui.cpp" />
     <ClCompile Include="DllInjection.cpp" />
     <ClCompile Include="DllInjectionPlugin.cpp" />
     <ClCompile Include="DumpMemoryGui.cpp" />
     <ClCompile Include="DumpSectionGui.cpp" />
+    <ClCompile Include="FunctionExport.cpp" />
     <ClCompile Include="IATSearch.cpp" />
     <ClCompile Include="ImportRebuilder.cpp" />
     <ClCompile Include="ImportsHandling.cpp" />
     <ClCompile Include="Logger.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="MainGui.cpp" />
     <ClCompile Include="NativeWinApi.cpp" />
     <ClCompile Include="OptionsGui.cpp" />
     <ClCompile Include="PeParser.cpp" />
     <ClCompile Include="PickApiGui.cpp" />
     <ClCompile Include="PickDllGui.cpp" />
     <ClCompile Include="PluginLoader.cpp" />
     <ClCompile Include="ProcessAccessHelp.cpp" />
     <ClCompile Include="ProcessLister.cpp" />
     <ClCompile Include="Scylla.cpp" />
     <ClCompile Include="StringConversion.cpp" />
     <ClCompile Include="SystemInformation.cpp" />
     <ClCompile Include="TreeImportExport.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="AboutGui.h" />
     <ClInclude Include="ApiReader.h" />
     <ClInclude Include="Architecture.h" />
     <ClInclude Include="Configuration.h" />
     <ClInclude Include="ConfigurationHolder.h" />
     <ClInclude Include="DeviceNameResolver.h" />
     <ClInclude Include="DisassemblerGui.h" />
     <ClInclude Include="DllInjection.h" />
     <ClInclude Include="DllInjectionPlugin.h" />
     <ClInclude Include="DumpMemoryGui.h" />
     <ClInclude Include="DumpSectionGui.h" />
     <ClInclude Include="hexedit.h" />
     <ClInclude Include="IATSearch.h" />
     <ClInclude Include="ImportRebuilder.h" />
     <ClInclude Include="ImportsHandling.h" />
     <ClInclude Include="Logger.h" />
     <ClInclude Include="MainGui.h" />
     <ClInclude Include="multitree.h" />
     <ClInclude Include="NativeWinApi.h" />
     <ClInclude Include="OptionsGui.h" />
     <ClInclude Include="PeParser.h" />
     <ClInclude Include="PickApiGui.h" />
     <ClInclude Include="PickDllGui.h" />
     <ClInclude Include="PluginLoader.h" />
     <ClInclude Include="ProcessAccessHelp.h" />
     <ClInclude Include="ProcessLister.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="Scylla.h" />
     <ClInclude Include="StringConversion.h" />
     <ClInclude Include="SystemInformation.h" />
     <ClInclude Include="Thunks.h" />
     <ClInclude Include="TreeImportExport.h" />
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="MainGui.rc" />
   </ItemGroup>
   <ItemGroup>
     <None Include="check.ico" />
     <None Include="error.ico" />
     <None Include="scylla.ico" />
     <None Include="warning.ico" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
   <ProjectExtensions>
     <VisualStudio>
       <UserProperties RESOURCE_FILE="MainGui.rc" />
     </VisualStudio>
   </ProjectExtensions>
 </Project>
\ No newline at end of file
diff --git a/diStorm/diStorm.vcxproj b/diStorm/diStorm.vcxproj
index 1f770c8..b268de3 100644
--- a/diStorm/diStorm.vcxproj
+++ b/diStorm/diStorm.vcxproj
@@ -1,179 +1,177 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{A4B94DE4-BE0E-4E7D-95E7-7B84E6F117A1}</ProjectGuid>
     <RootNamespace>diStorm</RootNamespace>
     <Keyword>Win32Proj</Keyword>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
-    <PlatformToolset>v90</PlatformToolset>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
     <WholeProgramOptimization>true</WholeProgramOptimization>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>StaticLibrary</ConfigurationType>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
     <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(Platform)\$(Configuration)\</IntDir>
     <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(Platform)\$(Configuration)\</IntDir>
     <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(Platform)\$(Configuration)\</IntDir>
     <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)$(Platform)\$(Configuration)\</OutDir>
     <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(Platform)\$(Configuration)\</IntDir>
     <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
     <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" />
     <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
     <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" />
     <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">AllRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
     <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" />
     <CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='Release|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
     <CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;SUPPORT_64BIT_OFFSET;_DEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
       <AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;SUPPORT_64BIT_OFFSET;_DEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <WholeProgramOptimization>false</WholeProgramOptimization>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;SUPPORT_64BIT_OFFSET;NDEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Midl>
       <TargetEnvironment>X64</TargetEnvironment>
     </Midl>
     <ClCompile>
       <Optimization>MaxSpeed</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <WholeProgramOptimization>false</WholeProgramOptimization>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;SUPPORT_64BIT_OFFSET;NDEBUG;_LIB;DISTORM_STATIC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>true</MinimalRebuild>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <PrecompiledHeader>
       </PrecompiledHeader>
       <WarningLevel>Level3</WarningLevel>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <AdditionalIncludeDirectories>include</AdditionalIncludeDirectories>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="src\decoder.c" />
     <ClCompile Include="src\distorm.c" />
     <ClCompile Include="src\instructions.c" />
     <ClCompile Include="src\insts.c" />
     <ClCompile Include="src\mnemonics.c" />
     <ClCompile Include="src\operands.c" />
     <ClCompile Include="src\prefix.c" />
     <ClCompile Include="src\textdefs.c" />
     <ClCompile Include="src\wstring.c" />
-    <ClCompile Include="src\x86defs.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\config.h" />
     <ClInclude Include="src\decoder.h" />
     <ClInclude Include="include\distorm.h" />
     <ClInclude Include="src\instructions.h" />
     <ClInclude Include="src\insts.h" />
     <ClInclude Include="include\mnemonics.h" />
     <ClInclude Include="src\operands.h" />
     <ClInclude Include="src\prefix.h" />
     <ClInclude Include="src\textdefs.h" />
     <ClInclude Include="src\wstring.h" />
     <ClInclude Include="src\x86defs.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
 </Project>
\ No newline at end of file