Merged haxifix/PlugY + Code Formatting

2024-11-30 12:36:02 +00:00 · 2020-10-25 14:10:17 +01:00 · 2020-10-25 14:10:17 +01:00 · 93aaeb0b61
commit 93aaeb0b61
parent 9c3a7a01c3
33 changed files with 1806 additions and 533 deletions
--- a/Commons/D2Funcs.h
+++ b/Commons/D2Funcs.h
@ -1,6 +1,7 @@
 /*======================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
  Declares the type for a STDCALL or FASTCALL function pointer
  called N with arguments list P, returning R, namedInDLL D and at @A
@ -149,68 +150,68 @@
 //F7(STD,  D2Common,00000,00000,00000,00000,10001,00000,00000,00000,	DWORD,		D2GetActIDFromLevel, (DWORD levelID));
-F7(STD,  D2Common,00000,00000,00000,10188,11084,11109,10346,10907,	DWORD,		D2Common11084, (Room* ptRoom, DWORD zero));
+F8(STD,  D2Common,00000,00000,00000,10188,11084,11109,10346,10907, 21AED0, DWORD,		D2Common11084, (Room* ptRoom, DWORD zero));
-F7(STD,  D2Common,10057,10057,10057,10332,11021,10511,10826,10691,	DWORD,		D2GetLevelID, (Room* ptRoom));
+F8(STD,  D2Common,10057,10057,10057,10332,11021,10511,10826,10691, 21A1B0, DWORD,		D2GetLevelID, (Room* ptRoom));
-F7(STD,  D2Common,10138,10138,10138,10623,10491,11043,10654,10716,	Room*,		D2GetDropRoom, (Room* ptRoom, Position*, Position*, DWORD, DWORD, DWORD, DWORD));
+F8(STD,  D2Common,10138,10138,10138,10623,10491,11043,10654,10716, 24E810, Room*,		D2GetDropRoom, (Room* ptRoom, Position*, Position*, DWORD, DWORD, DWORD, DWORD));
 //F7(STD,  D2Common,10149,10149,10149,00000,00000,00000,00000,00000,	Inventory*,	D2GetInventory, (Unit* ptUnit));
-F7(STD,  D2Common,10242,10242,10242,00000,00000,00000,00000,00000,	Unit*,		D2Common10242, (Inventory* ptInventory, Unit* ptItem, DWORD bIsClient));
+F8(STD,  D2Common,10242,10242,10242,00000,00000,00000,00000,00000,00000, Unit*,		D2Common10242, (Inventory* ptInventory, Unit* ptItem, DWORD bIsClient));
-F7(STD,  D2Common,10246,10246,10246,10855,10813,10289,10133,10402,	Unit*,		D2CanPutItemInInv, (Inventory* ptInventory, Unit* ptItem, DWORD p3, DWORD zero, Unit* ptUnit, const char* file, DWORD line));
+F8(STD,  D2Common,10246,10246,10246,10855,10813,10289,10133,10402, 23B950, Unit*,		D2CanPutItemInInv, (Inventory* ptInventory, Unit* ptItem, DWORD p3, DWORD zero, Unit* ptUnit, const char* file, DWORD line));
-F7(STD,  D2Common,10243,10243,10243,10461,10827,10936,10646,10490,	Unit*,		D2InvRemoveItem, (Inventory* ptInventory, Unit* ptItem));
+F8(STD,  D2Common,10243,10243,10243,10461,10827,10936,10646,10490, 23AD90, Unit*,		D2InvRemoveItem, (Inventory* ptInventory, Unit* ptItem));
-F7(STD,  D2Common,10249,10249,10249,10880,11068,10436,11107,10963,	DWORD,		D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//result : boolean 0=echec  ; vValueC = 0 for Game.dll, 1 for Clientdll
+F8(STD,  D2Common,10249,10249,10249,10880,11068,10436,11107,10963, 23BCC0, DWORD,		D2InvAddItem, (Inventory* ptInventory, Unit* ptItem, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));//result : boolean 0=echec  ; vValueC = 0 for Game.dll, 1 for Clientdll
-F7(STD,  D2Common,10250,10250,10250,00000,00000,00000,00000,00000,	DWORD,		D2Common10250, (const char* file, DWORD line, Inventory* ptInventory, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));// result : boolean 0=echec  ; vValueC = 0 for Game.dll, 1 for Clientdll
+F8(STD,  D2Common,10250,10250,10250,00000,00000,00000,00000,00000, 00000, DWORD,		D2Common10250, (const char* file, DWORD line, Inventory* ptInventory, DWORD posX, DWORD posY, DWORD vValueC, DWORD bIsClient, BYTE page));// result : boolean 0=echec  ; vValueC = 0 for Game.dll, 1 for Clientdll
 //F7(STD,  D2Common,10257,10257,10257,00000,00000,00000,00000,00000,	Unit*,		D2GetItemFromBodyLoc, (Inventory* ptInventory, DWORD bodyloc));
-F7(STD,  D2Common,10273,10273,10273,00000,00000,00000,00000,00000,	DWORD,		D2Common10273, (Inventory* ptInventory, void* unknow));
+F8(STD,  D2Common,10273,10273,10273,00000,00000,00000,00000,00000, 00000, DWORD,		D2Common10273, (Inventory* ptInventory, void* unknow));
-F7(STD,  D2Common,10277,10277,10277,10402,10535,11151,10460,11040,	Unit*,		D2InventoryGetFirstItem, (Inventory* ptInventory));
+F8(STD,  D2Common,10277,10277,10277,10402,10535,11151,10460,11040, 23B2C0, Unit*,		D2InventoryGetFirstItem, (Inventory* ptInventory));
-F7(STD,  D2Common,10304,10304,10304,10934,11140,10770,10464,10879,	Unit*,		D2UnitGetNextItem, (Unit* ptItem));
+F8(STD,  D2Common,10304,10304,10304,10934,11140,10770,10464,10879, 23DFA0, Unit*,		D2UnitGetNextItem, (Unit* ptItem));
-F7(STD,  D2Common,10305,10305,10305,11095,10748,10852,11147,10897,	Unit*,		D2GetRealItem, (Unit* ptUnit));
+F8(STD,  D2Common,10305,10305,10305,11095,10748,10852,11147,10897, 23DFD0, Unit*,		D2GetRealItem, (Unit* ptUnit));
 //F7(STD,  D2Common,10321,10321,10321,00000,00000,00000,00000,00000,	SkillData*,	D2GetLeftSkill, (Unit* ptChar));
 //F7(STD,  D2Common,10322,10322,10322,00000,00000,00000,00000,00000,	SkillData*,	D2GetRightSkill, (Unit* ptChar));
-F7(STD,  D2Common,10326,10326,00000,00000,00000,00000,00000,00000,	DWORD,		D2GetPosX, (Unit* ptUnit));//NOT IN 1.10
+F8(STD,  D2Common,10326,10326,00000,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetPosX, (Unit* ptUnit));//NOT IN 1.10
 //F7(STD,  D2Common,10328,10328,10328,00000,00000,00000,00000,00000,	void,		D2SetPosX, (Unit* ptUnit, DWORD pos));
-F7(STD,  D2Common,10329,10329,00000,00000,00000,00000,00000,00000,	DWORD,		D2GetPosY, (Unit* ptUnit));//NOT IN 1.10
+F8(STD,  D2Common,10329,10329,00000,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetPosY, (Unit* ptUnit));//NOT IN 1.10
 //F7(STD,  D2Common,10331,10331,10331,00000,00000,00000,00000,00000,	void,		D2SetPosY, (Unit* ptUnit, DWORD pos));
-F7(STD,  D2Common,10332,10332,10332,11080,10056,10543,10141,11166,	void,		D2GetPosition, (Unit* ptUnit, Position* pos));
+F8(STD,  D2Common,10332,10332,10332,11080,10056,10543,10141,11166, 220870, void,		D2GetPosition, (Unit* ptUnit, Position* pos));
-F7(STD,  D2Common,10339,10339,10339,10455,10864,10941,11060,11025,	DWORD,		D2GetMaxGoldBank, (Unit* ptUnit));
+F8(STD,  D2Common,10339,10339,10339,10455,10864,10941,11060,11025, 223460, DWORD,		D2GetMaxGoldBank, (Unit* ptUnit));
-F7(STD,  D2Common,10342,10342,10342,10172,10933,10366,10331,10846,	Room*,		D2GetRoom, (Unit* ptUnit));
+F8(STD,  D2Common,10342,10342,10342,10172,10933,10366,10331,10846, 220BB0, Room*,		D2GetRoom, (Unit* ptUnit));
 //F7(STD,  D2Common,10348,10348,10348,00000,00000,00000,00000,00000,	void,		D2SetUnitMode, (Unit* ptUnit, DWORD mode));
 //F7(STD,  D2Common,10394,10394,10394,00000,00000,00000,00000,00000,	ObjectsBIN*,D2GetObjectsBIN, (Unit* ptObject));
-F7(STD,  D2Common,10420,10420,10420,10218,10079,11097,10356,10404,	PlayerData*,D2InitPlayerData, (Unit* ptChar));
+F8(STD,  D2Common,10420,10420,10420,10218,10079,11097,10356,10404, 221F90, PlayerData*,D2InitPlayerData, (Unit* ptChar));
 //F7(STD,  D2Common,10421,10421,10421,10914,10329,00000,00000,00000,	DWORD,		D2FreePlayerData, (DWORD game1C, Unit* ptChar));
-F7(STD,  D2Common,10424,10424,10424,10562,10800,10860,10920,11103,	PlayerData*,D2GetPlayerData, (Unit* ptChar));
+F8(STD,  D2Common,10424,10424,10424,10562,10800,10860,10920,11103, 2221A0, PlayerData*,D2GetPlayerData, (Unit* ptChar));
-F7(STD,  D2Common,10431,10431,10431,00000,00000,00000,00000,00000,	DWORD,		D2GetDefence, (Unit* ptChar));
+F8(STD,  D2Common,10431,10431,10431,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetDefence, (Unit* ptChar));
-F7(STD,  D2Common,10433,10433,10433,00000,00000,00000,00000,00000,	DWORD,		D2GetChanceToBlock, (Unit* ptChar, DWORD isLODGame));
+F8(STD,  D2Common,10433,10433,10433,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetChanceToBlock, (Unit* ptChar, DWORD isLODGame));
-F7(STD,  D2Common,10439,10439,10439,10343,11131,10729,10049,11159,	DWORD,		D2GetMaxGold, (Unit* ptUnit));
+F8(STD,  D2Common,10439,10439,10439,10343,11131,10729,10049,11159, 222E70, DWORD,		D2GetMaxGold, (Unit* ptUnit));
-F7(STD,  D2Common,00000,00000,00000,10440,10572,10481,11090,10193,	DWORD,		D2Common10572, (Unit* ptObject, DWORD value));
+F8(STD,  D2Common,00000,00000,00000,10440,10572,10481,11090,10193, 224690, DWORD,		D2Common10572, (Unit* ptObject, DWORD value));
 //F7(STD,  D2Common,10463,10463,10463,00000,00000,00000,00000,00000,	DWORD,		D2SetStatWithNoTest, ( Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
 //F7(STD,  D2Common,10464,10464,10464,00000,00000,00000,00000,00000,	void,		D2AddStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
 //F7(STD,  D2Common,10465,10465,10465,00000,00000,00000,00000,00000,	DWORD,		D2SetStat, (Stats* ptStats, DWORD statID, DWORD statValue, DWORD statIndex));
 //F7(STD,  D2Common,10466,10466,10466,00000,00000,00000,00000,00000,	int,		D2GetStat, (Stats* ptStats, DWORD statID, DWORD statIndex));
 //F7(STD,  D2Common,10470,10470,10470,00000,00000,00000,00000,00000,	Stats*,		D2AllocNewStats, (DWORD nUnitId, DWORD flags, DWORD uk18, DWORD nUnitType, DWORD nItemNum));
-F7(STD,  D2Common,00000,00000,00000,10471,11160,10866,10258,10040,	BYTE,		D2GetObjectFlags, (Unit* ptObject));
+F8(STD,  D2Common,00000,00000,00000,10471,11160,10866,10258,10040, 2222C0, BYTE,		D2GetObjectFlags, (Unit* ptObject));
-F7(STD,  D2Common,00000,00000,00000,10572,11048,10150,10111,10033,	void,		D2SetObjectFlags, (Unit* ptObject, BYTE flags));
+F8(STD,  D2Common,00000,00000,00000,10572,11048,10150,10111,10033, 222300, void,		D2SetObjectFlags, (Unit* ptObject, BYTE flags));
 //F7(STD,  D2Common,10471,10471,10471,00000,00000,00000,00000,00000,	DWORD,		D2Common10471, (void*));
 //F7(STD,  D2Common,10472,10472,10472,00000,00000,00000,00000,00000,	DWORD,		D2Common10472, (void*));
 //F7(STD,  D2Common,10475,10475,10475,00000,00000,00000,00000,00000,	void,		D2UpdateDisabledStat, (Stats* ptCharStats, Stats* ptStats, DWORD one));
 //F7(STD,  D2Common,10481,10481,10481,00000,00000,00000,00000,00000,	void*,		D2Common10481, (Unit* ptUnit, DWORD flags));
 //F7(STD,  D2Common,10484,10484,10484,00000,00000,00000,00000,00000,	Stats*,		D2GetAffixStats, (Unit* ptItem, DWORD, DWORD));
 //F7(STD,  D2Common,10485,10485,10485,00000,00000,00000,00000,00000,	void,		D2FreeStats, (Stats* ptStats));
-F7(STD,  D2Common,10487,10487,10487,00000,00000,00000,00000,00000,	DWORD,		D2isInState, (Unit* ptChar, DWORD isLODGame));
+F8(STD,  D2Common,10487,10487,10487,00000,00000,00000,00000,00000, 00000, DWORD,		D2isInState, (Unit* ptChar, DWORD isLODGame));
 //F7(STD,  D2Common,10517,10517,10517,00000,00000,00000,00000,00000,	void,		D2SetPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));
-F7(STD,  D2Common,10518,10518,10518,10109,10627,10762,10551,10645,	void,		D2AddPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));//ONLY 1.11b
+F8(STD,  D2Common,10518,10518,10518,10109,10627,10762,10551,10645, 2272B0, void,		D2AddPlayerStat, (Unit* ptChar, DWORD statID, int amount, DWORD index));//ONLY 1.11b
-F7(STD,  D2Common,10519,10519,10519,11092,10061,10658,10973,10550,	int,		D2GetPlayerStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
+F8(STD,  D2Common,10519,10519,10519,11092,10061,10658,10973,10550, 225480, int,		D2GetPlayerStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
 //F7(STD,  D2Common,10520,10520,10520,00000,00000,00000,00000,00000,	int,		D2GetPlayerStat20, (Unit* ptChar, DWORD statID, DWORD index));
-F7(STD,  D2Common,10521,10521,10521,10733,10550,10494,10587,10216,	int,		D2GetPlayerBaseStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
+F8(STD,  D2Common,10521,10521,10521,10733,10550,10494,10587,10216, 2253B0, int,		D2GetPlayerBaseStat, (Unit* ptChar, DWORD statID, DWORD index));//ONLY 1.11b
 //F7(STD,  D2Common,10527,10527,10527,00000,00000,00000,00000,00000,	DWORD,		D2Common10527, (Unit* ptUnit));
-F7(STD,  D2Common,10539,10539,10539,00000,00000,00000,00000,00000,	DWORD,		D2haveDefenceBonus, (Unit* ptChar));
+F8(STD,  D2Common,10539,10539,10539,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveDefenceBonus, (Unit* ptChar));
-F7(STD,  D2Common,10540,10540,10540,00000,00000,00000,00000,00000,	DWORD,		D2haveFireResBonus, (Unit* ptChar));
+F8(STD,  D2Common,10540,10540,10540,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveFireResBonus, (Unit* ptChar));
-F7(STD,  D2Common,10541,10541,10541,00000,00000,00000,00000,00000,	DWORD,		D2haveColdResBonus, (Unit* ptChar));
+F8(STD,  D2Common,10541,10541,10541,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveColdResBonus, (Unit* ptChar));
-F7(STD,  D2Common,10542,10542,10542,00000,00000,00000,00000,00000,	DWORD,		D2haveLightResBonus, (Unit* ptChar));
+F8(STD,  D2Common,10542,10542,10542,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveLightResBonus, (Unit* ptChar));
-F7(STD,  D2Common,10543,10543,10543,00000,00000,00000,00000,00000,	DWORD,		D2havePoisonResBonus, (Unit* ptChar));
+F8(STD,  D2Common,10543,10543,10543,00000,00000,00000,00000,00000, 00000, DWORD,		D2havePoisonResBonus, (Unit* ptChar));
-F7(STD,  D2Common,10546,10546,10546,00000,00000,00000,00000,00000,	DWORD,		D2haveDefenceMalus, (Unit* ptChar));
+F8(STD,  D2Common,10546,10546,10546,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveDefenceMalus, (Unit* ptChar));
-F7(STD,  D2Common,10547,10547,10547,00000,00000,00000,00000,00000,	DWORD,		D2haveFireResMalus, (Unit* ptChar));
+F8(STD,  D2Common,10547,10547,10547,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveFireResMalus, (Unit* ptChar));
-F7(STD,  D2Common,10548,10548,10548,00000,00000,00000,00000,00000,	DWORD,		D2haveColdResMalus, (Unit* ptChar));
+F8(STD,  D2Common,10548,10548,10548,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveColdResMalus, (Unit* ptChar));
-F7(STD,  D2Common,10549,10549,10549,00000,00000,00000,00000,00000,	DWORD,		D2haveLightResMalus, (Unit* ptChar));
+F8(STD,  D2Common,10549,10549,10549,00000,00000,00000,00000,00000, 00000, DWORD,		D2haveLightResMalus, (Unit* ptChar));
-F7(STD,  D2Common,10550,10550,10550,00000,00000,00000,00000,00000,	DWORD,		D2havePoisonResMalus, (Unit* ptChar));
+F8(STD,  D2Common,10550,10550,10550,00000,00000,00000,00000,00000, 00000, DWORD,		D2havePoisonResMalus, (Unit* ptChar));
 //F7(STD,  D2Common,10552,10552,10552,00000,00000,00000,00000,00000,	DWORD,		D2Common10552, (Unit* ptUnit));
 //F7(STD,  D2Common,10567,10567,10567,00000,00000,00000,00000,00000,	DWORD,		D2CanBeBroken, (Unit* ptItem));
 //F7(STD,  D2Common,10573,10573,10573,00000,00000,00000,00000,00000,	void,		D2CopyStats, (Stats* ptDestStats, Stats* ptSrcStats));
@ -218,35 +219,35 @@ F7(STD,  D2Common,10550,10550,10550,00000,00000,00000,00000,00000,	DWORD,		D2hav
 //F7(STD,  D2Common,10575,10575,10575,00000,00000,00000,00000,00000,	void,		D2FreeBinFiles, ());
 //F7(STD,  D2Common,10576,10576,10576,00000,00000,00000,00000,00000,	void,		D2LoadBinFiles, (DWORD zero1, DWORD zero2, bool));
 //F7(STD,  D2Common,00000,00000,00000,10651,10651,00000,00000,00000,	DWORD,		D2CheckQuestState, (void* ptQuest, DWORD index, DWORD value));
-F7(STD,  D2Common,10578,10578,10578,10653,10496,10244,10849,10037,	void*,		D2CompileTxtFile, (DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength));
+F8(STD,  D2Common,10578,10578,10578,10653,10496,10244,10849,10037, 2122F0, void*,		D2CompileTxtFile, (DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength));
-F7(STD,  D2Common,10600,10600,10600,10573,10262,10887,10695,10994,	ItemsBIN*,	D2GetItemsBIN, (DWORD itemID));
+F8(STD,  D2Common,10600,10600,10600,10573,10262,10887,10695,10994, 2335F0, ItemsBIN*,	D2GetItemsBIN, (DWORD itemID));
 //F7(STD,  D2Common,10601,10601,10601,00000,00000,00000,00000,00000,	ItemsBIN*,	D2GetByCodeItemStatsBIN, (DWORD code, DWORD* itemID));
 //F7(STD,  D2Common,10604,10604,10604,00000,00000,00000,00000,00000,	AffixBIN*,	D2GetAffixBIN, (int affixID));
-F7(STD,  D2Common,10616,10616,10616,10500,10523,10774,10806,10619,	GemsBIN*,	D2GetGemsBIN, (DWORD gemID));
+F8(STD,  D2Common,10616,10616,10616,10500,10523,10774,10806,10619, 10619, GemsBIN*,	D2GetGemsBIN, (DWORD gemID));
-F7(STD,  D2Common,11232,11232,11232,10746,10258,10913,10783,10393,	CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID));
+F8(STD,  D2Common,11232,11232,11232,10746,10258,10913,10783,10393, 26A1B0, CubeMainBIN*,D2GetCubeMainBIN, (DWORD cubemainID));
-F7(STD,  D2Common,11233,11233,11233,10639,11135,10390,10675,10235,	int,		D2GetNbCubeMainBIN, ());
+F8(STD,  D2Common,11233,11233,11233,10639,11135,10390,10675,10235, 26A200, int,		D2GetNbCubeMainBIN, ());
 //F7(STD,  D2Common,10737,10737,10737,00000,00000,00000,00000,00000,	LevelsBIN*,	D2GetLevelsBIN, (DWORD levelID));
-F7(STD,  D2Common,10628,10628,10628,00000,00000,00000,00000,00000,	DWORD,		D2GetNextLevelXP, (DWORD classID, DWORD level));
+F8(STD,  D2Common,10628,10628,10628,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetNextLevelXP, (DWORD classID, DWORD level));
-F7(STD,  D2Common,10629,10629,10629,00000,00000,00000,00000,00000,	DWORD,		D2GetMaxLevel, (DWORD classID));
+F8(STD,  D2Common,10629,10629,10629,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetMaxLevel, (DWORD classID));
-F7(STD,  D2Common,10655,10655,10655,10655,10309,10297,10218,10694,	DifficultyLevelsBIN*,	D2GetDifficultyLevelsBIN, (DWORD difficultyLevel));
+F8(STD,  D2Common,10655,10655,10655,10655,10309,10297,10218,10694, 10694, DifficultyLevelsBIN*,	D2GetDifficultyLevelsBIN, (DWORD difficultyLevel));
 //F7(STD,  D2Common,10659,10659,10659,00000,00000,00000,00000,00000,	TreasureClassBIN*,		D2GetTreasureClassBIN, (WORD id, DWORD uk));
 //F7(STD,  D2Common,10668,10668,10668,10450,10953,00000,00000,00000,	SuperUniqueBIN*,		D2GetSuperUniqueBIN, (WORD id));
-F7(STD,  D2Common,10695,10695,10695,10927,10899,10276,10106,10911,	DWORD,		D2GetItemQuality, (Unit* ptItem));
+F8(STD,  D2Common,10695,10695,10695,10927,10899,10276,10106,10911, 227E70, DWORD,		D2GetItemQuality, (Unit* ptItem));
-F7(STD,  D2Common,10707,10707,10707,10911,10303,10989,10202,10458,	DWORD,		D2TestFlags, (Unit* ptUnit, DWORD flags, DWORD line, const char* file));
+F8(STD,  D2Common,10707,10707,10707,10911,10303,10989,10202,10458, 2280A0, DWORD,		D2TestFlags, (Unit* ptUnit, DWORD flags, DWORD line, const char* file));
 //F7(STD,  D2Common,10708,10708,10708,00000,00000,00000,00000,00000,	void,		D2SetFlags, (Unit* ptUnit, DWORD flags, DWORD bitNewValue));
 //F7(STD,  D2Common,10709,10709,10709,00000,00000,00000,00000,00000,	DWORD,		D2GetFlags, (Unit* ptUnit));
 //F7(STD,  D2Common,10711,10711,10711,00000,00000,00000,00000,00000,	void,		D2ItemSetFlags, (Unit* ptItem, DWORD flags, DWORD toSet));// toSet = 0 for set to 0 the selected flags else set to 1
-F7(STD,  D2Common,10717,10717,10717,10898,10100,10410,10086,10008,	DWORD,		D2GetItemLevel, (Unit* ptItem));
+F8(STD,  D2Common,10717,10717,10717,10898,10100,10410,10086,10008, 2281E0, DWORD,		D2GetItemLevel, (Unit* ptItem));
-F7(STD,  D2Common,10719,10719,10719,10820,10505,10370,10020,10810,	BYTE,		D2ItemGetPage, (Unit* ptUnit));
+F8(STD,  D2Common,10719,10719,10719,10820,10505,10370,10020,10810, 228250, BYTE,		D2ItemGetPage, (Unit* ptUnit));
-F7(STD,  D2Common,10720,10720,10720,10485,10608,10223,10012,11026,	void,		D2ItemSetPage, (Unit* ptItem, BYTE page));
+F8(STD,  D2Common,10720,10720,10720,10485,10608,10223,10012,11026, 228280, void,		D2ItemSetPage, (Unit* ptItem, BYTE page));
-F7(STD,  D2Common,10731,10731,10731,11017,10890,10231,10744,10601,	DWORD,		D2CheckItemType, (Unit* ptItem, DWORD itype));
+F8(STD,  D2Common,10731,10731,10731,11017,10890,10231,10744,10601, 229BB0, DWORD,		D2CheckItemType, (Unit* ptItem, DWORD itype));
-F7(STD,  D2Common,10732,10732,10732,10692,10685,10280,10620,10075,	int,		D2GetUniqueID, (Unit* ptItem));
+F8(STD,  D2Common,10732,10732,10732,10692,10685,10280,10620,10075, 229DA0, int,		D2GetUniqueID, (Unit* ptItem));
-F7(STD,  D2Common,10734,10734,10734,00000,00000,00000,00000,00000,	void,		D2SetAnim, (Unit* ptUnit, int anim));
+F8(STD,  D2Common,10734,10734,10734,00000,00000,00000,00000,00000, 00000, void,		D2SetAnim, (Unit* ptUnit, int anim));
 //F7(STD,  D2Common,10749,10749,10749,00000,00000,00000,00000,00000,	void,		D2GetWidthHeight, (Unit* ptItem, BYTE* Width, BYTE* Height);
 //F7(STD,  D2Common,10751,10751,10751,00000,00000,00000,00000,00000,	DWORD,		D2GetItemType, (Unit* ptUnit));
 //F7(STD,  D2Common,10757,10757,10757,00000,00000,00000,00000,00000,	DWORD,		D2GetItemLevelReq, (Unit* ptChar, Unit* ptItem));
-F7(STD,  D2Common,10619,10619,10619,10687,10877,10321,11032,10981,	int*,		D2GetNbRunesBIN, ());//return the point on th number
+F8(STD,  D2Common,10619,10619,10619,10687,10877,10321,11032,10981, 10981, int*,		D2GetNbRunesBIN, ());//return the point on th number
-F7(STD,  D2Common,10620,10620,10620,10775,10296,10622,10006,10405,	RunesBIN*,	D2GetRunesBIN, (int runesID));
+F8(STD,  D2Common,10620,10620,10620,10775,10296,10622,10006,10405, 10405, RunesBIN*,	D2GetRunesBIN, (int runesID));
 //F7(STD,  D2Common,10792,10792,10792,00000,00000,00000,00000,00000,	DWORD,		D2CanBeRare, (Unit* ptItem));
 //F7(STD,  D2Common,10810,10810,10810,00000,00000,00000,00000,00000,	BYTE,		D2CheckHasInv, (Unit* ptItem));
 //F7(STD,  D2Common,10813,10813,10813,00000,00000,00000,00000,00000,	DWORD,		D2GetStaffMods, (Unit* ptItem));
@ -255,35 +256,36 @@ F7(STD,  D2Common,10620,10620,10620,10775,10296,10622,10006,10405,	RunesBIN*,	D2
 //F7(STD,  D2Common,10855,10855,10855,00000,00000,00000,00000,00000,	void,		D2AddAffix, (DWORD, DWORD, Unit* ptItem, AffixBIN* ptAffix, DWORD, DWORD));
 //F7(STD,  D2Common,10872,10872,10872,00000,00000,00000,00000,00000,	DWORD,		D2WarpPlayer, (Path* ptPath, Unit* ptChar, Room* ptRoom, DWORD x, DWORD y));
 //F7(STD,  D2Common,10875,10875,10875,00000,00000,00000,00000,00000,	WORD,		D2GetItemVersion, (Unit* ptItem));
-F7(STD,  D2Common,11163,11163,11163,10880,11068,10436,11107,10963,	DWORD,		D2isEtheral, (Unit* ptItem));//ONLY UNTIL 1.10
+F8(STD,  D2Common,11163,11163,11163,10880,11068,10436,11107,10963, 23BCC0, DWORD,		D2isEtheral, (Unit* ptItem));//ONLY UNTIL 1.10
-F7(STD,  D2Common,10881,10881,10881,10956,11156,10218,10987,10665,	DWORD,		D2SaveItem, (Unit* ptItem, saveBitField* data, DWORD startSize, DWORD p4, DWORD p5, DWORD p6));
+F8(STD,  D2Common, 11163, 11163, 11163, 10880, 11068, 10436, 11107, 10963, 23BCC0, DWORD, D2isEtheral2, (Unit* ptItem, DWORD a2, DWORD a3, DWORD a4, DWORD a5, DWORD a6, WORD a7));
 F8(STD,  D2Common,10881,10881,10881,10956,11156,10218,10987,10665, 2313E0, DWORD,		D2SaveItem, (Unit* ptItem, saveBitField* data, DWORD startSize, DWORD p4, DWORD p5, DWORD p6));
 //F7(STD,  D2Common,10916,10916,10916,00000,00000,00000,00000,00000,	void,		DoNothing916, ());
 //F7(STD,  D2Common,10940,10940,10940,10027,10105,10953,00000,00000,	void,		D2Common10027, (Unit* ptChar, DWORD skillID));
 //F7(STD,  D2Common,10950,10950,10950,00000,00000,00000,00000,00000,	SkillData*,	D2GetSkillPointer, (Unit* ptChar, WORD SkillID));
 //F7(STD,  D2Common,10952,10952,10952,10950,10256,10858,00000,00000,	SkillData*,	D2IncSkillBaseLevel, (Unit* ptChar, DWORD skillID));
-F7(STD,  D2Common,10953,10953,10953,10099,10255,10210,10302,10335,	void,		D2SetSkillBaseLevel,(Unit* ptChar, DWORD skillID, DWORD slvl, DWORD bRemove, char*, DWORD));
+F8(STD,  D2Common,10953,10953,10953,10099,10255,10210,10302,10335, 247280, void,		D2SetSkillBaseLevel,(Unit* ptChar, DWORD skillID, DWORD slvl, DWORD bRemove, char*, DWORD));
 //F7(STD,  D2Common,10963,10963,10963,00000,00000,00000,00000,00000,	DWORD,		D2GetSkillID, (SkillData* ptSkill, const char* file, DWORD line));
 //F7(FAST, D2Common,10966,10966,10966,00000,00000,00000,00000,00000,	SkillsBIN*,	D2GetSkillsBIN, (SkillData* ptSkill));
-F7(STD,  D2Common,10968,10968,10968,10700,10109,10904,10306,10007,	DWORD,		D2GetSkillLevel, (Unit* ptChar, SkillData* ptSkill, DWORD includingBonus));
+F8(STD,  D2Common,10968,10968,10968,10700,10109,10904,10306,10007, 2442A0, DWORD,		D2GetSkillLevel, (Unit* ptChar, SkillData* ptSkill, DWORD includingBonus));
 //F7(STD,  D2Common,11023,11023,11023,00000,00000,00000,00000,00000,	DWORD,		D2GetCriticalStrikeFromMasteries, (Unit* ptChar, Unit* ptItem, DWORD zero, DWORD two));
 //F7(STD,  D2Common,11007,11007,11007,00000,00000,00000,00000,00000,	bool,		D2TestQuestState, (void* ptQuest, DWORD QuestID, DWORD QuestState));
 //F7(STD,  D2Common,11041,11041,11041,00000,00000,00000,00000,00000,	int,		D2GetPlayerSkillID, (DWORD playerID, DWORD skillNumber));
 //F7(STD,  D2Common,11042,11042,11042,00000,00000,00000,00000,00000,	int,		D2GetNbSkillsPerPlayer, (DWORD playerID));
 //F7(STD,  D2Common,11269,11269,11269,00000,00000,00000,00000,00000,	DWORD,		D2GetAllIndexFromStat, (Stats* ptStats, DWORD statID, D2Stat* allIndex, DWORD maxIndex));
 //F7(STD,  D2Common,11270,11270,11270,00000,00000,00000,00000,00000,	DWORD,		D2GetAllIndexFromStatID, (Unit* ptItem, DWORD statID, D2Stat* allIndex, DWORD));
-F7(STD,  D2Common,11276,11276,11276,10254,10074,10111,10435,11081,	DWORD,		D2GetSkillCost, (Unit* ptChar, int skpoints, DWORD skillID, DWORD curSkillLevel));//not 10447
+F8(STD,  D2Common,11276,11276,11276,10254,10074,10111,10435,11081, 246D00, DWORD,		D2GetSkillCost, (Unit* ptChar, int skpoints, DWORD skillID, DWORD curSkillLevel));//not 10447
-A7(FAST, D2Common,00000,00000,82C80, 15D0, 1800, 1220, 12D0, 17B0,	CharStatsBIN*,	D2GetCharStatsBIN, (DWORD charID));
+A8(FAST, D2Common,00000,00000,82C80, 15D0, 1800, 1220, 12D0, 17B0, 833E0, CharStatsBIN*,	D2GetCharStatsBIN, (DWORD charID));
-A7(FAST, D2Common,00000,00000,12410,5D7D0,1A100,116C0,1C020,5B0E0,	DWORD,			D2CompileCubeInput, (CubeInput* cubeinput, char* s, DWORD p1, DWORD p2));
+A8(FAST, D2Common,00000,00000,12410,5D7D0,1A100,116C0,1C020,5B0E0, 268600, DWORD,			D2CompileCubeInput, (CubeInput* cubeinput, char* s, DWORD p1, DWORD p2));
-A7(FAST, D2Common,00000,00000,12910,5D210,19B40,11100,1BA60,5AB20,	DWORD,			D2CompileCubeOutput, (CubeOutput* cubeoutput, char* s, DWORD p1, DWORD p2));
+A8(FAST, D2Common,00000,00000,12910,5D210,19B40,11100,1BA60,5AB20, 5AB20, DWORD,			D2CompileCubeOutput, (CubeOutput* cubeoutput, char* s, DWORD p1, DWORD p2));
-A7(FAST, D2Common,00000,00000,2B1A0, 11F0, 1380, 1140, 1300, 1160,	ItemTypesBIN*,	D2GetItemTypesBIN, (DWORD itemTypesId));
+A8(FAST, D2Common,00000,00000,2B1A0, 11F0, 1380, 1140, 1300, 1160, 155C90, ItemTypesBIN*,	D2GetItemTypesBIN, (DWORD itemTypesId));
 //A7(FAST, D2Common,00000,00000,62FD0,00000,00000,00000,00000,00000,	void,			D2EncodeValueCheckMax, (saveBitField* data, DWORD value, DWORD bitSize));
-A7(FAST, D2Common,00000,00000,642B0, 13F0, 12F0, 1540, 17A0, 17E0,	ItemStatCostBIN*,D2GetItemStatCostBIN, (DWORD id));
+A8(FAST, D2Common,00000,00000,642B0, 13F0, 12F0, 1540, 17A0, 17E0, 5C4F0, ItemStatCostBIN*,D2GetItemStatCostBIN, (DWORD id));
 //A7(FAST, D2Common,00000,00000,764A0,00000,00000,00000,00000,00000,	void*,			D2Common764A0, (Stats* ptStats, DWORD stat, ItemStatCostBIN* itemStatCost ,DWORD));
 //A7(STD,  D2Common,00000,00000,76E30,00000,00000,00000,00000,00000,	void,			D2PreUpdateDisabledStat, (Stats* ptStats));
 //A7(FAST, D2Common,00000,00000,76C10,00000,00000,00000,00000,00000,	void,			D2ApplyStat,(Stats* ptCharStats, DWORD statId, DWORD value, Unit* ptItem));
-A7(FAST, D2Common,738A4,739B4,84268, 96E0, 98D0, 9900, 9900, B5E0,	void*,			D2ReadFile,(DWORD unused, char* filename, DWORD* size, const char*, DWORD));
+A8(FAST, D2Common,738A4,739B4,84268, 96E0, 98D0, 9900, 9900, B5E0, /*116E46*/117079, void*,			D2ReadFile,(DWORD unused, char* filename, DWORD* size, const char*, DWORD));
 //A7(FAST, D2Common,00000,00000, 94D0,00000,00000,00000,00000,00000,	void*,			D2GetStringIDForTxtFile,(const char * string));
-A7(STD,  D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40,	void,			D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
+A8(STD,  D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40, 2552E0, void,			D2LoadSuperuniques,(DWORD mempool));//FASCALL UNTIL 1.10
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -308,24 +310,24 @@ A7(STD,  D2Common,1F500,1F510,29FA0,71EB0,32AA0,7D2A0,59870,80C40,	void,			D2Loa
 //E2F(D2Client,5BA90,	void,		D2ReloadGambleScreen, ());//1.11b
 //E2F(D2Client,1FEB0,	void,		D2OpenNPCMenu, (Unit* ptNPC));//1.11b by ESI
-A7(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420,A9480,	void*,		D2LoadImage, (const char* filename, DWORD filetype));
+A8(FAST, D2Client, 1000, 1000, 1000,75D00,A9070,BEF70,2B420,A9480, 788B0, void*,		D2LoadImage, (const char* filename, DWORD filetype));
-A7(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000,00000,	void,		D2FreeImage, (void* image));//6FAA1140
+A8(FAST, D2Client, 1150, 1150, 1140,00000,00000,00000,00000,00000, 00000, void,		D2FreeImage, (void* image));//6FAA1140
-A7(FAST, D2Client, D640, D630, DB50,73620,5E4E0,79670,147A0,B6890,	void,		D2SendMsgToAll,(BYTE* data));//1.11 and 1.11b by ESI !!
+A8(FAST, D2Client, D640, D630, DB50,73620,5E4E0,79670,147A0,B6890, 787B0, void,		D2SendMsgToAll,(BYTE* data));//1.11 and 1.11b by ESI !!
 //A7(STD,  D2Client,00000,00000,15A80,00000,00000,00000,00000,00000,	int,		D2GetAvgChanceMonsterWillHitYou, ());//6FAB5A80
-A7(STD,  D2Client,00000,00000,15A80,00000,00000,00000,00000,00000,	DWORD,		D2GetLastMonsterIDFight, ());//6FAB5A80
+A8(STD,  D2Client,00000,00000,15A80,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetLastMonsterIDFight, ());//6FAB5A80
-A7(STD,  D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0,BF640,	void,		D2PrintStatsPage, ());
+A8(STD,  D2Client,29800,297F0,2FD60,828A0,89320,6B280,BCEA0,BF640, A7D00, void,		D2PrintStatsPage, ());
 //A7(FAST, D2Client,00000,00000,45990,00000,00000,00000,00000,00000,	Unit*,		D245990, (Inventory*,DWORD idItem);//6FAE5990
-A7(FAST, D2Client,4BB20,4BB20,521C0,B8CB0,21250,88EA0,54E10,2CE40,	DWORD,		D2PrintStat,(Unit* ptItem, Stats* ptStats, DWORD statID, DWORD statIndex, DWORD statValue, LPWSTR lpText));//statID=EAX, lpText=ESI 1.11b
+A8(FAST, D2Client,4BB20,4BB20,521C0,B8CB0,21250,88EA0,54E10,2CE40, E4D80, DWORD,		D2PrintStat,(Unit* ptItem, Stats* ptStats, DWORD statID, DWORD statIndex, DWORD statValue, LPWSTR lpText));//statID=EAX, lpText=ESI 1.11b
-A7(FAST, D2Client,85A60,84DE0,80430,9EEB0,62070,8B7A0,BF5F0,18820,	LPWSTR,		D2SetColorPopup, (LPWSTR popupText, DWORD color));//1.11 and 1.11b BY EDI
+A8(FAST, D2Client,85A60,84DE0,80430,9EEB0,62070,8B7A0,BF5F0,18820, 521C0, LPWSTR,		D2SetColorPopup, (LPWSTR popupText, DWORD color));//1.11 and 1.11b BY EDI
 //A7(FAST, D2Client,00000,00000,869F0,00000,00000,00000,00000,00000,	Unit*,		D2ClientGetObject, (DWORD itemNum, DWORD type));//6FB269F0
-A7(FAST, D2Client,B4360,B36E0,B5820,3ACC0,54210,31FA0,88A70,26270,	DWORD,		D2PlaySound, (DWORD id, DWORD, DWORD, DWORD, DWORD));
+A8(FAST, D2Client,B4360,B36E0,B5820,3ACC0,54210,31FA0,88A70,26270, B9A00, DWORD,		D2PlaySound, (DWORD id, DWORD, DWORD, DWORD, DWORD));
 //A7(FAST, D2Client,B9970,B8CF0,BB0F0,00000,00000,00000,00000,00000,	void,		D2FillRect,(DWORD x, DWORD y, DWORD Width, DWORD Height, DWORD color, DWORD transTbl));
-A7(FAST, D2Client,00000,00000,00000,00000,571C0,18450,46150,790D0,	Unit*,		D2GetCurrentNPC, ());
+A8(FAST, D2Client,00000,00000,00000,00000,571C0,18450,46150,790D0, 790D0, Unit*,		D2GetCurrentNPC, ());
-A7(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0,B61F0,	void,		D2SendToServerXX,(DWORD size, BYTE * data));//by EBX
+A8(FAST, D2Client,00000,00000,00000,73260,5DE40,791A0,143E0,B61F0, 78350, void,		D2SendToServerXX,(DWORD size, BYTE * data));//by EBX
-A7(FAST, D2Client,88940,87CC0,83260,A1F30,65690,8EF00,C2790,1C190,	void,		D2TogglePage, (DWORD a, DWORD b, DWORD c));
+A8(FAST, D2Client,88940,87CC0,83260,A1F30,65690,8EF00,C2790,1C190, 55F20, void,		D2TogglePage, (DWORD a, DWORD b, DWORD c));
-A7(FAST, D2Client,00000,00000,00000,A6520,710C0,A6640,8CD00,90C10,	void,		D2ClickOnStashButton, (DWORD x, DWORD y));//BY x=ESI y=EDI
+A8(FAST, D2Client,00000,00000,00000,A6520,710C0,A6640,8CD00,90C10, 89980, void,		D2ClickOnStashButton, (DWORD x, DWORD y));//BY x=ESI y=EDI
-A7(STD,  D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0,18AA0,	void*,		D2LoadBuySelBtn, ());
+A8(STD,  D2Client,897B0,88B30,84110,9E3B0,621C0,8B8F0,BEAF0,18AA0, 54600, void*,		D2LoadBuySelBtn, ());
-A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60,	void,		D2ReloadGambleScreen, ());
+A8(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60, 7DC60, void,		D2ReloadGambleScreen, ());
 //A7(FAST, D2Client,00000,00000,00000,00000,1FEB0,5CDD0,00000,00000,	void,		D2OpenNPCMenu, (Unit* ptNPC));//by ESI
@ -370,43 +372,43 @@ A7(FAST, D2Client,00000,00000,00000,8E480,5BA90,1CC00,4ABE0,7DC60,	void,		D2Relo
 //E2S(D2Game,E66D0,	void,		D2SaveGame, (Game* ptGame));//1.11b
-F7(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049,10002,	void,		D2SetNbPlayers, (DWORD nbPlayers));
+F8(FAST, D2Game,10059,10059,10059,10039,10007,10037,10049,10002, 135780, void,		D2SetNbPlayers, (DWORD nbPlayers));
 //A7(FAST, D2Game,00000,00000,01DE0,00000,00000,00000,00000,00000,	void*,		D2GetClientByClientID, (Game* ptGame, DWORD clientID));//6FC31DE0
-A7(FAST, D2Game,00000,00000, 6C60,E3DA0,E8210,EB060,49930,E5070,	void,		D2AddClient, (DWORD clientID));//BY EAX
+A8(FAST, D2Game,00000,00000, 6C60,E3DA0,E8210,EB060,49930,E5070, 12C550, void,		D2AddClient, (DWORD clientID));//BY EAX
-A7(STD,  D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0,BC700,	Game*,		D2GetGameByClientID, (DWORD clientID));//6FC394E0
+A8(STD,  D2Game,00000,00000, 94E0,E0520,E49A0,A6360,2AAE0,BC700, /*12E860*/12FEE0, Game*,		D2GetGameByClientID, (DWORD clientID));//6FC394E0
-A7(FAST, D2Game,00000,00000, B0E0,DF250,E36D0,A5080,29820,BB510,	void,		D2BroadcastFunction, (Game* ptGame, void* fct, void* param));//00DAB0E0
+A8(FAST, D2Game,00000,00000, B0E0,DF250,E36D0,A5080,29820,BB510, 12DED0, void,		D2BroadcastFunction, (Game* ptGame, void* fct, void* param));//00DAB0E0
-A7(FAST, D2Game, C380, C650, C710,41420,A0D50,7D220,8A3E0,DB780,	DWORD,		D2SendPacket, (void* ptNetClient, LPVOID pData, DWORD size));//EAX=ptNetClient [ESP]=pData
+A8(FAST, D2Game, C380, C650, C710,41420,A0D50,7D220,8A3E0,DB780, 13B280, DWORD,		D2SendPacket, (void* ptNetClient, LPVOID pData, DWORD size));//EAX=ptNetClient [ESP]=pData
-A7(FAST, D2Game, D650, D920, DB50,44D00,A3F20,802E0,8D5F0,DD4F0,	void,		D2SetSkillBaseLevelOnClient, (void* ptClient, Unit* ptChar, DWORD skillID, DWORD sLvl, DWORD bRemove));//by EAX,ESI,EBX
+A8(FAST, D2Game, D650, D920, DB50,44D00,A3F20,802E0,8D5F0,DD4F0, 13C4A0, void,		D2SetSkillBaseLevelOnClient, (void* ptClient, Unit* ptChar, DWORD skillID, DWORD sLvl, DWORD bRemove));//by EAX,ESI,EBX
 //A7(FAST, D2Game,00000,00000,0E6F0,00000,00000,00000,00000,00000,	void,		D2UpdateClientItem, (NetClient*	ptNetClient, Unit* ptChar, Unit* ptItem,DWORD,DWORD,DWORD));//6FC3E6F0
 //A7(FAST, D2Game,00000,00000,10FB0,00000,00000,00000,00000,00000,	DWORD,		D2UpdateInventory, (Game* ptGame, Unit* ptChar, void* ptNetClient, Inventory* pInventory));//6FC40FB0
 //A7(FAST, D2Game,00000,00000,110E0,00000,00000,00000,00000,00000,	DWORD,		D2UpdateItem, (Unit* ptChar, Unit* ptItem, Unit* ptSocketedItem, void* ptNetClient));//6FC410E0
-A7(STD,  D2Game,00000,00000,00000,27230,109F0,AE930,A22E0,15F40,	DWORD,		D2LinkPortal, (Game* ptGame, Unit* ptObject, DWORD levelEndID, DWORD levelStartID));
+A8(STD,  D2Game,00000,00000,00000,27230,109F0,AE930,A22E0,15F40, 16CF40, DWORD,		D2LinkPortal, (Game* ptGame, Unit* ptObject, DWORD levelEndID, DWORD levelStartID));
-A7(FAST, D2Game,00000,00000,128F0,38D90,43E60,11FF0,D2070,B2F70,	DWORD,		D2VerifIfNotCarry1, (Unit* ptItem, ItemsBIN* itemsData, Unit* ptFirstItem));// BY EBX=itemsData EAX=ptFirstItem [ESP]=ptItem
+A8(FAST, D2Game,00000,00000,128F0,38D90,43E60,11FF0,D2070,B2F70, 15CA40, DWORD,		D2VerifIfNotCarry1, (Unit* ptItem, ItemsBIN* itemsData, Unit* ptFirstItem));// BY EBX=itemsData EAX=ptFirstItem [ESP]=ptItem
 //A7(FAST, D2Game,00000,00000,1ED80,00000,00000,00000,00000,00000,	Unit*,		D2CreateItem, (Game* ptGame, ItemGenerationData* itemGenerationData, DWORD));//6FC4ED80
-A7(FAST, D2Game,00000,00000,22070, 1090, 1DF0, 11F0, 1280, 1340,	Room*,		D2TestPositionInRoom, (Room* ptRoom, DWORD x, DWORD y));
+A8(FAST, D2Game,00000,00000,22070, 1090, 1DF0, 11F0, 1280, 1340, 63740, Room*,		D2TestPositionInRoom, (Room* ptRoom, DWORD x, DWORD y));
 //A7(FAST, D2Game,00000,00000,22410,00000,00000,00000,00000,00000,	void,		D2AddStaffModAffixes, (Unit* ptItem, ItemGenerationData* itemParam));//6FC52410
 //A7(FAST, D2Game,00000,00000,22C00,00000,00000,00000,00000,00000,	WORD,		D2GetNewAffix, (Unit* ptItem, DWORD testIfSpawnable, DWORD mustSelectOne, DWORD addToItem, DWORD isPrefix, int affixID, WORD autoAffixGroupID));//6FC52C00
 //A7(FAST, D2Game,00000,00000,23610,00000,00000,00000,00000,00000,	WORD,		D2GetRareAffixName, (Unit* ptItem, DWORD wantPrefix));//6FC53610
 //A7(FAST, D2Game,00000,00000,3AD10,00000,00000,00000,00000,00000,	DWORD,		D2GetSuperUniqueMonsterID, (Game* ptGame, Unit* ptMonster));//6FC6AD10
-A7(FAST, D2Game,00000,00000,3F220,4ABE0,EC7E0,40B90,24950,CDE20,	DWORD,		D2SpawnMonster, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//wrong param
+A8(FAST, D2Game,00000,00000,3F220,4ABE0,EC7E0,40B90,24950,CDE20, 1A09E0, DWORD,		D2SpawnMonster, (Game* ptGame, Room* ptRoom, DWORD zero1, DWORD x, DWORD y, DWORD minusOne, DWORD superuniqueID, DWORD zero2));//wrong param
-A7(STD,  D2Game,00000,00000,00000,D6D10,235C0, D410,200E0,59980,	void,		D2Game235C0, (Game* ptGame, Room* ptRoom));
+A8(STD,  D2Game,00000,00000,00000,D6D10,235C0, D410,200E0,59980, 142B40, void,		D2Game235C0, (Game* ptGame, Room* ptRoom));
 //A7(FAST, D2Game,00000,00000,4C7B0,00000,00000,00000,00000,00000,	Unit*,		D2GetSkillItem, (Unit* ptChar));//6FC7C7B0
 //A7(FAST, D2Game,00000,00000,5A500,00000,00000,00000,00000,00000,	DWORD,		D2SavePlayer, (Game* ptGame, Unit* ptChar, char* playername, DWORD zero));//6FC8A500
-A7(FAST, D2Game,4F100,4F500,5B8A0,B9D70,25D50,44950,54810,3A4C0,	DWORD,		D2LoadInventory, (Game* ptGame, Unit* pChar, saveBitField* pdata, DWORD p2, DWORD maxSize, DWORD p4, DWORD *ptNbBytesRead));//6FC8B8A0
+A8(FAST, D2Game,4F100,4F500,5B8A0,B9D70,25D50,44950,54810,3A4C0, 1335E0, DWORD,		D2LoadInventory, (Game* ptGame, Unit* pChar, saveBitField* pdata, DWORD p2, DWORD maxSize, DWORD p4, DWORD *ptNbBytesRead));//6FC8B8A0
-A7(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0,6DC40,	Unit*,		D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00
+A8(FAST, D2Game,7BAE0,7BFD0,8BB00,97620,BEF80,93650,E03A0,6DC40, 152F60, Unit*,		D2GameGetObject, (Game* ptGame, DWORD type, DWORD itemNum));//6FCBBB00
 //A7(FAST, D2Game,00000,00000,9F320,501C0,F1C50,F1A50,F3220,00000,	Unit*,		D2GetOwnerMonster, (Unit* ptMonster));
 //A7(FAST, D2Game,00000,00000,E08D0,00000,00000,00000,00000,00000,	void,		D2UpdateSkillDataAfterUnassignment, (Game* ptGame, Unit* ptChar, DWORD skillID));//6FD108D0
-A7(FAST, D2Game,00000,00000,00000,99760,C09E0,94E70,E1D90,6FE10,	Unit*,		D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));
+A8(FAST, D2Game,00000,00000,00000,99760,C09E0,94E70,E1D90,6FE10, 155230, Unit*,		D2CreateUnit, (DWORD type, DWORD id, DWORD x, DWORD y, Game* ptGame, Room* ptRoom, DWORD uk1, DWORD uk2, DWORD uk3));
-A7(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180,941E0,	void,		D2OpenPandPortal, (Game* ptGame, Unit* ptChar));
+A8(FAST, D2Game,00000,00000,00000,9B480,34920,D1AA0,70180,941E0, 194270, void,		D2OpenPandPortal, (Game* ptGame, Unit* ptChar));
-A7(FAST, D2Game,00000,00000,00000,9B470,34910,D1A90,70170,941D0,	void,		D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));
+A8(FAST, D2Game,00000,00000,00000,9B470,34910,D1A90,70170,941D0, 194280, void,		D2OpenPandFinalPortal, (Game* ptGame, Unit* ptChar));
-A7(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610,31920,	void,		D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,84730,85AA0,DBE90,A9610,31920, 1E9170, void,		D2MephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
-A7(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60,4EAD0,	void,		D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,75980,D7BD0,CD0F0,85B60,4EAD0, 1F78B0, void,		D2DiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
-A7(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850,	void,		D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,EAB20,2BC80,B3B90,B8610,C8850, 1FCFE0, void,		D2BaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
-A7(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0,49480,	void,		D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,70320,D2D70,C2A90,7B4E0,49480, 1F81C0, void,		D2UberMephIA, (Game* ptGame, Unit* ptMonster, DWORD*));
-A7(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0,2C3F0,	void,		D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,7F200,7FE60,D6250,A39D0,2C3F0, 1E9DF0, void,		D2UberDiabloIA, (Game* ptGame, Unit* ptMonster, DWORD*));
-A7(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80,C6EC0,	void,		D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
+A8(FAST, D2Game,00000,00000,00000,E92B0,2A300,B2210,B6C80,C6EC0, 1FD200, void,		D2UberBaalIA, (Game* ptGame, Unit* ptMonster, DWORD*));
 //A7(FAST, D2Game,00000,00000,00000,00000,92420,00000,00000,00000,	void,		D2ReloadGambleScreenGame, (Unit* ptNPC, Game* ptGame, Unit* ptChar, DWORD, DWORD one));
-A7(STD,  D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660,	void,		D2SaveGame, (Game* ptGame) );
+A8(STD,  D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660, 12CA10, void,		D2SaveGame, (Game* ptGame) );
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -414,8 +416,8 @@ A7(STD,  D2Game,00000,00000, 89C0,E2390,E66D0,A8090,2C830,BE660,	void,		D2SaveGa
 //D2S(D2Net,10020,	DWORD,		D2SendToServer, (DWORD size, DWORD one, void* data));//ONLY 1.11b
 //D2S(D2Net,10018,	DWORD,		D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));//ONLY 1.11b
-F7(STD,  D2Net,	10005,10005,10005,10035,10020,10036,10024,10015,	DWORD,		D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before
+F8(STD,  D2Net,	10005,10005,10005,10035,10020,10036,10024,10015, 12AE50, DWORD,		D2SendToServer, (DWORD size, DWORD one, void* data));//(DWORD zero, void* data, DWORD size) for 1.10 and before
-F7(STD,  D2Net,	10006,10006,10006,10018,10018,10015,10002,10012,	DWORD,		D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));
+F8(STD,  D2Net,	10006,10006,10006,10018,10018,10015,10002,10012, 12B330, DWORD,		D2SendToClient, (DWORD zero, DWORD clientID, void* data, DWORD size));
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -440,25 +442,25 @@ F7(STD,  D2Net,	10006,10006,10006,10018,10018,10015,10002,10012,	DWORD,		D2SendT
 ////D2S(Fog,10217,		int,		D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
 //D2S(Fog,10265,		int,		D2GetInstructionPointer, ());//ONLY 1.11/1.11b NOT 1.10
-F7(STD,  Fog,	10023,10023,10023,00000,00000,00000,00000,00000,	void,		D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10)
+F8(STD,  Fog,	10023,10023,10023,00000,00000,00000,00000,00000, 00000, void,		D2FogAssertOld, (const char* ptMessage, DWORD eip, DWORD line));//(STDCALL until 1.10)
-F7(FAST, Fog,	00000,00000,00000,10024,10024,10024,10024,10024,	void,		D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line));
+F8(FAST, Fog,	00000,00000,00000,10024,10024,10024,10024,10024, 8A60, void,		D2FogAssert, (const char* ptMessage, DWORD eip, DWORD line));
-F7(FAST, Fog,	10042,10042,10042,10042,10042,10042,10042,10042,	void*,		D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
+F8(FAST, Fog,	10042,10042,10042,10042,10042,10042,10042,10042, B380, void*,		D2FogMemAlloc, (DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
-F7(FAST, Fog,	10043,10043,10043,10043,10043,10043,10043,10043,	void*,		D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
+F8(FAST, Fog,	10043,10043,10043,10043,10043,10043,10043,10043, B3C0, void*,		D2FogMemDeAlloc, (void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
-F7(FAST, Fog,	10045,10045,10045,10045,10045,10045,10045,10045,	void*,		D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
+F8(FAST, Fog,	10045,10045,10045,10045,10045,10045,10045,10045, B430, void*,		D2AllocMem, (DWORD,DWORD dwMemSize, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
-F7(FAST, Fog,	10046,10046,10046,10046,10046,10046,10046,10046,	void*,		D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
+F8(FAST, Fog,	10046,10046,10046,10046,10046,10046,10046,10046, B480, void*,		D2FreeMem, (DWORD,void* ptMemLoc, LPCSTR lpszErrFile, DWORD ErrLine, DWORD Zero));
-F7(FAST, Fog,	10102,10102,10102,10102,10102,10102,10102,10102,	DWORD,		D2MPQOpenFile, (char* ptPath, void** buf));
+F8(FAST, Fog,	10102,10102,10102,10102,10102,10102,10102,10102, 68E0, DWORD,		D2MPQOpenFile, (char* ptPath, void** buf));
-F7(FAST, Fog,	10103,10103,10103,10103,10103,10103,10103,10103,	DWORD,		D2MPQCloseFile, (void* mpqfile));
+F8(FAST, Fog,	10103,10103,10103,10103,10103,10103,10103,10103, 68F0, DWORD,		D2MPQCloseFile, (void* mpqfile));
-F7(FAST, Fog,	10104,10104,10104,10104,10104,10104,10104,10104,	DWORD,		D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD));
+F8(FAST, Fog,	10104,10104,10104,10104,10104,10104,10104,10104, 6900, DWORD,		D2MPQReadFile, (void* mpqfile, BYTE* buffer, DWORD nbToRead, DWORD* nbRead,DWORD,DWORD,DWORD));
-F7(FAST, Fog,	10105,10105,10105,10105,10105,10105,10105,10105,	DWORD,		D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset));
+F8(FAST, Fog,	10105,10105,10105,10105,10105,10105,10105,10105, 6930, DWORD,		D2MPQGetSizeFile, (void* mpqfile, DWORD* toReset));
-F7(FAST, Fog,	10115,10115,10115,10115,10115,10115,10115,10115,	void,		D2FogGetSavePath, (char* ptPath, DWORD maxsize));
+F8(FAST, Fog,	10115,10115,10115,10115,10115,10115,10115,10115, 7050, void,		D2FogGetSavePath, (char* ptPath, DWORD maxsize));
-F7(FAST, Fog,	10116,10116,10116,10116,10116,10116,10116,10116,	void,		D2FogGetInstallPath, (char* ptPath, DWORD maxsize));
+F8(FAST, Fog,	10116,10116,10116,10116,10116,10116,10116,10116, 6BA0, void,		D2FogGetInstallPath, (char* ptPath, DWORD maxsize));
 //F7(STD,  Fog, 10126,10126,10126,10126,10126,10126,10126,10126,	DWORD,		D2InitBitField, (saveBitField* data, BYTE* buf, DWORD bufsize));//6FF536C0
 //F7(STD,  Fog, 10127,10127,10127,10127,10127,10127,10127,10127,	DWORD,		D2GetBitFieldSize, (saveBitField* data));//6FF536C0
 //F7(STD,  Fog, 10128,10128,10128,10128,10128,10128,10128,10128,	void,		D2EncodeValue, (saveBitField* data, DWORD value, DWORD bitSize));//6FF536C0
 //F7(STD,  Fog, 10130,10130,10130,10130,10130,10130,10130,10130,	DWORD,		D2DecodeValue, (saveBitField* data,DWORD readingSize));//6FF53840
-F7(STD,  Fog,	10212,10212,10212,10212,10212,10212,10212,10212,	void,		D2Fog10212, (DWORD unknow));
+F8(STD,  Fog,	10212,10212,10212,10212,10212,10212,10212,10212, 2BD0B0, void,		D2Fog10212, (DWORD unknow));
 //F7(STD,  Fog, 10217,10217,10217,10217,10217,10217,10217,10217,	int,		D2GetIDFromLookUpTable, (void* table, char* string, bool));//6FF53840
-F7(STD,  Fog,	00000,00000,00000,10265,10265,10265,10265,10265,	int,		D2GetInstructionPointer, ());
+F8(STD,  Fog,	00000,00000,00000,10265,10265,10265,10265,10265, 8090, int,		D2GetInstructionPointer, ());
 //Fog10213 getIndexFromLookupTable (&table,code,bool)
@ -478,11 +480,11 @@ F7(STD,  Fog,	00000,00000,00000,10265,10265,10265,10265,10265,	int,		D2GetInstru
 ////E2S(D2Lang,1670,	DWORD,		D2swprintf, (DWORD bufSize, LPWSTR buf, LPWSTR string, ...));//6FC11670_sprintf
 //F7(FAST, D2Lang,	10003,10003,10003,00000,00000,00000,00000,10011,	LPWSTR,		D2GetStringFromString, (const char* ptString));//6FC13BC0
-F7(FAST, D2Lang,	10003,10003,10003,10002,10004,10010,10011,10011,	LPWSTR,		D2GetStringFromString, (const char* ptString));//6FC13BC0 LAutour
+F8(FAST, D2Lang,	10003,10003,10003,10002,10004,10010,10011,10011, 124E20, LPWSTR,		D2GetStringFromString, (const char* ptString));//6FC13BC0 LAutour
-F7(FAST, D2Lang,	10004,10004,10004,10005,10000,10005,10003,10004,	LPWSTR,		D2GetStringFromIndex, (WORD dwIndexNum));
+F8(FAST, D2Lang,	10004,10004,10004,10005,10000,10005,10003,10004, 124A30, LPWSTR,		D2GetStringFromIndex, (WORD dwIndexNum));
 //F7(STD,  D2Lang,	10006,10006,10006,00000,00000,00000,00000,00000,	void,		D2GetStringLang, (LPSTR ptLang, DWORD Zero));//6FC13FB0
-F7(STD,  D2Lang,	10007,10007,10007,10009,10013,10002,10009,10001,	DWORD,		D2GetLang, ());//14b  00522A20
+F8(STD,  D2Lang,	10007,10007,10007,10009,10013,10002,10009,10001, 125150, DWORD,		D2GetLang, ());//14b  00522A20
-F7(STD,  D2Lang,	10010,10010,10010,00000,00000,00000,00000,00000,	DWORD,		D2PrintBigNumber, (LPWSTR ptBuf , DWORD number, DWORD size));//6FC14210
+F8(STD,  D2Lang,	10010,10010,10010,00000,00000,00000,00000,00000, 00000, DWORD,		D2PrintBigNumber, (LPWSTR ptBuf , DWORD number, DWORD size));//6FC14210
 //F7(STD,  D2Lang,	10013,10013,10013,00000,00000,00000,00000,10005,	DWORD,		D2GetStringAndIndexFromString, (const char* ptString , LPWSTR result));//6FC13960
 //A7(FAST, D2Lang,	00000,00000,029B0,00000,00000,00000,00000,00000,	DWORD,		D2UnicodeWidth, (DWORD MemLoc, WORD Size));//6FC129B0
 //A7(FAST, D2Lang,	00000,00000,02E60,00000,00000,00000,00000,00000,	LPWSTR,		D2GetStrFromIndex , (void* ptFile, void* ptMemLoc, DWORD dwIndexNum));//6FC12E60
@ -499,9 +501,9 @@ F7(STD,  D2Lang,	10010,10010,10010,00000,00000,00000,00000,00000,	DWORD,		D2Prin
 //D2S(Storm,511,		void,		D2FreeWinMessage, (sWinMessage* msg));//1.11/1.11b
 //F7(STD,  Storm,	  253,  253,  253,  253,  253,  253,  000,  000,	void,		D2StormMPQCloseFile, (void* mpqfile));
-F7(STD,  Storm,	  268,  268,  268,  268,  268,  268,  268,  268,	DWORD,		D2StormMPQOpenFile, (DWORD zero, LPCSTR fileName, DWORD dwSearchScope, void** buffer))
+F8(STD,  Storm,	  268,  268,  268,  268,  268,  268,  268,  268, 192F0, DWORD,		D2StormMPQOpenFile, (DWORD zero, LPCSTR fileName, DWORD dwSearchScope, void** buffer))
-F7(STD,  Storm,	  503,  503,  503,  503,  503,  503,  503,  503,	void,		D2Storm503, (DWORD, DWORD, DWORD));
+F8(STD,  Storm,	  503,  503,  503,  503,  503,  503,  503,  503, 13750, void,		D2Storm503, (DWORD, DWORD, DWORD));
-F7(STD,  Storm,	  511,  511,  511,  511,  511,  511,  511,  511,	void,		D2FreeWinMessage, (sWinMessage* msg));
+F8(STD,  Storm,	  511,  511,  511,  511,  511,  511,  511,  511, 20290, void,		D2FreeWinMessage, (sWinMessage* msg));
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -513,12 +515,12 @@ F7(STD,  Storm,	  511,  511,  511,  511,  511,  511,  511,  511,	void,		D2FreeWi
 //D2S(D2gfx,10000,	void,		D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));//ONLY 1.11b
 //D2S(D2gfx,10044,	void,		D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );//ONLY 1.11b
-F7(STD,  D2gfx,	10005,10005,10005,10000,10063,10043,10031,10012,	DWORD,		D2GetResolution,() );
+F8(STD,  D2gfx,	10005,10005,10005,10000,10063,10043,10031,10012, F5160, DWORD,		D2GetResolution,() );
 //F7,STD,  D2gfx,	10023,10023,10023,00000,00000,00000,00000,00000,	DWORD,		D2CreateMainWindow,(DWORD,DWORD) );
 //F7(STD,  D2gfx,	10026,10026,10026,00000,00000,00000,00000,00000,	DWORD,		D2ShowWindow,() );
 //F7,STD,  D2gfx,	10027,10027,10027,00000,00000,00000,00000,00000,	HWND,		D2GetWindowHandle,() );//6FA749C0
-F7(STD,  D2gfx,	10055,10055,10055,10028,10000,10062,10014,10028,	void,		D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));
+F8(STD,  D2gfx,	10055,10055,10055,10028,10000,10062,10014,10028, F6300, void,		D2FillArea,(DWORD x1, DWORD y1, DWORD x2, DWORD y2, DWORD color, DWORD transTbl));
-F7(STD,  D2gfx,	10072,10072,10072,10047,10044,10024,10041,10042,	void,		D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );
+F8(STD,  D2gfx,	10072,10072,10072,10047,10044,10024,10041,10042, F6480, void,		D2PrintImage,(sDrawImageInfo* data, DWORD x, DWORD y, DWORD p4, DWORD p5, DWORD p6) );
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -532,36 +534,36 @@ F7(STD,  D2gfx,	10072,10072,10072,10047,10044,10024,10041,10042,	void,		D2PrintI
 //D2F(D2Win,10132,	DWORD,		D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
 //D2S(D2Win,10113,	void*,		D2CreateTextBox,(DWORD* data) );//ONLY 1.11b
-F7(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022,10051,	void,		D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) );
+F8(FAST, D2Win, 10046,10046,10046,10061,10075,10015,10022,10051, FCFF0, void,		D2PrintLineOnTextBox,(void* screen, char* s, DWORD color) );
-F7(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150,10076,	void,		D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) );
+F8(FAST, D2Win, 10117,10117,10117,10020,10064,10001,10150,10076, 102320, void,		D2PrintString,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD bfalse) );
-F7(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028,10150,	DWORD,		D2GetPixelLen,(LPWSTR s) );
+F8(FAST, D2Win, 10121,10121,10121,10034,10128,10132,10028,10150, 101820, DWORD,		D2GetPixelLen,(LPWSTR s) );
-F7(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184,10047,	DWORD,		D2SetFont,(DWORD fontID) );
+F8(FAST, D2Win, 10127,10127,10127,10141,10170,10010,10184,10047, 102EF0, DWORD,		D2SetFont,(DWORD fontID) );
-F7(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085,10137,	void,		D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) );
+F8(FAST, D2Win, 10129,10129,10129,10118,10039,10031,10085,10137, 102280, void,		D2PrintPopup,(LPWSTR s, DWORD x, DWORD y, DWORD color, DWORD center) );
-F7(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000,00000,	void,		D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260
+F8(FAST, D2Win, 10131,10131,10131,00000,00000,00000,00000,00000, 00000, void,		D2GetPixelRect,(LPWSTR s, DWORD* x, DWORD* y) );//6F8AB260
-F7(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000,00000,	DWORD,		D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
+F8(FAST, D2Win, 10132,10132,10132,00000,00000,00000,00000,00000, 00000, DWORD,		D2PrintTextPopup,(LPWSTR s, DWORD x, DWORD y, DWORD uk, DWORD type, DWORD color) );//6F8AB080
-F7(STD,  D2Win, 10017,10017,10017,10147,10113,10098,10098,10164,	void*,		D2CreateTextBox,(DWORD* data) );
+F8(STD,  D2Win, 10017,10017,10017,10147,10113,10098,10098,10164, F93C0, void*,		D2CreateTextBox,(DWORD* data) );
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //D2CMP : ????0000
 //D2S(D2CMP,10014,	DWORD,		D2CMP10014, (void* image) );//ONLY 1.11
-F7(STD,  D2CMP,	10032,10032,10032,10021,10014,10106,10065,10020,	DWORD,		D2CMP10014, (void* image) );
+F8(STD,  D2CMP,	10032,10032,10032,10021,10014,10106,10065,10020, 201A50, DWORD,		D2CMP10014, (void* image) );
 //ONLY UNTIL 1.10 :
-A7(FAST, D2Client,	 BA00, B9F0, C080,00000,00000,00000,00000,00000,	DWORD,		D2isLODGame, ());//6FAAC080
+A8(FAST, D2Client,	 BA00, B9F0, C080,00000,00000,00000,00000,00000, 00000, DWORD,		D2isLODGame, ());//6FAAC080
-A7(FAST, D2Client,	00000,00000, C090,00000,00000,00000,00000,00000,	BYTE,		D2GetDifficultyLevel, ());//6FAAC090  1.09 should be BA10 (b) BA00 (d)
+A8(FAST, D2Client,	00000,00000, C090,00000,00000,00000,00000,00000, 00000, BYTE,		D2GetDifficultyLevel, ());//6FAAC090  1.09 should be BA10 (b) BA00 (d)
-A7(STD,  D2Client,	B6670,B59F0,B7BC0,00000,00000,00000,00000,00000,	DWORD,		D2GetMouseX, ());//6FB57BC0
+A8(STD,  D2Client,	B6670,B59F0,B7BC0,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetMouseX, ());//6FB57BC0
-A7(STD,  D2Client,	B6680,B5A00,B7BD0,00000,00000,00000,00000,00000,	DWORD,		D2GetMouseY, ());//6FB57BD0
+A8(STD,  D2Client,	B6680,B5A00,B7BD0,00000,00000,00000,00000,00000, 00000, DWORD,		D2GetMouseY, ());//6FB57BD0
-A7(STD,  D2Client,	8DC40,8CFC0,883D0,00000,00000,00000,00000,00000,	Unit*,		D2GetClientPlayer, ());//6FB283D0
+A8(STD,  D2Client,	8DC40,8CFC0,883D0,00000,00000,00000,00000,00000, 00000, Unit*,		D2GetClientPlayer, ());//6FB283D0
-A7(FAST, D2Client,	 B920, B910, BF60,00000,00000,00000,00000,00000,	void,		D2CleanStatMouseUp, ());//6FAABF60
+A8(FAST, D2Client,	 B920, B910, BF60,00000,00000,00000,00000,00000, 00000, void,		D2CleanStatMouseUp, ());//6FAABF60
-A7(FAST, D2Client,	 D210, D200, D990,00000,00000,00000,00000,00000,	void,		D2SendToServer3, (BYTE type, WORD p));//6FAAD990
+A8(FAST, D2Client,	 D210, D200, D990,00000,00000,00000,00000,00000, 00000, void,		D2SendToServer3, (BYTE type, WORD p));//6FAAD990
 //A7(FAST, D2Client,	00000,00000, DA20,00000,00000,00000,00000,00000,	void,		D2SendToServer5, (BYTE type, DWORD p));//6FAADA20
 //A7(FAST, D2Client,	00000,00000, D9E0,00000,00000,00000,00000,00000,	void,		D2SendToServer7, (BYTE type, WORD p1, WORD p2, WORD p3));//6FAAD9E0
 //A7(FAST, D2Client,	00000,00000, DA40,00000,00000,00000,00000,00000,	void,		D2SendToServer9, (BYTE type, DWORD p1, DWORD p2));//6FAADA40
 //A7(FAST, D2Client,	00000,00000, DA70,00000,00000,00000,00000,00000,	void,		D2SendToServer13,(BYTE type, DWORD p1, DWORD p2, DWORD p3));//6FAADA70
-A7(FAST, D2Game,	7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000,	NetClient*,	D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
+A8(FAST, D2Game,	7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000, 00000, NetClient*,	D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////// VARIABLES ////////
@ -583,23 +585,23 @@ A7(FAST, D2Game,	7C2C0,7C7B0,8C2E0,00000,00000,00000,00000,00000,	NetClient*,	D2
 //E2C(D2Client,11C1E0,Unit*,		ptClientChar);//1.11b
 //C7(D2Common,000000,000000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C,	DataTables*,SgptDataTables); //03836A20 - 037A0000 //01EE6A20
-C7(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C, F7038,	DWORD,		ResolutionY);//0x258 = 600
+C8(D2Client, D50E8, D40E0, D40F0, F5C60, F4FC8, DC6E4, DBC4C, F7038, 311470, DWORD,		ResolutionY);//0x258 = 600
-C7(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48, F7034,	DWORD,		ResolutionX);//0x320 = 800
+C8(D2Client, D50EC, D40E4, D40F4, F5C5C, F4FC4, DC6E0, DBC48, F7034, 31146C, DWORD,		ResolutionX);//0x320 = 800
-C7(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4,11D358,	DWORD,		NegWindowStartY);//0xFFFFFFC4 = -60
+C8(D2Client,125AD8,124958,11A74C,11BD28,11BEFC,11BD2C,11B9A4,11D358, 3A285C, DWORD,		NegWindowStartY);//0xFFFFFFC4 = -60
-C7(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0,11D354,	DWORD,		WindowStartX);//0x50 = 80
+C8(D2Client,125AD4,124954,11A748,11BD24,11BEF8,11BD28,11B9A0,11D354, 3A2858, DWORD,		WindowStartX);//0x50 = 80
 //C7(D2Launch, 55818, 56088, 2CD5C,000000, 2CD5C,000000,000000,00000,	DWORD,		GameTypeMode);//0x50 = 80 //6FA3CD5C-6FA10000
-C7(D2Game,   F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8,1105E0,	NetClient*,	ClientTable);
+C8(D2Game,   F2A80, F2918,113FB8,111718,1115E0,1105E0,1107B8,1105E0, 4842A8, NetClient*,	ClientTable);
 //C7(D2Client,000000,000000,000000,000000,104225,000000,000000,00000,	DWORD,		CurrentNPCNum);
-C7(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854,1087B4,	DWORD,		IsLodGame);
+C8(D2Client,000000,000000,000000, FB3F4,11A2F4,10330C,119854,1087B4, 3A04F4, DWORD,		IsLodGame);
-C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,000000,	BYTE,		DifficultyLevel);
+C8(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,000000, 000000, BYTE,		DifficultyLevel);
 //C7(D2Client,000000,000000,10795C,11BFB8,11C2A8,11BFF4,000000,11D1D8,	BYTE,		DifficultyLevel);
-C7(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824,11C94C,	DWORD,		MouseY);//0x258 = 600
+C8(D2Client,000000,000000,000000,10A40C,11B414,101634,11B824,11C94C, 3A6AAC, DWORD,		MouseY);//0x258 = 600
-C7(D2Client,000000,000000,000000,10A410,11B418,101638,11B828,11C950,	DWORD,		MouseX);//0x320 = 800
+C8(D2Client,000000,000000,000000,10A410,11B418,101638,11B828,11C950, 3A6AB0, DWORD,		MouseX);//0x320 = 800
-C7(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC,11D050,	Unit*,		ptClientChar);
+C8(D2Client,000000,000000,000000,11C4F0,11C1E0,11C3D0,11BBFC,11D050, 3A5E74, Unit*,		ptClientChar);
-C7(D2Client, DB918, DA828,000000,000000,000000,000000,000000,000000,	DWORD,		NbStatDesc);
+C8(D2Client, DB918, DA828,000000,000000,000000,000000,000000,000000, 000000, DWORD,		NbStatDesc);
-C7(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000,000000,	DWORD,		StatDescTable);
+C8(D2Client, DAF98, D9EA8,000000,000000,000000,000000,000000,000000, 000000, DWORD,		StatDescTable);
 /* NEXT NOT TESTED IN 1.10 (1.09b fct)
 D2_STD(D2Common10066,	void,		D2RemoveFromRoom, (DrlgRoom1* hRoom, DWORD untitype, DWORD unitID),				0x6FD7CFD0);
--- a/PlugY/BigStash.cpp
+++ b/PlugY/BigStash.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Use a more big stash
@ -77,8 +78,13 @@ void Install_BigStash()
 	log_msg("Patch D2Common & D2Client for make 10x10 squares in the stash. (BigStash)\n");
 	// modification of stash grid
-	mem_seek R7(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5, 6CC25);
+	mem_seek R8(D2Common, C9F3, CA03, 14ED3, 5FCB5, 2A505, 1BDB5, 82CA5, 6CC25, 25C0F8);
-	MEMC_REF4( D2CompileTxtFile, caller_modifStashGrid);
+  if (version_D2Common == V114d) {
    MEMT_REF4(0xFFFB61F4, caller_modifStashGrid);
  }
  else {
    MEMC_REF4(D2CompileTxtFile, caller_modifStashGrid);
  }
 	//01B64ED2  |. E8 99AEFFFF    CALL D2Common.#10578
 	//6FDAFCB4  |. E8 A7C3FCFF    CALL D2Common.#10653
 	//6FD7A504  |. E8 5743FEFF    CALL D2Common.#10496                     ; \#10496
@ -87,16 +93,16 @@ void Install_BigStash()
 	//6FDBCC24  |. E8 B7FEF9FF    CALL D2Common.#10037                     ; \#10037
 	// modification of stash background
-	mem_seek R7(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C, 943FC);
+    mem_seek R8(D2Client, 45B1C, 45B1C, 4C61C, A643C, 749BC, A9D7C, 8CC1C, 943FC, 89EB5);
-	memt_byte( 0x68, 0xE8 );	// CALL caller_changeTradeStash
+    memt_byte(0x68, 0xE8);	// CALL caller_changeTradeStash
-	MEMT_REF4( 0x00000104, caller_changeTradeStash);
+    MEMT_REF4(0x00000104, caller_changeTradeStash);
    //6FAEC61C  |. 68 04010000    PUSH 104
    //6FB5643C  |. 68 04010000    PUSH 104
    //6FB249BC  |. 68 04010000    PUSH 104
    //6FB59D7C  |. 68 04010000    PUSH 104
    //6FB3CC1C  |. 68 04010000    PUSH 104
    //6FB443FC  |. 68 04010000    PUSH 104
 	log_msg("\n");
 	isInstalled = true;
--- a/PlugY/Commands.cpp
+++ b/PlugY/Commands.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Updating server.
@ -569,9 +570,9 @@ void Install_Commands()
 	active_savegame = version_D2Common >= V111;
 	// Run custom commmand
-	mem_seek R7(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6, B1FD6);
+	mem_seek R8(D2Client, 2C120, 2C110, 32BDD, C1EE6, 91C16, 86926, 70AE6, B1FD6, 7C548);
 	memt_byte( 0x83, 0xE8 );	// CALL 
-	MEMT_REF4( 0xC08508C4 , version_D2Client == V113d ? caller_Commands_113d : version_D2Client >= V111 ? caller_Commands_111 : caller_Commands);
+	MEMT_REF4( 0xC08508C4 , version_D2Client >= V113d ? caller_Commands_113d : version_D2Client >= V111 ? caller_Commands_111 : caller_Commands);
 	//6FB71EE6   . 83C4 08        ADD ESP,8
 	//6FB71EE7   . 85C0           TEST EAX,EAX
 	//6FB41C16  |. 83C4 08        ADD ESP,8
--- a/PlugY/D2functions.cpp
+++ b/PlugY/D2functions.cpp
@ -1,6 +1,7 @@
 /*================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
    This file implements some common and useful
    function related to some Diablo II mechanisms.
@ -16,9 +17,9 @@ s_shifting shifting;
 #define E2S(F, A, R, N, P)	T##N N;
 #define E2F(F, A, R, N, P)	T##N N;
 #define E2C(F, A, T, N)		T* pt##N;
-#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N;
+#define F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) T##N N;
-#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) T##N N;
+#define A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) T##N N;
-#define C7(Z, A,B,C,D,E,F,G,H, T, N)       T* pt##N;
+#define C8(Z, A,B,C,D,E,F,G,H,I, T, N)       T* pt##N;
 #include "../Commons/D2Funcs.h"
 DataTables* SgptDataTables;
@ -34,9 +35,9 @@ DataTables* SgptDataTables;
 ////E2F(D2Client,0,	void,		D2SendToServer13,(BYTE type, DWORD p1, DWORD p2, DWORD p3));//6FAADA70
 //E2F(D2Game,0,	NetClient*,	D2GetClient, (Unit* ptUnit, char* lpszErrFile, DWORD ErrLine));//6FCBC2E0
 //E2F(D2Client,0,	void,		D2CleanStatMouseUp, ());//6FAABF60
-#undef F7
+#undef F8
-#undef A7
+#undef A8
-#undef C7
+#undef C8
 #undef D2S
 #undef D2F
 #undef E2S
@ -80,6 +81,8 @@ TD2GetItemStatCostBIN		 V2GetItemStatCostBIN;
 TD2SendPacket				 V2SendPacket;
 TD2LoadInventory			 V2LoadInventory;
 TD2SaveGame					 V2SaveGame;
 TD2LinkPortal					 V2LinkPortal;
 TD2Game235C0					 V2Game235C0;
 //DWORD* ptNbStatDesc
 //DWORD* ptStatDescTable;
@ -282,6 +285,45 @@ continue_compileTxtFile:
 	JMP ECX
 }}
 __declspec(naked) void* STDCALL compileTxtFile_114(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength) {
    _asm {
        SUB ESP, 0x20C
        //	MOV EAX,DWORD PTR DS:[6FDF1464]
        PUSH EBX
        PUSH EBP
        PUSH ESI
        PUSH EDI
        MOV DWORD PTR SS : [ESP + 0x10], 0
        MOV EBX, DWORD PTR SS : [ESP + 0x224]
        PUSH EBX
        LEA EAX, DWORD PTR SS : [ESP + 0x1A]
        PUSH EAX
        CALL DWORD PTR SS : [wsprintf]
        MOV EDX, DWORD PTR SS : [ESP + 0x228]
        ADD ESP, 8
        LEA EDX, DWORD PTR SS : [ESP + 0xE]
        PUSH EDX
        PUSH EAX
        LEA EDX, DWORD PTR SS : [ESP + 0x20]
        CALL D2ReadFile
        TEST EAX, EAX
        JNZ continue_compileTxtFile
        PUSH __LINE__
        CALL D2GetInstructionPointer
        PUSH EAX
        PUSH S_errorReadTxtFile
        CALL D2FogAssert
        ADD ESP, 0xC
        PUSH - 1
        CALL exit
        continue_compileTxtFile :
        MOV ECX, D2CompileTxtFile
        ADD ECX, 0x1EC
        JMP ECX
    }
 }
 __declspec(naked) void* STDCALL compileTxtFile_111(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength)
 {_asm{
 	SUB ESP,0x20C
@ -330,6 +372,14 @@ Unit* STDCALL	D2GetClientPlayer_111(){return ptClientChar;}
 DWORD *StatMouse1, *StatMouse2, *StatMouse3, *StatMouse4;
 void FASTCALL D2CleanStatMouseUp_111(){*StatMouse1=*StatMouse2=*StatMouse3=*StatMouse4=0;}
 FCT_ASM ( D2CleanStatMouseUp_114 )
    MOV DWORD PTR DS : [StatMouse1], 0
    MOV DWORD PTR DS : [StatMouse2], 0
    MOV DWORD PTR DS : [StatMouse3], 0
    MOV DWORD PTR DS : [StatMouse4], 0
    RETN
 }}
 Unit* STDCALL	D2GetRealItem_111(Unit* ptItem){return ptItem;}
 /* 1.11 : sizememory : 0x104 (LoadBuySell)
 6FADA7F0  |. A1 48BDBC6F    MOV EAX,DWORD PTR DS:[6FBCBD48]
@ -372,6 +422,14 @@ FCT_ASM ( D2LoadImage_111 )
 	RETN
 }}
 FCT_ASM( D2LoadImage_114 )
    PUSH EDX
    MOV EAX, ECX
    CALL V2LoadImage
    POP EDX
    RETN
 }}
 const char* D2FreeImage_FILE = __FILE__;
 FCT_ASM ( D2FreeImage_111 )
 	PUSH ESI
@ -410,6 +468,20 @@ FCT_ASM ( D2GetClient_111 )
 	RETN 4
 }}
 FCT_ASM( D2SetSkillBaseLevelOnClient_114 )
    PUSH EBX
    PUSH EBX
    PUSH ESI
    PUSH DWORD PTR SS : [ESP + 0x14]
    PUSH DWORD PTR SS : [ESP + 0x14]
    MOV EBX, DWORD PTR SS : [ESP + 0x14]
    MOV EAX, ECX
    MOV ESI, EDX
    CALL V2SetSkillBaseLevelOnClient
    POP ESI
    POP EBX
    RETN 0xC
 }}
 FCT_ASM ( D2SetSkillBaseLevelOnClient_111 )
 	PUSH EBX
@ -435,6 +507,24 @@ FCT_ASM ( D2GetItemStatCostBIN_111 )
 	JMP V2GetItemStatCostBIN
 }}
 FCT_ASM( D2SendToServer3_114 )
    PUSH EDI
    PUSH ESI
    PUSH EBX
    PUSH ECX
    MOV BYTE PTR SS : [ESP], CL
    MOV WORD PTR SS : [ESP + 1], DX
    MOV EDI, 3
    LEA ECX, DWORD PTR SS : [ESP]
    PUSH ECX
    CALL D2SendToServerXX
    POP ECX
    POP EBX
    POP ESI
    POP EDI
    RETN
 }}
 FCT_ASM ( D2SendToServer3_111 )
 	PUSH EBX
 	PUSH ECX
@ -449,6 +539,23 @@ FCT_ASM ( D2SendToServer3_111 )
 	RETN
 }}
 FCT_ASM( D2PrintStat_114 )
    PUSH ESI
    PUSH EBX
    PUSH ECX
    MOV ESI, DWORD PTR SS : [ESP + 0x1C]
    PUSH DWORD PTR SS : [ESP + 0x18]
    PUSH DWORD PTR SS : [ESP + 0x18]
    PUSH DWORD PTR SS : [ESP + 0x18]
    PUSH EDX
    PUSH ECX
    CALL V2PrintStat
    POP ECX
    POP EBX
    POP ESI
    RETN 0x10
 }}
 FCT_ASM ( D2PrintStat_111 )
 	PUSH ESI
 	MOV ESI,DWORD PTR SS:[ESP+0x14]
@ -462,6 +569,16 @@ FCT_ASM ( D2PrintStat_111 )
 	RETN 0x10
 }}
 FCT_ASM(D2SendPacket_114)
    PUSH EDI
    PUSH DWORD PTR SS : [ESP + 8]
 	PUSH EDX
 	MOV EDI, ECX
 	CALL V2SendPacket
    POP EDI
    RETN 0x4
 }}
 FCT_ASM ( D2SendPacket_111 )
 	POP EAX
 	PUSH EDX
@ -485,6 +602,13 @@ FCT_ASM ( D2CompileCubeInput_111 )
 	RETN 8
 }}
 FCT_ASM( D2CompileCubeInput_114 )
    PUSH ECX
    MOV EAX, EDX
    CALL V2CompileCubeInput
    RETN 8
 }}
 FCT_ASM ( D2CompileCubeOutput_111 )
 	PUSH EBX
 	MOV EBX,ECX
@ -531,6 +655,22 @@ FCT_ASM ( D2SpawnMonster_111b )
 	RETN 0x18
 }}
 FCT_ASM( D2SpawnMonster_114 )
    PUSH ECX
    MOV EBX, DWORD PTR SS : [ESP + 0x18]
    MOV ECX, DWORD PTR SS : [ESP + 0x14]
    MOV DWORD PTR SS : [ESP + 0x18], ECX
    MOV ECX, DWORD PTR SS : [ESP + 0x10]
    MOV DWORD PTR SS : [ESP + 0x14], ECX
    MOV ECX, DWORD PTR SS : [ESP + 0xC]
    MOV DWORD PTR SS : [ESP + 0x10], ECX
    MOV ECX, DWORD PTR SS : [ESP + 0x8]
    MOV DWORD PTR SS : [ESP + 0xC], ECX
    MOV DWORD PTR SS : [ESP + 0x8], EDX
    POP ECX
    JMP V2SpawnMonster
 }}
 FCT_ASM ( D2VerifIfNotCarry1_111 )
 	PUSH EBX
 	PUSH ECX
@ -578,6 +718,10 @@ FCT_ASM ( D2SendToServer_1XX )
 	RETN 0xC
 }}
 FCT_ASM( D2GetGameByClientID_114 )
    MOV ECX, DWORD PTR SS : [ESP + 0x4]
    JMP V2GetGameByClientID
 }}
 FCT_ASM ( D2GetGameByClientID_1XX )
 	POP EAX
@ -593,6 +737,36 @@ FCT_ASM ( D2SaveGame_1XX )
 	JMP V2SaveGame
 }}
 FCT_ASM( D2SetColorPopup_114 )
    PUSH EDI
    PUSH EDX
    MOV EDI, ECX
    CALL V2SetColorPopup
    POP EDI
    RETN
 }}
 FCT_ASM( D2LinkPortal_114 )
    PUSH ECX
    MOV ECX, DWORD PTR SS : [ESP + 0x8]
    PUSH DWORD PTR SS : [ESP + 0x14]
    PUSH DWORD PTR SS : [ESP + 0x14]
    PUSH DWORD PTR SS : [ESP + 0x14]
    CALL V2LinkPortal
    POP ECX
    RETN 0x10
 }}
 FCT_ASM( D2Game235C0_114 )
    PUSH ECX
    PUSH EDX
    MOV ECX, DWORD PTR SS : [ESP + 0xC]
    MOV EDX, DWORD PTR SS : [ESP + 0x10]
    POP EDX
    POP ECX
    RETN 0x8
 }}
 #define SETFCTADDR(F, I, N) setFctAddr((DWORD*)&N, (HMODULE)offset_##F, (LPCSTR)I)
 void setFctAddr(DWORD* addr, HMODULE module, LPCSTR index)
 {
@ -616,21 +790,24 @@ void initD2functions()
 	#define E2S(F, A, R, N, P)	N = (T##N)(offset_##F + 0x##A);
 	#define E2F(F, A, R, N, P)	N = (T##N)(offset_##F + 0x##A);
 	#define E2C(F, A, T, N)		pt##N = (T*)(offset_##F + 0x##A);
-	#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) setFctAddr((DWORD*)&N, (HMODULE)offset_##Z, (LPCSTR)(version_##Z == V113d? H : (version_##Z == V113c? G : (version_##Z == V112? F : (version_##Z == V111b? E : (version_##Z == V111? D : (version_##Z == V110? C : (version_##Z == V109d? B : A))))))));
+    #define F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) if (version_##Z == V114d) { E2S(Z, I, 0, N, 0) } else { setFctAddr((DWORD*)&N, (HMODULE)offset_##Z, (LPCSTR)(version_##Z == V113d? H : (version_##Z == V113c? G : (version_##Z == V112? F : (version_##Z == V111b? E : (version_##Z == V111? D : (version_##Z == V110? C : (version_##Z == V109d? B : A)))))))); }
-	#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) N = (T##N)R7(Z,A,B,C,D,E,F,G,H);
+	#define A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) N = (T##N)R8(Z,A,B,C,D,E,F,G,H,I);
-	#define C7(Z, A,B,C,D,E,F,G,H, T, N)       pt##N = (T*)R7(Z,A,B,C,D,E,F,G,H);
+	#define C8(Z, A,B,C,D,E,F,G,H,I, T, N)       pt##N = (T*)R8(Z,A,B,C,D,E,F,G,H,I);
 	#include "../Commons/D2Funcs.h"
-	SgptDataTables = *(DataTables**) R7(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, A33F0);
+    //D2FogMemAlloc = (TD2FogMemAlloc)(offset_D2Game + 0xB380);
    //E2S(D2Game, B380, 0, D2FogMemAlloc, 0)
    //return;
 	SgptDataTables = *(DataTables**) R8(D2Common, 0000, 0000, 96A20, 9B74C, 9EE8C, 9B500, 99E1C, A33F0, 344304);
 	if (version_D2Common < V110)
 	{
 		D2S(D2Common,10581,	CharStatsBIN*,		D2Common10581, (DWORD charID));//ONLY in 1.09
 		D2S(D2Common,10598,	ItemStatCostBIN*,	D2Common10598, (DWORD itemStatCostID));//ONLY in 1.09
 		D2S(D2Common,10673,	ItemTypesBIN*,		D2Common10673, (DWORD itemTypesID));//ONLY in 1.09
 	}
-	#undef F7
+	#undef F8
-	#undef A7
+	#undef A8
-	#undef C7
+	#undef C8
 	#undef D2S
 	#undef D2F
 	#undef E2S
@ -642,7 +819,7 @@ void initD2functions()
 	//setImage = version_D2Common >= V111 ? setImage_111 : setImage_1XX;
 	//setFrame = version_D2Common >= V111 ? setFrame_111 : setFrame_1XX;
 	getDescStrPos = version_D2Common >= V110  ? getDescStrPos_10 : getDescStrPos_9;
-	compileTxtFile = version_D2Common >= V111 ? compileTxtFile_111 : version_D2Common == V110 ? compileTxtFile_10 : compileTxtFile_9;
+	compileTxtFile = version_D2Common == V114d ? compileTxtFile_114 : version_D2Common >= V111 ? compileTxtFile_111 : version_D2Common == V110 ? compileTxtFile_10 : compileTxtFile_9;
 	//////////////// SELECT RIGHT ADDR FUNCTION ////////////////
@ -881,11 +1058,37 @@ void initD2functions()
 	V2TestPositionInRoom = D2TestPositionInRoom;
 	V2GetItemTypesBIN = D2GetItemTypesBIN;
 	V2SaveGame = D2SaveGame;
 	V2LinkPortal = D2LinkPortal;
 	V2Game235C0 = D2Game235C0;
 	//V2OpenNPCMenu = D2OpenNPCMenu;
 	//////////////// REDIRECT ON CUSTOM FUNCTIONS ////////////////
-	if ( version_D2Client >= V111 )
+    if (version_D2Client == V114d) {
-	{
+        D2GetClientPlayer = D2GetClientPlayer_111;
        D2GetClient = (TD2GetClient)D2GetClient_111;
        D2LoadImage = (TD2LoadImage)D2LoadImage_114;
        D2FreeImage = (TD2FreeImage)D2FreeImage_111;
        D2isLODGame = D2isLODGame_111;
        D2GetMouseX = D2GetMouseX_111;
        D2GetMouseY = D2GetMouseY_111;
        D2SendToServer3 = (TD2SendToServer3)D2SendToServer3_114;
        D2SetSkillBaseLevelOnClient = (TD2SetSkillBaseLevelOnClient)D2SetSkillBaseLevelOnClient_114;
        D2SendPacket = (TD2SendPacket)D2SendPacket_114;
        D2GetGameByClientID = (TD2GetGameByClientID)D2GetGameByClientID_1XX;
        D2SpawnMonster = (TD2SpawnMonster)D2SpawnMonster_114;
        D2CompileCubeInput = (TD2CompileCubeInput)D2CompileCubeInput_114;
        D2CleanStatMouseUp = (TD2CleanStatMouseUp)D2CleanStatMouseUp_114;
        D2LinkPortal = (TD2LinkPortal)D2LinkPortal_114;
        D2Game235C0 = (TD2Game235C0)D2Game235C0_114;
        D2PrintStat = (TD2PrintStat)D2PrintStat_114;
        D2SaveGame = (TD2SaveGame)D2SaveGame_1XX;
        D2VerifIfNotCarry1 = (TD2VerifIfNotCarry1)D2VerifIfNotCarry1_111;
        StatMouse1 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224, A0650);
        StatMouse2 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228, A0654);
        StatMouse3 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240, A0658);
        StatMouse4 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244, A065C);
    } else if ( version_D2Client >= V111 ) {
 		D2SendMsgToAll = (TD2SendMsgToAll) D2SendMsgToAll_111;
 		D2SetColorPopup = (TD2SetColorPopup) D2SetColorPopup_111;
 		D2LoadImage = (TD2LoadImage) D2LoadImage_111;
@ -915,10 +1118,10 @@ void initD2functions()
 		D2GetClientPlayer = D2GetClientPlayer_111;
 		D2GetRealItem = D2GetRealItem_111;
 		D2CleanStatMouseUp = D2CleanStatMouseUp_111;
-		StatMouse1 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224);
+		StatMouse1 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C004, 11C2F4, 11C040, 11C3DC, 11D224, A0650);
-		StatMouse2 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228);
+		StatMouse2 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C008, 11C2F8, 11C044, 11C3E0, 11D228, A0654);
-		StatMouse3 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240);
+		StatMouse3 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C020, 11C310, 11C05C, 11C3F8, 11D240, A0658);
-		StatMouse4 = (DWORD*)R7(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244);
+		StatMouse4 = (DWORD*)R8(D2Client, 0000, 0000, 0000, 11C024, 11C314, 11C060, 11C3FC, 11D244, A065C);
 	} else {
 		D2SendToServer = (TD2SendToServer) D2SendToServer_1XX;
 		D2GetGameByClientID = (TD2GetGameByClientID) D2GetGameByClientID_1XX;
@ -948,14 +1151,14 @@ void initD2functions()
 	//////////////// STRUCTURE MANAGEMENT ////////////////
 //	shifting.ptPYPlayerData = V7(D2Common,118,118,F4,F4,F4,F4,F4);
-	shifting.ptPYPlayerData = *(DWORD*)((DWORD)D2InitPlayerData + V7(D2Common,5D,5D,5D,49,49,49,49,49));
+	shifting.ptPYPlayerData = *(DWORD*)((DWORD)D2InitPlayerData + V8(D2Common,5D,5D,5D,49,49,49,49,49,48));
-	shifting.ptSpecificData = V7(D2Common,70,70,14,14,14,14,14,14);
+	shifting.ptSpecificData = V8(D2Common,70,70,14,14,14,14,14,14,14);
-	shifting.ptGame = V7(D2Common,A4,A4,80,80,80,80,80,80);
+	shifting.ptGame = V8(D2Common,A4,A4,80,80,80,80,80,80,80);
-	shifting.ptClientGame = V7(D2Common,170,194,1A8,1A8,1A8,1A8,1A8,1A8);
+	shifting.ptClientGame = V8(D2Common,170,194,1A8,1A8,1A8,1A8,1A8,1A8,1A8);
-	shifting.ptInventory = V7(D2Common,84,84,60,60,60,60,60,60);
+	shifting.ptInventory = V8(D2Common,84,84,60,60,60,60,60,60,60);
-	shifting.ptSkills = V7(D2Common,CC,CC,A8,A8,A8,A8,A8,A8);
+	shifting.ptSkills = V8(D2Common,CC,CC,A8,A8,A8,A8,A8,A8,A8);
-	shifting.ptImage = V7(D2Common,04,04,04,08,08,3C,34,34);
+	shifting.ptImage = V8(D2Common,04,04,04,08,08,3C,34,34,34);
-	shifting.ptFrame = V7(D2Common,08,08,08,44,44,40,00,00);
+	shifting.ptFrame = V8(D2Common,08,08,08,44,44,40,00,00,00);
 }
 /*================================= END OF FILE =================================*/
--- a/PlugY/D2wrapper.cpp
+++ b/PlugY/D2wrapper.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
    @file D2wrapper.cpp
    @brief Main Diablo II extra DLL handler.
@ -29,6 +30,7 @@
 #include "customLibraries.h"
 #include "common.h"
 #include "interface_Stash.h"
 int version_Game = UNKNOW;
 //int version_binkw32 = UNKNOW;
@ -173,17 +175,21 @@ void hookLibraries()
 {
 	log_msg("***** Unprotect Libraries *****\n");
    if (version_Game == V114d) {
        hookLibrary(S_Game, offset_Game);
    } else {
        hookLibrary(S_D2Client, offset_D2Client);
-//	hookLibrary(S_D2CMP,	offset_D2CMP);
+        //	hookLibrary(S_D2CMP,	offset_D2CMP);
        hookLibrary(S_D2Common, offset_D2Common);
        hookLibrary(S_D2Game, offset_D2Game);
        hookLibrary(S_D2gfx, offset_D2gfx);
        hookLibrary(S_D2Lang, offset_D2Lang);
        hookLibrary(S_D2Launch, offset_D2Launch);
-//	hookLibrary(S_D2Net,	offset_D2Net);
+        //	hookLibrary(S_D2Net,	offset_D2Net);
-//	hookLibrary(S_D2Win,	offset_D2Win);
+        //	hookLibrary(S_D2Win,	offset_D2Win);
        hookLibrary(S_Fog, offset_Fog);
        hookLibrary(S_Storm, offset_Storm);
    }
 	log_msg("\n\n");
 }
@ -192,17 +198,21 @@ void unhookLibraries()
 {
 	log_msg("***** Reprotect Libraries *****\n");
    if (version_Game == V114d) {
        unhookLibrary(S_Game, offset_Game);
    } else {
        unhookLibrary(S_D2Client, offset_D2Client);
-//	unhookLibrary(S_D2CMP,		offset_D2CMP);
+        //	unhookLibrary(S_D2CMP,		offset_D2CMP);
        unhookLibrary(S_D2Common, offset_D2Common);
        unhookLibrary(S_D2Game, offset_D2Game);
        unhookLibrary(S_D2gfx, offset_D2gfx);
        unhookLibrary(S_D2Lang, offset_D2Lang);
        unhookLibrary(S_D2Launch, offset_D2Launch);
-//	unhookLibrary(S_D2Net,		offset_D2Net);
+        //	unhookLibrary(S_D2Net,		offset_D2Net);
-//	unhookLibrary(S_D2Win,		offset_D2Win);
+        //	unhookLibrary(S_D2Win,		offset_D2Win);
        unhookLibrary(S_Fog, offset_Fog);
        unhookLibrary(S_Storm, offset_Storm);
    }
 	log_msg("\n\n");
 }
@ -272,8 +282,8 @@ void loadCustomLibraries()
 			curString=strtok(NULL,"|");
 		}
 	}
-	if(dllFilenames)
+  if (dllFilenames)
-		D2FogMemDeAlloc(dllFilenames,__FILE__,__LINE__,0);
+    D2FogMemDeAlloc(dllFilenames, __FILE__, __LINE__, 0);
 	log_msg("\n\n");
 }
@ -395,7 +405,7 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
 	initD2modules();
-	if (version_Game < V109 || version_Game > V113d)
+	if (version_Game < V109 || version_Game > V114d)
 	{
 		log_box("PlugY isn't compatible with this version : %s", GetVersionString(version_Game));
 		Release();
@ -490,6 +500,9 @@ extern "C" __declspec(dllexport) void* __stdcall Init(LPSTR IniName)
 	if (active_EnabledCowPortalWhenCowKingWasKill)
 		Install_EnabledCowPortalWhenCowKingWasKill();
    if (active_DoNotCloseNihlathakPortal)
      Install_DoNotCloseNihlathakPortal();
 	log_msg("\nDLL patched sucessfully.\n\n\n");
 	unhookLibraries();
--- a/PlugY/ExtraOptions.cpp
+++ b/PlugY/ExtraOptions.cpp
@ -1,12 +1,14 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	More little options.
 =================================================================*/
 #include "common.h"
 #include "skillsPoints.h"
 #include <stdio.h>
 int active_DisplayItemLevel = false;
@ -19,6 +21,7 @@ int active_EnabledTXTFilesWithMSExcel = false;
 int active_DisplayBaseStatsValue = false;
 int active_LadderRunewords = false;
 int active_EnabledCowPortalWhenCowKingWasKill = false;
 int active_DoNotCloseNihlathakPortal = false;
 /****************************************************************************************************/
@ -31,6 +34,22 @@ void STDCALL displayItemlevel(LPWSTR popup, Unit* ptItem)
 	wcscat(popup,text);
 }
 FCT_ASM( caller_displayItemlevel_114 )
    PUSH ECX
    PUSH EAX
    PUSH EDI
    PUSH ECX
    LEA EAX, DWORD PTR SS : [EBP - 0x2434]
    PUSH EAX
    CALL displayItemlevel
    POP EDI
    POP EAX
    POP ECX
    POP EDX
    PUSH 0x100
    JMP EDX
 }}
 FCT_ASM ( caller_displayItemlevel_113 )
 	PUSH ECX
 	PUSH EAX
@ -59,6 +78,22 @@ FCT_ASM ( caller_displayItemlevel_111 )
 	JMP EAX
 }}
 FCT_ASM( caller_displayItemlevelSet_114 )
    PUSH ECX
    PUSH EAX
    PUSH EDI
    PUSH ECX
    LEA EAX, DWORD PTR SS : [EBP - 0x2138]
    PUSH EAX
    CALL displayItemlevel
    POP EDI
    POP EAX
    POP ECX
    POP EDX
    PUSH 0x100
    JMP EDX
 }}
 FCT_ASM ( caller_displayItemlevelSet_111 )
 	PUSH ECX
 	PUSH EDX
@ -136,12 +171,12 @@ void Install_DisplayItemLevel()
 	static int isInstalled = false;
 	if (isInstalled) return;
-	log_msg("Patch D2Client for display item popup. (DisplayPopup)\n");
+	log_msg("Patch D2Client to display item popup. (DisplayPopup)\n");
 	// print the text in the final buffer
-	mem_seek R7(D2Client,	3D47C,	3D47C,	438A1, ADD0A, 789DA, AE0AA, 941C0, 98590);
+	mem_seek R8(D2Client,	3D47C,	3D47C,	438A1, ADD0A, 789DA, AE0AA, 941C0, 98590, 8E983);
 	memt_byte( 0x68 , 0xE8);
-	MEMT_REF4( 0x100, version_D2Client >= V113c ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9);
+	MEMT_REF4( 0x100, version_D2Client == V114d ? caller_displayItemlevel_114 : version_D2Client >= V113c ? caller_displayItemlevel_113 : version_D2Client >= V111 ? caller_displayItemlevel_111 : version_D2Client == V110 ? caller_displayItemlevel : caller_displayItemlevel_9);
 	//6FAE38A1   . 68 00010000        PUSH 100
 	//6FB5DD0A  |. 68 00010000        PUSH 100
 	//6FB289DA  |. 68 00010000	      PUSH 100
@ -150,9 +185,9 @@ void Install_DisplayItemLevel()
 	//6FB48590  |. 68 00010000    PUSH 100
 	// print the text in the final buffer (for set items)
-	mem_seek R7(D2Client,	3C452,	3C452,	427BE, AC773, 77773, ACEB3, 92FE3, 973B3);
+	mem_seek R8(D2Client,	3C452,	3C452,	427BE, AC773, 77773, ACEB3, 92FE3, 973B3, 8D774);
 	memt_byte( 0x68 , 0xE8);
-	MEMT_REF4( 0x100, version_D2Client >= V111  ? caller_displayItemlevelSet_111 : version_D2Client == V110 ? caller_displayItemlevelSet : caller_displayItemlevelSet_9);
+	MEMT_REF4( 0x100, version_D2Client == V114d ? caller_displayItemlevelSet_114 : version_D2Client >= V111 ? caller_displayItemlevelSet_111 : version_D2Client == V110 ? caller_displayItemlevelSet : caller_displayItemlevelSet_9);
 	//6FAE27BE   . 68 00010000        PUSH 100
 	//6FB5C773  |. 68 00010000        PUSH 100
 	//6FB27773  |. 68 00010000        PUSH 100
@ -211,13 +246,18 @@ void Install_SendPlayersCommand()
 	log_msg("Patch D2Client for init default nb /players. (SendPlayersCommand)\n");
-	infoEnabledSendPlayersCommand = (DWORD*)R7(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394, 11D1DC);
+	infoEnabledSendPlayersCommand = (DWORD*)R8(D2Client, 111D60, 110BC0, 107960, 11BFBC, 11C2AC, 11BFF8, 11C394, 11D1DC, 3A0610);
    if ( version_D2Client >= V110 )
-		msgNBPlayersString = (char*)R7(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00, D470C);
+		msgNBPlayersString = (char*)R8(D2Client, 0000, 0000, D8448, D06A8, D4748, D4680, D4E00, D470C, 2D7374);
 	// Set nb Player to default
-	mem_seek R7(D2Client,	8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2, 1D3F2);//6FB1C7B7-6FAA0000
+	mem_seek R8(D2Client,	8723B, 865BB, 81B8B, A3602, 66A02, 90162, C39F2, 1D3F2, 56EF9);//6FB1C7B7-6FAA0000
-	MEMJ_REF4( D2GetResolution , caller_SendPlayersCommand);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x0009E263, caller_SendPlayersCommand);
    }
    else {
        MEMJ_REF4(D2GetResolution, caller_SendPlayersCommand);
    }
 	//6FB2723A  |. E8 7D8E0300    CALL <JMP.&D2gfx.#10005>
 	//6FB265BA  |. E8 7D8E0300    CALL <JMP.&D2gfx.#10005>
 	//6FB21B8A   . E8 4F9C0400    CALL <JMP.&D2gfx.#10005>
@ -243,7 +283,7 @@ void Install_AlwaysRegenMapInSP()
 	log_msg("Patch D2Game for always regenerate maps in Single player. (AlwaysRegenMapInSP)\n");
 	// Always regenerate maps in Single player
-	mem_seek R7(D2Game,	517ED,	51BFA,	5DE88, 6235D, 2966D, 1E1FE, ED3BE, 26D7E);
+	mem_seek R8(D2Game,	517ED,	51BFA,	5DE88, 6235D, 2966D, 1E1FE, ED3BE, 26D7E, 16A20F);
 	memt_byte( 0x74 , 0xEB);		// JMP SHORT D2Game.01FE2368
 	//6FC8DE88  |. 74 09          JE SHORT D2Game.6FC8DE93
 	//01FE235D  |. 74 09		  JE SHORT D2Game.01FE2368
@ -267,7 +307,7 @@ void Install_RunLODs()
 	log_msg("Patch D2gfx for launch any number of Diablo II game in the same computer. (RunLODs)\n");
 	// execute if it's our packet else continue
-	mem_seek R7(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF, B6B0);
+	mem_seek R8(D2gfx, 447C, 447C, 446A, 84CF, 84AF, 894F, 85BF, B6B0, F562B);
 	memt_byte( 0x74, 0xEB );	// JMP SHORT D2gfx.6FA884F6
 	//6FA884AF  |. 74 45          JE SHORT D2gfx.6FA884F6
 	//6FA8894F  |. 74 45          JE SHORT D2gfx.6FA88996
@ -281,6 +321,17 @@ void Install_RunLODs()
 /****************************************************************************************************/
 FCT_ASM(caller_AlwaysDisplayLife_114)
    CMP onRealm, 0
    JNZ normalDisplayLife
    CMP active_AlwaysDisplayLifeMana, 0
    JE normalDisplayLife
    CMP EAX, 0x1
    RETN
 normalDisplayLife :
    CMP DWORD PTR DS : [0x7BEFDC], EAX
    RETN
 }}
 FCT_ASM (caller_AlwaysDisplayLife_113)
 	POP EAX
@ -326,7 +377,18 @@ normalDisplayLife:
 	RETN
 }}
-
+FCT_ASM( caller_AlwaysDisplayMana_114 )
    CMP onRealm, 0
    JNZ normalDisplayMana
    CMP active_AlwaysDisplayLifeMana, 0
    JE normalDisplayMana
    POP EAX
    ADD EAX, 0x32
    JMP EAX
 normalDisplayMana :
    CMP DWORD PTR DS : [0x7BEFE0], 0
    RETN
 }}
 FCT_ASM (caller_AlwaysDisplayMana_113)
 	MOV EAX,DWORD PTR DS:[ptResolutionY]
@ -386,10 +448,13 @@ void Install_AlwaysDisplayLifeMana()
 	if (isInstalled) return;
 	log_msg("Patch D2Client for always display life and mana. (ALwaysPrintLifeMana)\n");
-
+    if (version_D2Client == V114d) {
-	if ( version_D2Client >= V113c )
+        mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA, 98146);
-	{
+        memt_byte(0x39, 0xE8);
-		mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA);
+        MEMT_REF4(0x7BEFDC05, caller_AlwaysDisplayLife_114);
        memt_byte(0x00, 0x90);
    } else if ( version_D2Client >= V113c ) {
 		mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2764A, 6D6FA, 6D6FA);
 		memt_byte( 0x0F , 0x90);
 		memt_byte( 0x8C , 0xE8);
 		MEMT_REF4( 0x000000BC, caller_AlwaysDisplayLife_113);
@ -402,7 +467,7 @@ void Install_AlwaysDisplayLifeMana()
 		//6FB1D717  |. 0F8C A4000000  JL D2Client.6FB1D7C1
 	} else {
 		// Always display life.
-		mem_seek R7(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000, 0000);
+		mem_seek R8(D2Client, 58B32, 58B32, 5F102, 2D713, B5DF3, 81733, 0000, 0000, 0000);
 		memt_byte( 0xA1 , 0xE8);
 		MEMT_REF4( ptResolutionY , version_D2Client >= V111 ? caller_AlwaysDisplayLife_111 : caller_AlwaysDisplayLife);
 		//6FADD713  |. A1 605CBA6F    MOV EAX,DWORD PTR DS:[6FBA5C60]
@ -410,15 +475,19 @@ void Install_AlwaysDisplayLifeMana()
 		//6FB31733  |. A1 E4C6B86F    MOV EAX,DWORD PTR DS:[6FB8C6E4]
 	}
 	// Always display mana.
-	if ( version_D2Client >= V113c )
+    if (version_D2Client == V114d) {
-	{
+        mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC, 9824E);
        memt_byte(0x83, 0xE8);
        MEMT_REF4(0x7BEFE03D, caller_AlwaysDisplayMana_114);
        memt_byte(0x00, 0x90);
        memt_byte(0x00, 0x90);
    } else if ( version_D2Client >= V113c ) {
 		//mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 27711);
 		//memt_byte( 0x8B , 0x90);
 		//memt_byte( 0x0D , 0xE8);
 		//MEMT_REF4( offset_D2Client + 0x11C4B4 , caller_AlwaysDisplayMana_113);
-		mem_seek R7(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC);
+		mem_seek R8(D2Client, 0000, 0000, 0000, 0000, 0000, 0000, 2770C, 6D7BC, 00000);
 		memt_byte( 0xA1 , 0xE8);
 		MEMT_REF4( ptResolutionY , caller_AlwaysDisplayMana_113);
 		//6FAD770C  |> A1 4CBCB86F    MOV EAX,DWORD PTR DS:[6FB8BC4C]
@ -436,7 +505,7 @@ void Install_AlwaysDisplayLifeMana()
 	}
 	else if ( version_D2Client >= V110 )
 	{
-		mem_seek R7(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000, 0000);
+		mem_seek R8(D2Client, 0000, 0000, 5F1E6, 2D7FB, B5EDB, 8181B, 0000, 0000, 0000);
 		memt_byte( 0x5F , 0xE8);
 		MEMT_REF4( 0x815B5D5E , caller_AlwaysDisplayMana);
 		memt_byte( 0xC4 , 0x90);	// NOP
@ -461,7 +530,7 @@ void Install_AlwaysDisplayLifeMana()
 		//6FB3181F  |. 81C4 5C020000  ADD ESP,25C
 		//6FB31825  |. C3             RETN
 	} else {
-		mem_seek R7(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 58C09, 58C09, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0xE9 , 0xE8);
 		MEMT_REF4( 0x000000C2 , caller_AlwaysDisplayMana_9);
 		//6FAF8C09   . E9 C2000000    JMP D2Client.6FAF8CD0
@ -484,7 +553,7 @@ void Install_EnabledTXTFilesWithMSExcel()
 	log_msg("Patch D2Client for enabled the opening of files already opened by MS Excel. (EnabledTXTFilesWithMSExcel)\n");
-	mem_seek( (DWORD)D2StormMPQOpenFile + (version_Storm >= V111 ? 0x12A : 0xFF) );
+	mem_seek( (DWORD)D2StormMPQOpenFile + (version_Storm == V114d ? 0xB4 : version_Storm >= V111 ? 0x12A : 0xFF) );
 	memt_byte( 0x01 , 0x03);	//; |ShareMode = FILE_SHARE_READ|FILE_SHARE_WRITE									
 	//6FC1C969  |. 6A 01          PUSH 1        ; |ShareMode = FILE_SHARE_READ
@ -544,22 +613,26 @@ void Install_DisplayBaseStatsValue()
 	if (isInstalled) return;
 	log_msg("Patch D2Client for display base stats value. (DisplayBaseStatsValue)\n");
-
+    if (version_D2Client == V114d) goto jump;
 	// Always print stat button images.
-	mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955);
+	mem_seek R8(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955, BF955);
 	memt_byte( 0x8B, 0xEB );	// JMP SHORT D2Client.6FAD0088
-	memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) );
+	memt_byte( 0x4C, V8(D2Client, 12, 12, 13, 13, 13, 13, 13, 13, 13) );
 	memt_byte( 0x24, 0x90 );	// NOP
-	memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 );			// NOP (V109d:0x20 , V110:0x14
+	memt_byte( V8(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C, 1C), 0x90 );			// NOP (V109d:0x20 , V110:0x14
 	//6FAD0073     8B4C24 14         MOV ECX,DWORD PTR SS:[ESP+14]
 	//6FB32BBA   > 8B4C24 1C         MOV ECX,DWORD PTR SS:[ESP+1C]
 	//6FB3963A   > 8B4C24 1C         MOV ECX,DWORD PTR SS:[ESP+1C]
 	//6FB1B59A   > 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
 	//6FB6D1B5  |> 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
 	//6FB6F955  |> 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
-
+    jump:
-	mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE);
+	mem_seek R8(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE, A808C);
-	MEMJ_REF4( D2PrintImage, caller_displayBaseStatsValue);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x0004E3F0, caller_displayBaseStatsValue);
    } else {
        MEMJ_REF4(D2PrintImage, caller_displayBaseStatsValue);
    }
 	//6FB32C53   . E8 82A3F8FF    CALL <JMP.&D2gfx.#10047>
 	//6FB396D3   . E8 D238F8FF    CALL <JMP.&D2gfx.#10044>
 	//6FB1B636   . E8 431AFAFF    CALL <JMP.&D2gfx.#10024>
@ -577,8 +650,9 @@ void Install_DisplayBaseStatsValue()
 RunesBIN* STDCALL compileRunesTxt(DWORD unused, const char* filename, BINField* ptFields, DWORD* ptRecordCount, DWORD recordLength)
 {
 	RunesBIN* ptRunesBin = (RunesBIN*)D2CompileTxtFile(unused, filename, ptFields, ptRecordCount, recordLength);
-	for (DWORD i=0; i < *ptRecordCount; i++)
+	for (DWORD i = 0; i < *ptRecordCount; i++) {
-		ptRunesBin[i].Server=0;
+		ptRunesBin[i].Server = 0;
 	}
 	return ptRunesBin;
 }
@ -592,8 +666,12 @@ void Install_LadderRunewords()
 	log_msg("Patch D2Common for enabled the ladder only runewords. (LadderRunewords)\n");
-	mem_seek R7(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2, 63782);
+	mem_seek R8(D2Common, 0000, 0000, 1E965, 61762, 43A72, 5D492, 724B2, 63782, 239C40);
-	MEMC_REF4( D2CompileTxtFile, compileRunesTxt);
+    if (version_D2Common == V114d) {
        MEMT_REF4(0xFFFD86AC, compileRunesTxt);
    } else {
        MEMC_REF4(D2CompileTxtFile, compileRunesTxt);
    }
 	//01B6E964  |. E8 0714FFFF    CALL D2Common.#10578                     ; \#10578
 	//6FDB1761  |. E8 FAA8FCFF    CALL D2Common.#10653                     ; \#10653
 	//6FD93A71  |. E8 EAADFCFF    CALL D2Common.#10496                     ; \#10496
@ -617,7 +695,7 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
 	log_msg("Patch D2Game for enabled the opening of Cow Portal when player have already kill the cow king in that difficulty. (EnabledCowPortalWhenCowKingWasKill)\n");
-	mem_seek R7(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508, EBE8);
+	mem_seek R8(D2Game, 5DFF7, 5E457, 6C5E7 , B1278, 5DB68, 75C68, 67508, EBE8, 194179);
 	memt_byte( 0x85 , 0x33); // XOR EAX,EAX
 	//6FC8DFF7   . 85C0           TEST EAX,EAX
 	//6FC8E457   . 85C0           TEST EAX,EAX
@ -633,4 +711,23 @@ void Install_EnabledCowPortalWhenCowKingWasKill()
 	isInstalled = true;
 }
 /****************************************************************************************************/
 void Install_DoNotCloseNihlathakPortal()
 {
  static int isInstalled = false;
  if (version_D2Game < V114d || isInstalled) return;
  log_msg("Patch D2Game to not close Nihlathak's portal. (DoNotCloseNihlathakPortal)\n");
  mem_seek R8(D2Game, 0, 0, 0, 0, 0, 0, 0, 0, 18B9D7);
  memt_byte(0x0F, 0x90);
  memt_byte(0x85, 0x90);
  memt_dword(0x000000C5, 0x90909090);
  log_msg("\n");
  isInstalled = true;
 }
 /*================================= END OF FILE =================================*/
--- a/PlugY/GlobalVariable.cpp
+++ b/PlugY/GlobalVariable.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Updating server.
@ -27,6 +28,21 @@ void STDCALL BtnPress()
 	previouslyOnRealm = onRealm;
 }
 FCT_ASM( caller_BnetBtnPress114 )
    CMP active_DisableBattleNet, 1
    JE disableBattleNet
    MOV onRealm, 1
    PUSH EAX
    CALL BtnPress
    POP EAX
    SUB ESP, 0x3FC//400
    JMP DWORD PTR SS : [ESP + 0x3FC]
 disableBattleNet :
    POP EAX
    POP EAX
    RETN
 }}
 FCT_ASM ( caller_BnetBtnPress )
 	CMP active_DisableBattleNet,1
 	JE disableBattleNet
@ -49,6 +65,17 @@ FCT_ASM ( caller_MultiPlayerBtnPress )
 }}
 */
 FCT_ASM( caller_TCPIPBtnPress114 )
    MOV onRealm, 0
    PUSH EAX
    PUSH EDX
    CALL BtnPress
    POP EDX
    POP EAX
    MOV ECX, 0x006D39BC
    RETN
 }}
 FCT_ASM ( caller_TCPIPBtnPress111 )
 	MOV onRealm,0
 	CALL BtnPress
@ -99,9 +126,9 @@ void Install_VariableOnRealm()
 	log_msg("Patch D2Launch for set not on realm variable. (VariableonRealm)\n");
 	// click on Battle.net button
-	mem_seek R7(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295, 11C65);
+	mem_seek R8(D2Launch, 8195, 81A5, 9915, 129E5, 18AA5, 17D15, 19295, 11C65, 3533B);
 	memt_byte( 0x81, 0xE8 );	// CALL
-	MEMT_REF4( 0x000400EC, caller_BnetBtnPress);
+	MEMT_REF4( 0x000400EC, version_D2Launch == V114d ? caller_BnetBtnPress114 : caller_BnetBtnPress);
 	memt_byte( 0x00, 0x90 );	// NOP
 	//6FA529E5   . 81EC 00040000  SUB ESP,400
@ -112,11 +139,14 @@ void Install_VariableOnRealm()
 	//6FA1EFFC   . B8 01000000    MOV EAX,1
 	// click on TCP/IP button
-	mem_seek R7(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E, 1053E);
+	mem_seek R8(D2Launch, 87B9, 87C9, 9F99, 11329, 17409, 16659, 17B8E, 1053E, 2FFFA);
 	if (version_D2Launch == V109b || version_D2Launch == V109d || version_D2Launch == V110)
 	{
 		memt_byte( 0xBD, 0xE8 );	// CALL
 		MEMT_REF4( 0x00000001, caller_TCPIPBtnPress);
    } else if (version_D2Launch == V114d) {
        memt_byte(0xB9, 0xE8);
        MEMT_REF4(0x006D39BC, caller_TCPIPBtnPress114);
    } else {
 		memt_byte( 0xBE, 0xE8 );	// CALL
 		MEMT_REF4( 0x00000040, caller_TCPIPBtnPress111);
@ -124,7 +154,7 @@ void Install_VariableOnRealm()
 	}
 	// click on SinglePlayer button
-	mem_seek R7(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36, A906);
+	mem_seek R8(D2Launch, D1F6, D1E6, EC16, B726, 117E6, 10A56, 11F36, A906, 30BC9);
 	memt_byte( 0xBA, 0xE8 );	// CALL
 	MEMT_REF4( 0x00000400, caller_SinglePlayerBtnPress);
 	//6FA4B726   . BA 00040000    MOV EDX,400
@ -133,7 +163,7 @@ void Install_VariableOnRealm()
 	{
 		log_msg("\nPatch D2Game for fixing ptClient removing bug. (VariableonRealm)\n");
 		//Bug crash ptClient search fix (for Megalixir Mod).
-		mem_seek R7(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Game, 0000, 0000, 2B97, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x39 ,0xE8);
 		MEMT_REF4( 0x8B0C7429 , caller_fixClientRemovingBug);
 		memt_byte( 0xC1 ,0x90);
--- a/PlugY/InfinityStash.cpp
+++ b/PlugY/InfinityStash.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Gestion of the infinity and shared Stash.
@ -289,6 +290,8 @@ DWORD loadStashList(Unit* ptChar, BYTE* data, DWORD maxSize, DWORD* curSize, boo
 	DWORD nbStash = *(DWORD*)&data[*curSize];
 	*curSize += 4;
    log_msg("loadStashList\n\nnbStash = %d\n\n", nbStash);
 	while (curStash < nbStash)
 	{
 		newStash = addStash(ptChar, isShared);
@ -764,6 +767,26 @@ DWORD STDCALL carry1Limit(Unit* ptChar, Unit* ptItemParam, DWORD itemNum, BYTE p
 	return 0;
 }
 FCT_ASM( caller_carry1Limit_114 )
    PUSH DWORD PTR SS : [ESP + 0x08]//page
    PUSH 0//EDI
    PUSH DWORD PTR SS : [ESP + 0x0C]
    PUSH ESI//ptChar
    CALL carry1Limit
    TEST EAX, EAX
    JNZ	end_carry1Limit
    JMP D2ItemSetPage
 end_carry1Limit :
    ADD ESP, 0x10
    XOR EAX, EAX
    POP EDI
    POP EBX
    POP ESI
    MOV ESP, EBP
    POP EBP
    RETN 8
 }}
 FCT_ASM ( caller_carry1Limit_111 )
 	PUSH DWORD PTR SS:[ESP+0x08]//page
 	PUSH 0//EDI
@ -803,6 +826,26 @@ end_carry1Limit:
 	RETN 8
 }}
 FCT_ASM( caller_carry1LimitSwap_114 )
    PUSH EAX
    PUSH DWORD PTR SS : [ESP + 0x20]
    PUSH 0
    PUSH EDI//ptChar
    CALL carry1Limit
    TEST EAX, EAX
    JNZ	end_carry1Limit
    JMP D2ItemGetPage
 end_carry1Limit :
    ADD ESP, 8
    XOR EAX, EAX
    POP EBX
    POP EDI
    POP ESI
    MOV ESP, EBP
    POP EBP
    RETN 8
 }}
 FCT_ASM ( caller_carry1LimitSwap_112 )
 	PUSH EAX
 	PUSH DWORD PTR SS:[ESP+0x1C]
@ -880,6 +923,20 @@ END_carry1LimitWhenDrop:
 	RETN
 }}*/
 FCT_ASM( caller_carry1LimitWhenDrop_114 )
    PUSH 0
    PUSH 0
    PUSH DWORD PTR SS : [ESP + 0x10] //ptItem
    PUSH EBX //ptChar
    CALL carry1Limit
    TEST EAX, EAX
    JNZ	end_carry1Limit
    JMP D2CanPutItemInInv
 end_carry1Limit :
    XOR EAX, EAX
    RETN 0x1C
 }}
 FCT_ASM ( caller_carry1LimitWhenDrop_111 )
 	PUSH 0
 	PUSH 0
@ -925,6 +982,19 @@ END_carry1LimitWhenDrop:
 	RETN
 }}
 FCT_ASM( caller_carry1OutOfStash_114 )
    PUSH ESI
    CALL D2ItemGetPage
    CMP AL, 4
    JNZ continue_carry1OutOfStash
    SUB DWORD PTR SS : [ESP], 0xC
    RETN
 continue_carry1OutOfStash :
    MOV EDI, DWORD PTR SS : [EBP - 0x4]
    TEST EDI, EDI
    RETN
 }}
 FCT_ASM ( caller_carry1OutOfStash_111 )
 	PUSH EDI
 	CALL D2ItemGetPage
@ -967,8 +1037,12 @@ void Install_MultiPageStash()
 		log_msg("Patch D2Game for carry1 unique item. (MultiPageStash)\n");
 		// Cannot put 2 items carry1 in inventory
-		mem_seek R7(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3, 6B013);
+		mem_seek R8(D2Game, 0000, 0000, 55050, 57CA3, 2FE63, 99B03, CF1E3, 6B013, 14AC7F);
-		MEMJ_REF4( D2ItemSetPage , version_D2Game >= V111 ? caller_carry1Limit_111 : caller_carry1Limit);
+        if (version_D2Game == V114d) {
            MEMT_REF4(0x000DD5FD, caller_carry1Limit_114);
        } else {
            MEMJ_REF4(D2ItemSetPage, version_D2Game >= V111 ? caller_carry1Limit_111 : caller_carry1Limit);
        }
 		//6FC8504F   . E8 94670900    CALL <JMP.&D2Common.#10720>
 		//01FD7CA2   . E8 6329FBFF    CALL <JMP.&D2Common.#10485>
 		//01F9FE62   . E8 47A8FDFF    CALL <JMP.&D2Common.#10608>
@ -977,8 +1051,12 @@ void Install_MultiPageStash()
 		//6FC8B012   . E8 13F7F9FF    CALL <JMP.&D2Common.#11026>
 		// Cannot put 2 items carry1 in inventory by swapping
-		mem_seek R7(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8, 6BC78);
+		mem_seek R8(D2Game, 0000, 0000, 558D9, 58968, 310E8, 9B6E8, D10C8, 6BC78, 14B179);
-		MEMJ_REF4( D2ItemGetPage , version_D2Game >= V112 ? caller_carry1LimitSwap_112 : version_D2Game >= V111 ? caller_carry1LimitSwap_111 : caller_carry1LimitSwap);
+        if (version_D2Game == V114d) {
            MEMT_REF4(0x000DD0D3, caller_carry1LimitSwap_114);
        } else {
            MEMJ_REF4(D2ItemGetPage, version_D2Game >= V112 ? caller_carry1LimitSwap_112 : version_D2Game >= V111 ? caller_carry1LimitSwap_111 : caller_carry1LimitSwap);
        }
        //6FC858D8   . E8 175F0900    CALL <JMP.&D2Common.#10719>
 		//01FD8967   . E8 8E1DFBFF    CALL <JMP.&D2Common.#10820>
 		//01FA10E7   . E8 9A96FDFF    CALL <JMP.&D2Common.#10505>
@ -989,8 +1067,12 @@ void Install_MultiPageStash()
 		if ( version_D2Game >= V111 )
 		{
 			// Cannot put 2 items carry1 in inventory when drop cube
-			mem_seek R7(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75, B7B15);
+			mem_seek R8(D2Game, 0000, 0000, 0000, 3D935, 49FD5, 17AD5, D7B75, B7B15, 163A89);
-			MEMJ_REF4( D2CanPutItemInInv , caller_carry1LimitWhenDrop_111);
+            if (version_D2Game == V114d) {
                MEMT_REF4(0x000D7EC3, caller_carry1LimitWhenDrop_114);
            } else {
                MEMJ_REF4(D2CanPutItemInInv, caller_carry1LimitWhenDrop_111);
            }
 			//01FBD934  |. E8 5BD3FCFF    |CALL <JMP.&D2Common.#10855>
 			//01FB9FD4  |. E8 3912FCFF    |CALL <JMP.&D2Common.#10813>
 			//6FC37AD4  |. E8 0535FFFF    |CALL <JMP.&D2Common.#10289>
@ -998,17 +1080,22 @@ void Install_MultiPageStash()
 			//6FCD7B14  |. E8 7D32F5FF    |CALL <JMP.&D2Common.#10402>
 		} else {
 			// Cannot put 2 items carry1 in inventory when drop cube
-			mem_seek R7(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000, 0000);
+			mem_seek R8(D2Game, 0000, 0000, 14341, 0000, 0000, 0000, 0000, 0000, 0000);
 			memt_byte( 0xBA ,0xE8);
 			MEMT_REF4( 0x00000806 , caller_carry1LimitWhenDrop);
 			//6FC44341  |. BA 06080000    |MOV EDX,806
 		}
 		// Verif only carry1 out of stash page when pick up an item
-		mem_seek R7(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B, B301B);
+		mem_seek R8(D2Game, 0000, 0000, 1299E, 38E3B, 43F0B, 1209B, D211B, B301B, 15CADD);
-		memt_byte( 0x8B ,0xE8);
+        if (version_D2Game == V114d) {
-		MEMT_REF4( version_D2Game >= V111 ? 0x850C2474 : 0x85102444 , version_D2Game >= V111 ? caller_carry1OutOfStash_111 : caller_carry1OutOfStash);
+            memt_byte(0x8B, 0xE8);
-		memt_byte( version_D2Game >= V111 ? 0xF6 : 0xC0 ,0x90);
+            MEMT_REF4(0xFF85FC7D, caller_carry1OutOfStash_114);
        } else {
            memt_byte(0x8B, 0xE8);
            MEMT_REF4(version_D2Game >= V111 ? 0x850C2474 : 0x85102444, version_D2Game >= V111 ? caller_carry1OutOfStash_111 : caller_carry1OutOfStash);
            memt_byte(version_D2Game >= V111 ? 0xF6 : 0xC0, 0x90);
        }
        //6FC4299E  |. 8B4424 10      |MOV EAX,DWORD PTR SS:[ESP+10]
 		//6FC429A2  |. 85C0           |TEST EAX,EAX
 		//01FB8E3B  |. 8B7424 0C      |MOV ESI,DWORD PTR SS:[ESP+C]
--- a/PlugY/Interface_Skills.cpp
+++ b/PlugY/Interface_Skills.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Interface functions
@ -28,7 +29,7 @@ void STDCALL printSkillsPageBtns()
 	if (active_SkillsPoints && !onRealm && D2isLODGame())
 	{
 		sDrawImageInfo data;
-		ZeroMemory(&data,sizeof(data));
+		ZeroMemory(&data, sizeof(data));
 		setImage(&data, unassignSkillsBtnImages);
 		setFrame(&data, btnSkillIsDown);
 		D2PrintImage(&data, getXSkillBtn(), getYSkillBtn(), -1, 5, 0);
@ -44,7 +45,8 @@ void STDCALL printSkillsPageBtns()
 Unit* STDCALL skillsPageMouseDown(sWinMessage* msg)
 {
 	Unit* ptChar = D2GetClientPlayer();
-
+    log_msg("push down left button\n");
    log_msg("type=%u\nx=%u\ny=%u\n\n", msg->type, msg->x, msg->y);
 	if ( active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
 	{
 		log_msg("push down left button unassign skill\n");
@ -59,6 +61,7 @@ Unit* STDCALL skillsPageMouseDown(sWinMessage* msg)
 void STDCALL skillsPageMouseUp()
 {
  log_msg("push up left button\n");
 	if ( active_SkillsPoints && !onRealm && D2isLODGame() && isOnButtonUnassignSkill(D2GetMouseX(),D2GetMouseY()))
 	{
 		log_msg("push up left button unassign skill\n");
@ -88,11 +91,22 @@ FCT_ASM ( caller_printSkillsPageBtns )
 	RETN
 }}
-FCT_ASM ( caller_DontPrintSkillPointsRemaining_111 )
+FCT_ASM( caller_DontPrintSkillPointsRemaining_114 )
-	MOV AL,BYTE PTR DS:[onRealm]
+    MOV AL, BYTE PTR DS : [onRealm]
-	TEST AL,AL
+    TEST AL, AL
    JNZ dontPrint
-	ADD DWORD PTR SS:[ESP],0xF2
+    ADD DWORD PTR SS : [ESP], 0x97
    RETN
    dontPrint :
    MOV ECX, 0x1083
    RETN
 }}
 FCT_ASM(caller_DontPrintSkillPointsRemaining_111)
    MOV AL, BYTE PTR DS : [onRealm]
    TEST AL, AL
    JNZ dontPrint
    ADD DWORD PTR SS : [ESP], 0xF2
 	RETN
 dontPrint:
 	MOV ECX,0x1083
@ -110,6 +124,12 @@ dontPrint:
 	RETN
 }}
 FCT_ASM( caller_skillsPageMouseDown_114 )
  PUSH ESI
  CALL skillsPageMouseDown
  RETN
 }}
 FCT_ASM ( caller_skillsPageMouseDown_111 )
 	PUSH EBP
 	CALL skillsPageMouseDown
@ -139,7 +159,7 @@ void Install_InterfaceSkills()
 	log_msg("Patch D2Client for skills interface. (InterfaceSkills)\n");
 	// Print new buttons images
-	mem_seek R7(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20, 2F380);
+	mem_seek R8(D2Client, 7AC20, 7AC20, 77073, 16190, 8A9C0, 7F320, 77F20, 2F380, AB7A5);
 	memt_byte( 0x5F, 0xE9 );	// JMP caller_printBtns
 	if ( version_D2Client >= V111 ) {
 		MEMT_REF4( 0xCCC35B5E, caller_printSkillsPageBtns_111);
@ -184,9 +204,9 @@ void Install_InterfaceSkills()
 	if (posXUnassignSkillBtn==-1 && posYUnassignSkillBtn==-1)
 	{
 		// Don't print "Skill Points Remaining"
-		mem_seek R7(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334, 2F7E4);
+		mem_seek R8(D2Client, 7AC30, 7AC30, 77080, 16294, 8AC74, 7ECF4, 78334, 2F7E4, AACE0);
 		memt_byte( 0xB9, 0xE8 );
-		MEMT_REF4( 0x00001083, version_D2Client >= V111 ? caller_DontPrintSkillPointsRemaining_111 : caller_DontPrintSkillPointsRemaining);
+		MEMT_REF4( 0x00001083, version_D2Client == V114d ? caller_DontPrintSkillPointsRemaining_114 : version_D2Client >= V111 ? caller_DontPrintSkillPointsRemaining_111 : caller_DontPrintSkillPointsRemaining);
 		//6FB17080  /$ B9 83100000    MOV ECX,1083
 		//6FAC6294  |. B9 83100000    MOV ECX,1083
 		//6FB3AC74  |. B9 83100000    MOV ECX,1083
@ -196,11 +216,12 @@ void Install_InterfaceSkills()
 	}
 	// Manage mouse down (Play sound)
-	mem_seek R7(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62, 31112);
+    mem_seek R8(D2Client, 7BBD1, 7BBD1, 780E4, 17BC2, 8C6E2, 808B2, 79C62, 31112, ABC1A);
-	memt_byte( 0xC7, 0xE8 );	// CALL caller_skillsPageMouseDown
+    memt_byte(0xC7, 0xE8);	// CALL caller_skillsPageMouseDown
-	MEMT_REF4( version_D2Client >= V111 ? 0x00001845 : 0x00001843, version_D2Client >= V111 ? caller_skillsPageMouseDown_111 : caller_skillsPageMouseDown);
+    MEMT_REF4(version_D2Client == V114d ? 0x00001846 : version_D2Client >= V111 ? 0x00001845 : 0x00001843, version_D2Client == V114d ? caller_skillsPageMouseDown_114 : version_D2Client >= V111 ? caller_skillsPageMouseDown_111 : caller_skillsPageMouseDown);
-	memt_byte( 0x00, 0x90 );	// NOP
+    memt_byte(0x00, 0x90);	// NOP
-	memt_byte( 0x00, 0x90 );	// NOP
+    memt_byte(0x00, 0x90);	// NOP
 	//6FB180E4   > C743 18 00000000     MOV DWORD PTR DS:[EBX+18],0
 	//6FAC7BC2   > C745 18 00000000     MOV DWORD PTR SS:[EBP+18],0
 	//6FB3C6E2   > C745 18 00000000     MOV DWORD PTR SS:[EBP+18],0
@ -209,8 +230,12 @@ void Install_InterfaceSkills()
 	//6FAE1112   > C745 18 00000000     MOV DWORD PTR SS:[EBP+18],0
 	// Manage mouse up
-	mem_seek R7(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8);
+	mem_seek R8(D2Client, 7BC40, 7BC40, 78466, 17558, 8C078, 80248, 795F8, 30AA8, ABC96/*ABE38*/);
-	MEMJ_REF4( D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A
+    if (version_D2Client == V114d) {
        MEMT_REF4(/*0xFFFFFE45*/0xFFF745F6, caller_skillsPageMouseUp);
    } else {
        MEMJ_REF4(D2FreeWinMessage, caller_skillsPageMouseUp);//0xFFF93B0A
    }
 	//6FB18465   . E8 C07D0400    CALL <JMP.&Storm.#511>
 	//6FAC7557   .^E9 4248FFFF    JMP <JMP.&Storm.#511>
 	//6FB3C077   .^E9 16FDF7FF    JMP <JMP.&Storm.#511>
--- a/PlugY/Interface_Stash.cpp
+++ b/PlugY/Interface_Stash.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Interface stats page functions
@ -346,6 +347,24 @@ Unit* STDCALL initGetNextItemForSet(Inventory* ptInventory)
 	return getNextItemForSet(item);
 }
 FCT_ASM( caller_manageBtnDown_114 )
    PUSH EBX
    CALL manageBtnDown
    TEST EAX, EAX
    JE IS_NOT_ON_BUTTON
    POP EDX
    MOV EDX, DWORD PTR DS : [EDX + 0xA]
    MOV DWORD PTR DS : [EDX], 1
    POP EDI
    POP ESI
    POP EBX
    MOV ESP, EBP
    POP EBP
    RETN 4
 IS_NOT_ON_BUTTON :
    JMP D2ClickOnStashButton
 }}
 FCT_ASM( caller_manageBtnDown_111 )
 	PUSH EBP
@ -381,6 +400,31 @@ IS_NOT_ON_BUTTON:
 	JMP D2isLODGame
 }}
 FCT_ASM( caller_manageBtnUp_114 )
    PUSH EBX
    CALL manageBtnUp
    MOV isDownBtn.all, 0
    TEST EAX, EAX
    JE IS_NOT_ON_BUTTON
    POP EDX
    MOV EDX, DWORD PTR DS : [EDX + 0x33]
    MOV DWORD PTR DS : [EDX], 0
    SUB EDX, 8
    MOV DWORD PTR DS : [EDX], 0
    ADD EDX, 4
    MOV DWORD PTR DS : [EDX], 0
    ADD EDX, 0x68
    MOV DWORD PTR DS : [EDX], 0
    POP EDI
    POP ESI
    POP EBX
    MOV ESP, EBP
    POP EBP
    RETN 4
 IS_NOT_ON_BUTTON:
    JMP D2ClickOnStashButton
 }}
 FCT_ASM( caller_manageBtnUp_111 )
 	PUSH EBX
 	CALL manageBtnUp
@ -430,6 +474,11 @@ IS_NOT_ON_BUTTON:
 	JMP D2isLODGame
 }}
 FCT_ASM( initBtnsStates_114 )
    MOV isDownBtn.all, 0
    MOV DWORD PTR DS : [0x7BCC3C], EAX
    RETN
 }}
 FCT_ASM ( initBtnsStates )
 	MOV isDownBtn.all,0
@ -449,8 +498,12 @@ void Install_InterfaceStash()
 	log_msg("Patch D2Client for stash interface. (InterfaceStash)\n");
 	// Print button images
-	mem_seek R7(D2Client, 39060, 39060, 3F399, B1006, 7DF86, B3656, 99A56, 9DE26);
+	mem_seek R8(D2Client, 39060, 39060, 3F399, B1006, 7DF86, B3656, 99A56, 9DE26, 8F308);
-	MEMC_REF4( D2LoadBuySelBtn, printBtns);
+	if (version_D2Client == V114d) {
        MEMT_REF4(0xFFFC52F4, printBtns);
 	} else {
        MEMC_REF4(D2LoadBuySelBtn, printBtns);
 	}
 	//6FADF398  |. E8 734D0400    CALL D2Client.6FB24110
 	//6FB61005  |. E8 A6D3FEFF    CALL D2Client.6FB4E3B0
 	//6FB2DF85  |. E8 3642FEFF    CALL D2Client.6FB121C0
@ -459,8 +512,12 @@ void Install_InterfaceStash()
 	//6FB4DE25  |. E8 76ACF7FF    CALL D2Client.6FAC8AA0
 	// print page number
-	mem_seek R7(D2Client, 3903C, 3903C, 3F375, B0FE3, 7DF63, B3633, 99A33, 9DE03);
+	mem_seek R8(D2Client, 3903C, 3903C, 3F375, B0FE3, 7DF63, B3633, 99A33, 9DE03, 8F2E5);
-	MEMJ_REF4( D2PrintString, printPageNumber);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x00073037, printPageNumber);
    } else {
        MEMJ_REF4(D2PrintString, printPageNumber);
    }
 	//6FADF374  |. E8 3FCC0800    CALL <JMP.&D2Win.#10117>
 	//6FB60FE2  |. E8 99C2F5FF    CALL <JMP.&D2Win.#10020>
 	//6FB2DF62  |. E8 19F3F8FF    CALL <JMP.&D2Win.#10064>
@ -469,8 +526,12 @@ void Install_InterfaceStash()
 	//6FB4DE02  |. E8 4739F7FF    CALL <JMP.&D2Win.#10076>
 	// Manage mouse down (Play sound)
-	mem_seek R7(D2Client, 45091, 45091, 4BBA1, B4666, 7FDD6, B54A6, 9B8A6, 9FC76);
+	mem_seek R8(D2Client, 45091, 45091, 4BBA1, B4666, 7FDD6, B54A6, 9B8A6, 9FC76, 925B8);
-	MEMC_REF4( version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnDown_111 : caller_manageBtnDown);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0xFFFF73C4, caller_manageBtnDown_114);
    } else {
        MEMC_REF4(version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnDown_111 : caller_manageBtnDown);
    }
    //6FAEBBA0   > E8 DB04FCFF    CALL D2Client.6FAAC080
 	//6FB64665   . E8 B61EFFFF    CALL D2Client.6FB56520
 	//6FB2FDD5   . E8 E612FFFF    CALL D2Client.6FB210C0
@ -479,8 +540,12 @@ void Install_InterfaceStash()
 	//6FB4FC75   . E8 960FFFFF    CALL D2Client.6FB40C10
 	// Manage mouse up
-	mem_seek R7(D2Client, 455F9, 455F9, 4C0F9, B57B9, 7FC09, B52D9, 9B6D9, 9FAA9);
+	mem_seek R8(D2Client, 455F9, 455F9, 4C0F9, B57B9, 7FC09, B52D9, 9B6D9, 9FAA9, 89B63);
-	MEMC_REF4( version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnUp_111 : caller_manageBtnUp);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0xFFFFFE19, caller_manageBtnUp_114);
    } else {
        MEMC_REF4(version_D2Client >= V111 ? (DWORD)D2ClickOnStashButton : (DWORD)D2isLODGame, version_D2Client >= V111 ? caller_manageBtnUp_111 : caller_manageBtnUp);
    }
    //6FAEC0F8   > E8 83FFFBFF    CALL D2Client.6FAAC080
 	//6FB657B8   > E8 630DFFFF    CALL D2Client.6FB56520
 	//6FB2FC08   > E8 B314FFFF    CALL D2Client.6FB210C0
@ -489,10 +554,15 @@ void Install_InterfaceStash()
 	//6FB4FAA8   > E8 6311FFFF    CALL D2Client.6FB40C10
 	// init state of button on open stash page
-	mem_seek R7(D2Client, 45B3A, 45B3A, 4C63A, A645A, 749DA, A9D9A, 8CC3A, 9441A);
+	mem_seek R8(D2Client, 45B3A, 45B3A, 4C63A, A645A, 749DA, A9D9A, 8CC3A, 9441A, 89ED0);
-	memt_byte( 0x81, 0xE9 );	// CALL initBtnsStates
+    if (version_D2Client == V114d) {
-	MEMT_REF4( 0x000104C4, initBtnsStates);
+        memt_byte(0xA3, 0xE8);
-	memt_byte( 0x00, 0x90 );
+        MEMT_REF4(0x007BCC3C, initBtnsStates_114);
    } else {
        memt_byte(0x81, 0xE9);	// CALL initBtnsStates
        MEMT_REF4(0x000104C4, initBtnsStates);
        memt_byte(0x00, 0x90);
  }
 	//6FAE5B3A  |> 81C4 04010000  ADD ESP,104
 	//6FAE5B3A  |> 81C4 04010000  ADD ESP,104
 	//6FAEC63A  |> 81C4 04010000  ADD ESP,104
@ -503,8 +573,12 @@ void Install_InterfaceStash()
 	//6FB4441A  |> 81C4 04010000  ADD ESP,104
 	// init the search of print in green the item set name we have in stash
-	mem_seek R7(D2Client, 3F098, 3F098, 45997, A71F4, 71F64, A7314, 8D434, 91A24);
+	mem_seek R8(D2Client, 3F098, 3F098, 45997, A71F4, 71F64, A7314, 8D434, 91A24, 86774);
-	MEMJ_REF4( D2InventoryGetFirstItem, initGetNextItemForSet);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x001B4B48, initGetNextItemForSet);
    } else {
        MEMJ_REF4(D2InventoryGetFirstItem, initGetNextItemForSet);
    }
 	//6FAE5996  |. E8 D5500800    CALL <JMP.&D2Common.#10277>
 	//6FB571F3  |. E8 D64EF6FF    CALL <JMP.&D2Common.#10402>
 	//6FB21F63  |. E8 96A1F9FF    CALL <JMP.&D2Common.#10535>
@ -513,8 +587,12 @@ void Install_InterfaceStash()
 	//6FB41A23  |. E8 96A7F7FF    CALL <JMP.&D2Common.#11040>
 	// Get next item for print in green the item set name we have in stash
-	mem_seek R7(D2Client, 3F0FA, 3F0FA, 45A1C, A728B, 71FFB, A73AB, 8D4CB, 91ABB);
+	mem_seek R8(D2Client, 3F0FA, 3F0FA, 45A1C, A728B, 71FFB, A73AB, 8D4CB, 91ABB, 86807);
-	MEMJ_REF4( D2UnitGetNextItem, getNextItemForSet);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x001B7795, getNextItemForSet);
    } else {
        MEMJ_REF4(D2UnitGetNextItem, getNextItemForSet);
    }
 	//6FAE5A1B   E8 4A500800      CALL <JMP.&D2Common.#10304>
 	//6FB5728A  |. E8 0B4FF6FF    |CALL <JMP.&D2Common.#10934>
 	//6FB21FFA  |. E8 A1A1F9FF    |CALL <JMP.&D2Common.#11140>
--- a/PlugY/Interface_Stats.cpp
+++ b/PlugY/Interface_Stats.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Interface functions
@ -138,6 +139,16 @@ Unit* STDCALL statsPageMouseUp(sWinMessage* msg)
 	return ptChar;
 }
 FCT_ASM( caller_printStatsPageBtns_114 )
    CALL printStatsPageBtns
    POP EDI
    POP ESI
    POP EBX
    MOV ESP, EBP
    POP EBP
    RETN
 }}
 FCT_ASM ( caller_printStatsPageBtns_111 )
 	CALL printStatsPageBtns
 	POP EDI
@ -169,7 +180,21 @@ FCT_ASM ( caller_printStatsPageBtns_9 )
 	RETN
 }}
-
+FCT_ASM( caller_statsPageMouseDown_114 )
    PUSH DWORD PTR SS : [ESP + 0x18]
    CALL statsPageMouseDown
    TEST EAX, EAX
    JE fin_statsPageMouseDown
    MOV EAX, DWORD PTR DS : [0x7A6A70]
    RETN
 fin_statsPageMouseDown :
    ADD ESP, 4
    POP EDI
    POP ESI
    POP EBX
    POP EBP
    RETN 4
 }}
 FCT_ASM ( caller_statsPageMouseDown_111 )
 	PUSH DWORD PTR SS:[ESP+0x20]
@ -201,6 +226,22 @@ fin_statsPageMouseDown:
 	RETN 4
 }}
 FCT_ASM( caller_statsPageMouseUp_114 )
    PUSH DWORD PTR SS : [EBP + 0x8]
    CALL statsPageMouseUp
    TEST EAX, EAX
    JE fin_statsPageMouseUp
    MOV EAX, DWORD PTR DS : [0x7A6A70]
    RETN
 fin_statsPageMouseUp :
    POP EDI
    POP ESI
    POP EBX
    MOV ESP, EBP
    POP EBP
    RETN 4
 }}
 FCT_ASM ( caller_statsPageMouseUp )
 	PUSH EBP
 	CALL statsPageMouseUp
@ -244,9 +285,16 @@ void Install_InterfaceStats()
 	log_msg("Patch D2Client for stats interface. (InterfaceStats)\n");
 	// Print new buttons images
-	mem_seek R7(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6);
+    if (version_D2Client == V114d) {
-	memt_byte( 0x5F, 0xE9 );	// JMP
+        mem_seek R8(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6, A8949);
-	MEMT_REF4( 0x815B5D5E, version_D2Client >= V111 ? caller_printStatsPageBtns_111: version_D2Client == V110 ? caller_printStatsPageBtns : caller_printStatsPageBtns_9);
+        memt_byte(0x5F, 0xE9);
        MEMT_REF4(0xE58B5B5E, caller_printStatsPageBtns_114);
    } else {
        mem_seek R8(D2Client, 2A7BE, 2A7AE, 30F86, 83636, 8A0B6, 6C016, BDC16, C03B6, C03B6);
        memt_byte(0x5F, 0xE9);	// JMP
        MEMT_REF4(0x815B5D5E, version_D2Client >= V111 ? caller_printStatsPageBtns_111 : version_D2Client == V110 ? caller_printStatsPageBtns : caller_printStatsPageBtns_9);
    }
    //6FAD0F86   . 5F                   POP EDI
 	//6FAD0F87   . 5E                   POP ESI
 	//6FAD0F88   . 5D                   POP EBP
@ -282,14 +330,18 @@ void Install_InterfaceStats()
 	//6FB703B8  |. 5D             POP EBP
 	//6FB703B9  |. 5B             POP EBX
 	//6FB703BA  |. 81C4 70030000  ADD ESP,370
-	//6FB703Ñ0  \. C3             RETN
+	//6FB703<EFBFBD>0  \. C3             RETN
 	if ( version_D2Client >= V111 )
 	{
 		// Manage mouse down (Play sound)
-		mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568);
+		mem_seek R8(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, BCDC8, BF568, A77D4);
-		memt_byte( 0xA1, 0xE8 );
+        if (version_D2Client == V114d) {
-		MEMT_REF4( ptptClientChar, caller_statsPageMouseDown);
+            MEMT_REF4(0xFFFBC5F8, caller_statsPageMouseDown_114);
        } else {
            memt_byte(0xA1, 0xE8);
            MEMT_REF4(ptptClientChar, caller_statsPageMouseDown);
        }
 		//6FB327C8   . A1 F0C4BC6F    MOV EAX,DWORD PTR DS:[6FBCC4F0]
 		//6FB39248   . A1 E0C1BC6F    MOV EAX,DWORD PTR DS:[6FBCC1E0]
 		//6FB1B1A8   . A1 D0C3BC6F    MOV EAX,DWORD PTR DS:[6FBCC3D0]
@ -297,9 +349,13 @@ void Install_InterfaceStats()
 		//6FB6F568   . A1 50D0BC6F    MOV EAX,DWORD PTR DS:[6FBCD050]
 		// Manage mouse up
-		mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3);
+		mem_seek R8(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, BDE33, C05D3, A7963);
-		memt_byte( 0xA1, 0xE8 );
+        if (version_D2Client == V114d) {
-		MEMT_REF4( ptptClientChar, caller_statsPageMouseUp);
+            MEMT_REF4(0xFFFBC469, caller_statsPageMouseUp_114);
        } else {
            memt_byte(0xA1, 0xE8);
            MEMT_REF4(ptptClientChar, caller_statsPageMouseUp);
        }
 		//6FB33853   . A1 F0C4BC6F    MOV EAX,DWORD PTR DS:[6FBCC4F0]
 		//6FB3A2D3   . A1 E0C1BC6F    MOV EAX,DWORD PTR DS:[6FBCC1E0]
 		//6FB1C233   . A1 D0C3BC6F    MOV EAX,DWORD PTR DS:[6FBCC3D0]
@ -307,12 +363,12 @@ void Install_InterfaceStats()
 		//6FB705D3   . A1 50D0BC6F    MOV EAX,DWORD PTR DS:[6FBCD050]
 	} else {
 		// Manage mouse down (Play sound)
-		mem_seek R7(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, 0000, 0000);
+		mem_seek R8(D2Client, 2AA6D, 2AA5D, 3133D, 827C8, 89248, 6B1A8, 0000, 0000, 0000);
 		MEMC_REF4( D2GetClientPlayer, caller_statsPageMouseDown);
 		//6FAD133C   . E8 8F700500    CALL D2Client.6FB283D0
 		// Manage mouse up
-		mem_seek R7(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, 0000, 0000);
+		mem_seek R8(D2Client, 2AC43, 2AC33, 3151A, 83853, 8A2D3, 6C233, 0000, 0000, 0000);
 		MEMC_REF4( D2GetClientPlayer, version_D2Client == V110 ? caller_statsPageMouseUp : caller_statsPageMouseUp_9);//0x00056EB2
 		//6FAD1519   . E8 B26E0500    CALL D2Client.6FB283D0
 	}
--- a/PlugY/Language.cpp
+++ b/PlugY/Language.cpp
@ -36,10 +36,10 @@ void Install_LanguageManagement()
 	log_msg("Patch D2Lang for language management. (LanguageManagement)\n");
-	ptCurrentLanguage = *(DWORD**)((DWORD)D2GetLang + (version_D2Lang >= V111 ? 0x51: 0x5C));
+	ptCurrentLanguage = *(DWORD**)((DWORD)D2GetLang + (version_D2Lang == V114d ? 0x5F : version_D2Lang >= V111 ? 0x51: 0x5C));
 	// Language management
-	mem_seek( (DWORD)D2GetLang + (version_D2Lang >= V111 ? 0x3E : 0x49));//6FC13E39-6FC10000
+	mem_seek( (DWORD)D2GetLang + (version_D2Lang == V114d ? 0x4C : version_D2Lang >= V111 ? 0x3E : 0x49));//6FC13E39-6FC10000
 	memt_byte( 0xA1 , 0xE8);
 	MEMT_REF4( ptCurrentLanguage, languageManagement);
 	//6FC13E39  |. A1 EC0CC26F    MOV EAX,DWORD PTR DS:[6FC20CEC]
--- a/PlugY/LoadPlayerData.cpp
+++ b/PlugY/LoadPlayerData.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
  Load Player Custom Data.
@ -51,6 +52,20 @@ DWORD STDCALL LoadSPCustomData(Unit* ptChar)
 	return ret;
 }
 FCT_ASM( caller_LoadSPPlayerCustomData_114 )
    MOV EDI, EAX
    TEST EDI, EDI
    JNZ JMP_LoadSPPlayerCustomData
    PUSH DWORD PTR SS : [ESP + 0x1C]
    CALL LoadSPCustomData
    MOV EDI, EAX
    TEST EDI, EDI
    JNZ JMP_LoadSPPlayerCustomData
    RETN
 JMP_LoadSPPlayerCustomData :
    ADD DWORD PTR SS : [ESP], 0x14
    RETN
 }}
 FCT_ASM (caller_LoadSPPlayerCustomData )
 	MOV ESI,EAX
@ -186,6 +201,8 @@ void FASTCALL SendSaveFiles (char* ptPath, DWORD maxsize, char* name)
 	log_msg("\n--- Start SendSaveFiles ---\n");
    log_msg("path = %s\n\nmaxsize = %d\n\nname = %s\n\n", ptPath, maxsize, name);
 	// Send Extended Save File
 	log_msg("Send Extended Save File\n");
 	dataExtended = readExtendedSaveFile(name, &sizeExtended);
@ -350,7 +367,20 @@ DWORD STDCALL LoadMPCustomData(Unit* ptChar)
 	return ret;
 }
-
+FCT_ASM( caller_LoadMPPlayerCustomData_114 )
    PUSH DWORD PTR SS : [EDI]
    CALL LoadMPCustomData
    TEST EAX, EAX
    JNZ JMP_LoadMPlayerCustomData
    CMP DWORD PTR DS : [EDI], 0
    JNZ Continue_LoadMP
    ADD DWORD PTR SS : [ESP], 0x1D
 Continue_LoadMP :
 RE  TN
 JMP_LoadMPlayerCustomData :
    SUB DWORD PTR SS : [ESP], 0x10
    RETN
 }}
 FCT_ASM ( caller_LoadMPPlayerCustomData_111 )
 	PUSH DWORD PTR SS:[EBX]
@ -413,7 +443,18 @@ FCT_ASM ( caller_SendSaveFiles )
 	JMP SendSaveFiles
 }}
-
+FCT_ASM( caller_ReceiveSaveFiles_114 )
    PUSH ECX
    PUSH EDX
    LEA EBX, DWORD PTR DS : [ESI + 4]
    PUSH EBX		//Message
    MOV EBX, DWORD PTR SS : [ESI]
    PUSH EBX		//ID client
    CALL ReceiveSaveFiles
    POP EDX
    POP ECX
    RETN
 }}
 FCT_ASM ( caller_ReceiveSaveFiles_111 )
 	PUSH ECX
@ -475,10 +516,10 @@ void Install_LoadPlayerData()
 	log_msg("Patch D2Game & D2Client for load Player's custom data. (LoadPlayerData)\n");
 	// Load SP player custom data.
-	mem_seek R7(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D, 3BCCD);
+	mem_seek R8(D2Game, 5046F, 5086F, 5CB0F, BB8ED, 278CD, 465BD, 5638D, 3BCCD, 13447A);
 	memt_byte( 0x8B, 0xE8); // CALL caller_LoadSPPlayerCustomData
-	MEMT_REF4( 0x75F685F0 , caller_LoadSPPlayerCustomData);
+	MEMT_REF4( version_D2Game == V114d ? 0x75FF85F8 : 0x75F685F0 , version_D2Game == V114d ? caller_LoadSPPlayerCustomData_114 : caller_LoadSPPlayerCustomData);
-	memt_byte( 0x16, 0x90); // NOP
+	memt_byte( version_D2Game == V114d ? 0x13 : 0x16, 0x90); // NOP
 	//6FC8CB0F   8BF0             MOV ESI,EAX
 	//6FC8CB11   85F6             TEST ESI,ESI
 	//6FC8CB13   75 16            JNZ SHORT D2Game.6FC8CB2B
@ -499,9 +540,9 @@ void Install_LoadPlayerData()
 	//6FC5BCD1  |. 75 16          JNZ SHORT D2Game.6FC5BCE9
 	// Load MP player custom data.
-	mem_seek R7(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217, 3BB57);
+	mem_seek R8(D2Game, 50790, 50B90, 5CC66, BB777, 27757, 46447, 56217, 3BB57, 134572);
 	memt_byte( 0x83, 0xE8);
-	MEMT_REF4( version_D2Game >= V111 ? 0x2174003B : version_D2Game == V110 ? 0x4674003F : 0x1D74003F, version_D2Game >= V111 ? caller_LoadMPPlayerCustomData_111 : version_D2Game == V110 ? caller_LoadMPPlayerCustomData: caller_LoadMPPlayerCustomData_9);
+    MEMT_REF4( version_D2Game == V114d ? 0x1D74003F : version_D2Game >= V111 ? 0x2174003B : version_D2Game == V110 ? 0x4674003F : 0x1D74003F, version_D2Game == V114d ? caller_LoadMPPlayerCustomData_114 : version_D2Game >= V111 ? caller_LoadMPPlayerCustomData_111 : version_D2Game == V110 ? caller_LoadMPPlayerCustomData: caller_LoadMPPlayerCustomData_9);
 	//6FC8CC66  . 833F 00         CMP DWORD PTR DS:[EDI],0
 	//6FC8CC69  . 74 46           JE SHORT D2Game.6FC8CCB1
 	//0203B777  |> 833B 00        CMP DWORD PTR DS:[EBX],0
@ -516,8 +557,13 @@ void Install_LoadPlayerData()
 	//6FC5BB5A  |. 74 21          JE SHORT D2Game.6FC5BB7D
 	// Send save files to Server.
-	mem_seek R7(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C, B638C);
+	mem_seek R8(D2Client, CF42, CF32, D5A2, 733FC, 5DFDC, 7933C, 1457C, B638C, 7807E);
-	MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SendSaveFiles_111 : caller_SendSaveFiles);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0xFFF8EFCE, caller_SendSaveFiles_111);
    } else {
        MEMJ_REF4(D2FogGetSavePath, version_D2Game >= V111 ? caller_SendSaveFiles_111 : caller_SendSaveFiles);
    }
    //6FAAD5A1  |. E8 88D10B00    CALL <JMP.&Fog.#10115>
 	//6FB233FB  |. E8 CA8AF9FF    CALL <JMP.&Fog.#10115>
 	//6FB0DFDB  |. E8 C6DEFAFF    CALL <JMP.&Fog.#10115>
@ -526,9 +572,12 @@ void Install_LoadPlayerData()
 	//6FB6638B  |. E8 2E5BF5FF    CALL <JMP.&Fog.#10115>
 	// Receive save files from client.
-	mem_seek R7(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39, D53E9);
+	mem_seek R8(D2Game, 183A, 183A, 191A, 376E9, 703D9, 624D9, CAF39, D53E9, 13F114);
 	memt_byte( 0x8B ,0xE8);
-	if ( version_D2Game >= V111 ) {
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x46B60F1E, caller_ReceiveSaveFiles_114);
        memt_byte(0x04, 0x90);
    } else if ( version_D2Game >= V111 ) {
 		MEMT_REF4( 0xB60F005D, caller_ReceiveSaveFiles_111);
 		memt_byte( 0x45 ,0x90);
 		memt_byte( 0x04 ,0x90);
@ -550,7 +599,7 @@ void Install_LoadPlayerData()
 	if ( version_Fog <= V109d )
 	{
-		mem_seek R7(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(Fog, 47DE, 45AE, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x8B ,0xE8);
 		MEMT_REF4( 0x891C2444, version_Fog == V109b? caller_BugFix109b : caller_BugFix109d);
 		memt_byte( 0x44 ,0x90);
--- a/PlugY/MainScreen.cpp
+++ b/PlugY/MainScreen.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
    Print PlugY version on screen.
@ -34,6 +35,30 @@ void STDCALL printPlugYVersion(void** childrens, DWORD* sgnNumChildren)
 	}
 }
 void STDCALL printPlugYVersion114()
 {
    if (active_Windowed)
        SetWindowedOptions();
    if (active_PrintPlugYVersion)
    {
        char buf[20];
        void* textbox = D2CreateTextBox(newTextBoxData);
        void** childrens = (void**)0x779350;
        DWORD* sgnNumChildren = (DWORD*)0x779944;
        childrens[*sgnNumChildren] = textbox;
        d2_assert((*sgnNumChildren)++ >= 40, "sgnNumChildren < MAX_CHILDREN", __FILE__, __LINE__);
        sprintf(buf, "PlugY %s", PLUGY_VERSION);
        D2PrintLineOnTextBox(textbox, buf, colorOfPlugYVersion);
    }
 }
 FCT_ASM( caller_printPlugYVersion114 )
  POP ESI
  CALL printPlugYVersion114
  MOV ECX, 0x115
  JMP ESI
 }}
 FCT_ASM ( caller_printPlugYVersion )
 	POP ESI
 	PUSH DWORD PTR [ESI+2]
@ -51,9 +76,14 @@ void Install_PrintPlugYVersion()
 	log_msg("Patch D2Launch to print PlugY version. (PrintPlugYVersion)\n");
    if (version_D2Launch == V114d) {
        mem_seek R8(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11, 33798);
        memt_byte(0xB9, 0xE8);
        MEMT_REF4(0x00000115, caller_printPlugYVersion114);
    } else {
        // Print PlugY version.
-	mem_seek R7(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11);
+        mem_seek R8(D2Launch, 7F5D, 7F7D, 9639, 117C7, 178A7, 16AF7, 18061, 10A11, 10A11);
-	MEMJ_REF4( D2CreateTextBox, caller_printPlugYVersion);
+        MEMJ_REF4(D2CreateTextBox, caller_printPlugYVersion);
        //6FA19638  |. E8 1BED0000    CALL <JMP.&D2Win.#10017>
        //6FA517C6  |. E8 6F81FFFF    CALL <JMP.&D2Win.#10147>
        //6FA578A6  |. E8 D71FFFFF    CALL <JMP.&D2Win.#10113>
@ -61,6 +91,7 @@ void Install_PrintPlugYVersion()
        //6FA56AF6  |. E8 432EFFFF    CALL <JMP.&D2Win.#10098>
        //6FA58060  |. E8 ED18FFFF    CALL <JMP.&D2Win.#10098>
        //6FA50A10  |. E8 218FFFFF    CALL <JMP.&D2Win.#10164>
  }
 	log_msg("\n");
@ -83,6 +114,12 @@ FCT_ASM ( caller_VersionChange_10 )
 	RETN
 }}
 FCT_ASM(caller_VersionChange_114)
    MOV EDX, versionText
    MOV ECX, ESI
    RETN
 }}
 void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
 {
 	static int isInstalled = false;
@ -96,9 +133,14 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
 	// Print LoD/Mod version.
-	if (version_D2Launch >= V110)
+    if (version_D2Launch == V114d) {
        mem_seek R8(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4, 337EA);//6FA19721-6FA10000
        memt_byte(0x8D, 0xE8);	// CALL
        MEMT_REF4(0xCE8BC055, caller_VersionChange_114);
        //memt_byte(0xCE, 0x90);	// NOP
    } else if (version_D2Launch >= V110)
 	{
-		mem_seek R7(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4);//6FA19721-6FA10000
+		mem_seek R8(D2Launch, 00000, 00000, 9723, 1189B, 1797B, 16BCB, 18134, 10AE4, 10AE4);//6FA19721-6FA10000
 		memt_byte( 0x8D, 0xE8 );	// CALL
 		MEMT_REF4( 0x8B102454 , caller_VersionChange_10);
 		memt_byte( 0xCF, 0x90 );	// NOP
@ -115,7 +157,7 @@ void Install_VersionChange()// BUG WITH 2MOD if D2Mod started before PlugY ????
 		//6FA50AE4  |. 8D5424 10      LEA EDX,DWORD PTR SS:[ESP+10]
 		//6FA50AE8  |. 8BCF           MOV ECX,EDI
 	} else {
-		mem_seek R7(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B, 10AEB);
+		mem_seek R8(D2Launch, 801B, 803B, 972A, 118A2, 17982, 16BD2, 1813B, 10AEB, 10AEB);
 		MEMJ_REF4( D2PrintLineOnTextBox, versionChange);
 		//6FA19729  |. E8 88EB0000    CALL <JMP.&D2Win.#10046>
 		//6FA518A1  |. E8 267FFFFF    CALL <JMP.&D2Win.#10061>
--- a/PlugY/NewInterface_StatsPageTwo.cpp
+++ b/PlugY/NewInterface_StatsPageTwo.cpp
@ -11,6 +11,10 @@
 #include "newInterfaces.h"
 #include "common.h"
 #include <stdio.h>
 #include <fstream>
 #include <string>
 #include <vector>
 #include <sstream>
 #define	getXCloseBtn()			RX(0x110)
 #define	getLCloseBtn()			32
@ -61,6 +65,62 @@ extern int lastPage;
 int nbStatsInterface;
 statsInterfaceBIN* statsInterface;
 void loadStatsInterfaceDesc_114() {
    char filename[0x104];
    strcpy(filename, "PlugY\\statsinterface.txt");
    char fileTemp[0x104];
    log_msg("Load custom file : %s", filename);
    strcpy(fileTemp, filename);
    D2FogGetInstallPath(filename, 0x104 - strlen(filename));
    strcat(filename, fileTemp);
    log_msg("-> %s\n", filename);
    std::ifstream statsFile(filename);
    std::vector<std::string> stats;
    if (statsFile.is_open()) {
        std::string line;
        while (std::getline(statsFile, line)) {
            if (line.length() > 0 && line[0] != '*') {
                //log_msg("Loading stat:\n");
                //log_msg("%s\n\n", line);
                stats.push_back(line);
            }
        }
    } else {
        log_msg("FAILED TO OPEN FILE: %s", filename);
    }
    statsFile.close();
    nbStatsInterface = stats.size();
    statsInterface = new statsInterfaceBIN[nbStatsInterface];
    for (int i = 0; i < nbStatsInterface; ++i) {
        std::istringstream ss(stats[i]);
        auto& stat = statsInterface[i];
        std::string token = "";
        std::getline(ss, token, '\t');
        //log_msg("Stat (%u) %s\n", i, token.c_str());
        std::getline(ss, token, '\t');
        stat.enabled = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tenabled = %u\n", stat.enabled);
        std::getline(ss, token, '\t');
        stat.page = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tpage = %u\n", stat.page);
        std::getline(ss, token, '\t');
        stat.x = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tx = %u\n", stat.x);
        std::getline(ss, token, '\t');
        stat.y = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\ty = %u\n", stat.y);
        std::getline(ss, token, '\t');
        stat.color = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tcolor = %u\n", stat.color);
        std::getline(ss, token, '\t');
        stat.font = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tfont = %u\n", stat.font);
        std::getline(ss, token, '\t');
        stat.statsID = token.length() == 0 ? 0 : std::stoi(token.c_str());
        //log_msg("\tstatsID = %u\n", stat.statsID);
    }
 }
 void loadStatsInterfaceDesc(DWORD mempool)
 {
 	log_msg("loadStatsInterfaceDesc(%d)\n",mempool);
@ -75,7 +135,15 @@ void loadStatsInterfaceDesc(DWORD mempool)
 //	ADD_LOOKUP_WORD(10,	"stat", lookupItemStatCost);
 	ADD_WORD_FIELD(12,	"statID");
 	ADD_TERM_FIELD();
    //log_msg("statsInterface=0x%08x\nnbStatsInterface=0x%08x\n", statsInterface, &nbStatsInterface);
    //void* test = D2ReadFile(mempool, "PlugY\\statsinterface.txt", (DWORD*)nbStatsInterface, __FILE__, __LINE__);
    //void* test = D2CompileTxtFile(mempool, "PlugY\\statsinterface.txt", TableDesc, (DWORD*)&nbStatsInterface, sizeof(statsInterfaceBIN));
    //log_msg("D2CompileTxtFile()=0x%08x", test);
    if (version_D2Game == V114d) {
        loadStatsInterfaceDesc_114();
    } else {
        BUILD_BIN(statsInterfaceBIN, statsInterface, nbStatsInterface, "PlugY\\statsinterface.txt");
    }
 	lastPage = 0;
 	for (i=0; i<nbStatsInterface; i++)
@ -89,7 +157,12 @@ void freeStatsInterfaceDesc()
 	if (statsInterface)
 	{
-		D2FogMemDeAlloc(statsInterface,__FILE__,__LINE__,0);
+    if (version_D2Game == V114d) {
        delete[] statsInterface;
    }
    else {
        D2FogMemDeAlloc(statsInterface, __FILE__, __LINE__, 0);
    }
 		statsInterface = NULL;
 		nbStatsInterface = 0;
 	}
--- a/PlugY/NewInterfaces.cpp
+++ b/PlugY/NewInterfaces.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Interface functions
@ -56,6 +57,9 @@ int GetCurrentPage()
 void STDCALL printCustomPage()
 {
 	if(onRealm) {D2PrintStatsPage();return;}
    //printNewStatsPageTwo(selectedPage); return;
 	if ( (selectedPage > 0) && (selectedPage<=lastPage) )
 		printNewStatsPageTwo(selectedPage);
 	else if (selectedPage == lastPage+1)
@ -92,6 +96,18 @@ DWORD STDCALL mouseCustomPageLeftUp(sWinMessage* msg)
 		return -1;
 }
 FCT_ASM( caller_DontPrintBorder_114 )
    MOV ESI, bDontPrintBorder
    TEST ESI, ESI
    JE printBorder
    MOV bDontPrintBorder, 0
    ADD DWORD PTR SS : [ESP], 0x14F
    RETN
 printBorder :
    MOV ESI, DWORD PTR DS : [0x7BEF18]
    RETN
 }}
 FCT_ASM ( caller_DontPrintBorder_111 )
 	MOV ECX,bDontPrintBorder
 	TEST ECX,ECX
@ -116,6 +132,30 @@ printBorder:
 	RETN
 }}
 FCT_ASM(caller_mouseCustomPageLeftDown_114)
    PUSH EAX
    PUSH ESI
    CALL mouseCustomPageLeftDown
    TEST EAX, EAX
    POP EAX
    JE end_mouseNewPageLDown
    ;JG continue_mouseNewPageLDown
    LEA ECX, DWORD PTR DS : [EAX + 0x80]
    RETN
 continue_mouseNewPageLDown :
    POP EAX
    ADD EAX, 0x170
    PUSH 0x4A7720
    JMP EAX
    RETN
 end_mouseNewPageLDown :
    POP EDI
    POP ESI
    POP EBX
    POP EBP
    RETN 4
 }}
 FCT_ASM ( caller_mouseCustomPageLeftDown_111 )
 	PUSH EAX
@ -185,7 +225,27 @@ end_mouseNewPageLDown:
 	RETN 4
 }}
-
+FCT_ASM(caller_mouseCustomPageLeftUp_114)
    PUSH EBP
    CALL mouseCustomPageLeftUp
    TEST EAX, EAX
    JE end_mouseNewPageLUp
    ;JG continue_mouseNewPageLUp
    MOV EAX, DWORD PTR DS : [ptWindowStartX]
    MOV EAX, DWORD PTR DS : [EAX]
    RETN
 continue_mouseNewPageLUp :
    ADD DWORD PTR SS : [ESP], 0x2C4
    RETN
 end_mouseNewPageLUp :
    ADD ESP, 4
    POP EDI
    POP ESI
    POP EBX
    MOV ESP, EBP
    POP EBP
    RETN 4
 }}
 FCT_ASM ( caller_mouseCustomPageLeftUp_111 )
 	PUSH EBP
@ -257,7 +317,11 @@ end_mouseNewPageLUp:
-
+FCT_ASM( caller_resetSelectedPageByToolBar_114 )
    MOV selectedPage, 0
    MOV EDX, 2
    RETN
 }}
 FCT_ASM ( caller_resetSelectedPageByToolBar )
@ -269,6 +333,13 @@ noJump:
 	RETN
 }}
 FCT_ASM( caller_resetSelectedPageByKey_114 )
    MOV selectedPage, 0
    MOV EDX, DWORD PTR DS : [ECX * 4 + 0x712698]
    RETN
 }}
 FCT_ASM ( caller_resetSelectedPageByKey )
 	MOV selectedPage,0
 	POP EAX
@ -308,10 +379,10 @@ void Install_NewInterfaces()
 	{
 		if ( version_D2Client >= V111 )
 		{
-			//Reset selectedPage variable on opening stats page
+			// Reset selectedPage variable on opening stats page
-			mem_seek R7(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E, C41FE);
+			mem_seek R8(D2Client, 0000, 0000, 0000, 4B79E, 8F73E, 55E0E, 65F5E, C41FE, 7EC7A);
-			memt_byte( 0x83, 0xE8 );	// CALL caller_resetSelectedPage
+			memt_byte( version_D2Client == V114d ? 0xBA : 0x83, 0xE8 );	// CALL caller_resetSelectedPage
-			MEMT_REF4( 0x1F7426F8, caller_resetSelectedPageByToolBar);
+			MEMT_REF4( version_D2Client == V114d ? 0x00000002 : 0x1F7426F8, version_D2Client == V114d ? caller_resetSelectedPageByToolBar_114 : caller_resetSelectedPageByToolBar);
 			//6FAFB79E   > 83F8 26        CMP EAX,26
 			//6FAFB7A1   . 74 1F          JE SHORT D2Client.6FAFB7C2
 			//6FB3F73E   > 83F8 26        CMP EAX,26
@ -323,9 +394,17 @@ void Install_NewInterfaces()
 			//6FB741FE   > 83F8 26        CMP EAX,26
 			//6FB74201   . 74 1F          JE SHORT D2Client.6FB05E32
-			mem_seek R7(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA, 3E39A);
+			mem_seek R8(D2Client, 0000, 0000, 0000, 1E55A, 6A8FA, A31DA, 3C5EA, 3E39A, 6A91D);
-			memt_byte( 0x55, 0xE8 );	// CALL caller_resetSelectedPage
+            if (version_D2Client == V114d) {
-			MEMT_REF4( 0xD53BED33, caller_resetSelectedPageByKey);
+                memt_byte(0x8B, 0x90);
                memt_byte(0x14, 0x90);
                memt_byte(0x8D, 0xE8);
                MEMT_REF4(0x00712698, caller_resetSelectedPageByKey_114);
            }
            else {
                memt_byte(0x55, 0xE8);	// CALL caller_resetSelectedPage
                MEMT_REF4(0xD53BED33, caller_resetSelectedPageByKey);
            }
 			//6FACE55A   . 55             PUSH EBP
 			//6FACE55B   . 33ED           XOR EBP,EBP
 			//6FACE55D   . 3BD5           CMP EDX,EBP
@ -358,7 +437,7 @@ void Install_NewInterfaces()
 			//6FB3EF92  |. 3928           CMP DWORD PTR DS:[EAX],EBP
 		} else {
 			//Reset selectedPage variable on opening stats page
-			mem_seek R7(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000, 0000);//((DWORD)D2TogglePage+0x218);
+			mem_seek R8(D2Client, 88B58, 87ED8, 83478, A1FBE, 6571E, 8EF8E, 0000, 0000, 0000);//((DWORD)D2TogglePage+0x218);
 			memt_byte( 0x85, 0xE8 );	// CALL caller_resetSelectedPage
 			MEMT_REF4( 0xC2940FC0, caller_resetSelectedPage);
 			//6FB23478  |. 85C0           TEST EAX,EAX
@ -368,8 +447,12 @@ void Install_NewInterfaces()
 	}
 	// Print custom page
-	mem_seek R7(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49, 1D549);
+	mem_seek R8(D2Client, 87697, 86A17, 81FAB, A3759, 66B59, 902B9, C3B49, 1D549, 57052);
-	MEMC_REF4( D2PrintStatsPage, printCustomPage);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x00050CAA, printCustomPage);
    } else {
        MEMC_REF4(D2PrintStatsPage, printCustomPage);
    }
 	//6FB21FAA   . E8 B1DDFAFF    CALL D2Client.6FACFD60
 	//6FB53758   . E8 43F1FDFF    CALL D2Client.6FB328A0
 	//6FB16B58  |. E8 C3270200    CALL D2Client.6FB39320
@ -378,9 +461,10 @@ void Install_NewInterfaces()
 	//6FACD548  |. E8 F3200A00    CALL D2Client.6FB1B280
 	// Don't print Border
-	mem_seek R7(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6, 6D2B6);
+	mem_seek R8(D2Client, 58EF6, 58EF6, 5F4C6, 2D366, B5A46, 82166, 271C6, 6D2B6, 98707);
-	memt_byte( 0xB9, 0xE8 );	// CALL caller_DontPrintBorder
+	memt_byte( version_D2Client == V114d ? 0x8B : 0xB9, 0xE8 );	// CALL caller_DontPrintBorder
-	MEMT_REF4( 0x00000012, version_D2Client >= V111 ? caller_DontPrintBorder_111 : caller_DontPrintBorder);
+	MEMT_REF4( version_D2Client == V114d ? 0x7BEF1835 : 0x00000012, version_D2Client == V114d ? caller_DontPrintBorder_114 : version_D2Client >= V111 ? caller_DontPrintBorder_111 : caller_DontPrintBorder);
    if (version_D2Client == V114d) memt_byte(0x00, 0x90);
    //6FAFF4C6   > B9 12000000    MOV ECX,12
 	//6FADD366  |. B9 12000000    MOV ECX,12
 	//6FB65A46  |. B9 12000000    MOV ECX,12
@ -389,9 +473,9 @@ void Install_NewInterfaces()
 	//6FB1D2B6  |. B9 12000000    MOV ECX,12
 	// Manage mouse down (Play sound)
-	mem_seek R7(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6);
+	mem_seek R8(D2Client, 2A9DC, 2A9CC, 312A5, 82736, 891B6, 6B116, BCD36, BF4D6, A7731);
 	memt_byte( 0x8D, 0xE8 );	// CALL
-	MEMT_REF4( 0x00008088, version_D2Client >= V111 ? caller_mouseCustomPageLeftDown_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftDown : caller_mouseCustomPageLeftDown_9);
+	MEMT_REF4( 0x00008088, version_D2Client == V114d ? caller_mouseCustomPageLeftDown_114 : version_D2Client >= V111 ? caller_mouseCustomPageLeftDown_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftDown : caller_mouseCustomPageLeftDown_9);
 	memt_byte( 0x00, 0x90 );	// NOP
 	//6FAD12A5   . 8D88 80000000     LEA ECX,DWORD PTR DS:[EAX+80]
 	//6FB32736   . 8D88 80000000     LEA ECX,DWORD PTR DS:[EAX+80]
@ -401,9 +485,9 @@ void Install_NewInterfaces()
 	//6FB6F4D6   . 8D88 80000000     LEA ECX,DWORD PTR DS:[EAX+80]
 	// Manage mouse up
-	mem_seek R7(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459);
+	mem_seek R8(D2Client, 2ABBB, 2ABAB, 3148D, 836D9, 8A159, 6C0B9, BDCB9, C0459, A78DA);
 	memt_byte( 0xA1, 0xE8 );	// CALL caller_mouseCustomPageLeftUp
-	MEMT_REF4( ptWindowStartX, version_D2Client >= V111 ? caller_mouseCustomPageLeftUp_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftUp : caller_mouseCustomPageLeftUp_9);
+	MEMT_REF4( ptWindowStartX, version_D2Client == V114d ? caller_mouseCustomPageLeftUp_114 : version_D2Client >= V111 ? caller_mouseCustomPageLeftUp_111 : version_D2Client == V110 ? caller_mouseCustomPageLeftUp : caller_mouseCustomPageLeftUp_9);
 	//6FAD148D   . A1 48A7BB6F       MOV EAX,DWORD PTR DS:[6FBBA748]
 	//6FB336D9   . A1 24BDBC6F       MOV EAX,DWORD PTR DS:[6FBCBD24]
 	//6FB3A159   . A1 F8BEBC6F       MOV EAX,DWORD PTR DS:[6FBCBEF8]
--- a/PlugY/Parameters.cpp
+++ b/PlugY/Parameters.cpp
@ -170,6 +170,7 @@ const char* S_active_EnabledTXTFilesWithMSExcel= "EnabledTXTFilesWhenMSExcelOpen
 const char* S_active_DisplayBaseStatsValue = "ActiveDisplayBaseStatsValue";
 const char* S_active_LadderRunewords = "ActiveLadderRunewords";
 const char* S_active_EnabledCowPortalWhenCowKingWasKill = "ActiveCowPortalWhenCowKingWasKilled";
 const char* S_active_DoNotCloseNihlathakPortal = "ActiveDoNotCloseNihlathakPortal";
 const char* S_DLL = "DLL:\t";
 const char* S_DEFAULT = "DEFAULT:";
@ -819,6 +820,10 @@ void init_ExtraOptions(INIFile* iniFile, INIFile* iniFixedFile, INIFile* iniDefa
 	GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_EnabledCowPortalWhenCowKingWasKill, "0");
 	active_EnabledCowPortalWhenCowKingWasKill = atoi(buffer);
 	log_msg("active_EnabledCowPortalWhenCowKingWasKill= %u\n\n", active_EnabledCowPortalWhenCowKingWasKill);
    GET_PRIVATE_PROFILE_STRING(S_EXTRA, S_active_DoNotCloseNihlathakPortal, "0");
    active_DoNotCloseNihlathakPortal = atoi(buffer);
    log_msg("active_DoNotCloseNihlathakPortal= %u\n\n", active_DoNotCloseNihlathakPortal);
 }
--- a/PlugY/PlayerCustomData.cpp
+++ b/PlugY/PlayerCustomData.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Adding custom data.
 	Save and load infinity & shared Stash
@ -172,6 +173,22 @@ void FASTCALL updateItem_111(Unit* ptItem, Unit* ptChar)
 	}
 }
 FCT_ASM( caller_updateItem_114 )
    PUSH EAX
    MOV EAX, 0x552F60
    CALL EAX
    PUSH EAX
    PUSH ECX
    PUSH EDX
    MOV ECX, EAX
    MOV EDX, EDI
    CALL updateItem_111
    POP EDX
    POP ECX
    POP EAX
    RETN 4
 }}
 FCT_ASM ( caller_updateItem_111 )
 	MOV ECX,ESI
 	MOV EDX,EBP
@ -182,6 +199,22 @@ FCT_ASM ( caller_updateItem_111 )
 	JMP EAX
 }}
 FCT_ASM( caller_updateItemB_114 )
    PUSH EAX
    MOV EAX, 0x552F60
    CALL EAX
    PUSH EAX
    PUSH ECX
    PUSH EDX
    MOV ECX, EAX
    MOV EDX, EDI
    CALL updateItem_111
    POP EDX
    POP ECX
    POP EAX
    RETN 4
 }}
 FCT_ASM ( caller_updateItemB_111 )
 	MOV EDX,EBP
 	CALL updateItem_111
@ -205,6 +238,16 @@ FCT_ASM ( caller_updateItem_9 )
 	RETN 4
 }}
 FCT_ASM( caller_updateClientPlayerOnLoading_114 )
    PUSH DWORD PTR SS : [ESP + 0x14]
    CALL updateClientPlayerOnLoading
    POP ECX
    POP EDI
    POP ESI
    XOR EAX, EAX
    POP EBX
    JMP ECX
 }}
 FCT_ASM ( caller_updateClientPlayerOnLoading )
 	PUSH DWORD PTR SS:[ESP+0x14]
@ -217,6 +260,13 @@ FCT_ASM ( caller_updateClientPlayerOnLoading )
 	JMP ECX
 }}
 FCT_ASM( callerServer_getNextItemToFree_114 )
    PUSH DWORD PTR SS : [ESP + 4]
    PUSH DWORD PTR SS : [ESP + 0x10]
    CALL getNextItemToFree
    RETN 4
 }}
 FCT_ASM ( callerServer_getNextItemToFree_111 )
 	PUSH DWORD PTR SS:[ESP+4]
 	PUSH DWORD PTR SS:[ESP+0x30]
@ -238,6 +288,12 @@ FCT_ASM ( callerServer_getNextItemToFree_9 )
 	RETN 4
 }}
 FCT_ASM( callerClient_getNextItemToFree_114 )
    PUSH DWORD PTR SS : [ESP + 4]
    PUSH DWORD PTR SS : [ESP + 0xC]
    CALL getNextItemToFree
    RETN 4
 }}
 FCT_ASM ( callerClient_getNextItemToFree_111 )
 	PUSH DWORD PTR SS:[ESP+4]
@ -273,8 +329,12 @@ void Install_PlayerCustomData()
 	log_msg("Patch D2Game & D2Client & D2Common for Player's custom data. (PlayerCustomData)\n");
 	// Initialize custom data.
-	mem_seek(version_D2Client == V113d ? offset_D2Common + 0x170DE : version_D2Client == V113c ?  offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 );
+	mem_seek(version_D2Client == V114d ? offset_D2Common + 0x221FDD : version_D2Client == V113d ? offset_D2Common + 0x170DE : version_D2Client == V113c ?  offset_D2Common + 0x309BE : version_D2Client == V112 ? offset_D2Common + 0x585EE : version_D2Client == V111b ? offset_D2Common + 0x5BFCE : version_D2Common == V111 ? offset_D2Common + 0x4ED5E :(DWORD)D2InitPlayerData + 0x62 );
-	MEMJ_REF4( D2AllocMem, init_PlayerCustomData);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0xFFDE944F, init_PlayerCustomData);
    } else {
        MEMJ_REF4(D2AllocMem, init_PlayerCustomData);
    }
 	//01BD0381  |. E8 C03F0000    CALL <JMP.&Fog.#10045>
 	//6FD9ED5D  |. E8 94A4FBFF    CALL <JMP.&Fog.#10045>
 	//6FDABFCD  |. E8 34D2FAFF    CALL <JMP.&Fog.#10045>
@ -285,9 +345,13 @@ void Install_PlayerCustomData()
 	if ( version_D2Game >= V111 )
 	{
 		// update item
-		mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91, 75C81);
+		mem_seek R8(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 9BB91, 75C81, 1978F3);
-		memt_byte( 0x8B ,0xE8); // CALL
+        if (version_D2Game == V114d) {
-		MEMT_REF4( 0x52182454, caller_updateItem_111);
+            MEMT_REF4(0xFFFBB669, caller_updateItem_114);
        } else {
            memt_byte(0x8B, 0xE8); // CALL
            MEMT_REF4(0x52182454, caller_updateItem_111);
        }
 		//0200BC71  |> 8B5424 18      |MOV EDX,DWORD PTR SS:[ESP+18]
 		//0200BC75  |. 52             |PUSH EDX                                ; /Arg1
 		//02023C51  |> 8B5424 18      |MOV EDX,DWORD PTR SS:[ESP+18]
@ -299,9 +363,13 @@ void Install_PlayerCustomData()
 		//6FC95C81  |> 8B5424 18      |MOV EDX,DWORD PTR SS:[ESP+18]
 		//6FC95C85  |. 52             |PUSH EDX
-		mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1, 75CE1);
+		mem_seek R8(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 9BBF1, 75CE1, 197943);
-		memt_byte( 0x8B ,0xE8); // CALL
+        if (version_D2Game == V114d) {
-		MEMT_REF4( 0x52182454, caller_updateItemB_111);
+            MEMT_REF4(0xFFFBB619, caller_updateItemB_114);
        } else {
            memt_byte(0x8B, 0xE8); // CALL
            MEMT_REF4(0x52182454, caller_updateItemB_111);
        }
 		//0200BCD1  |> 8B5424 18      ||MOV EDX,DWORD PTR SS:[ESP+18]
 		//0200BCD5  |. 52             ||PUSH EDX                               ; /Arg1
 		//02023CB1  |> 8B5424 18      ||MOV EDX,DWORD PTR SS:[ESP+18]
@ -315,18 +383,23 @@ void Install_PlayerCustomData()
 	} else {
 		// update item
-		mem_seek R7(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000, 0000);
+		mem_seek R8(D2Game, 10933, 10C03, 1100D, 8BC71, C3C51, 5F2A1, 0000, 0000, 0000);
 		MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9);
 		//6FC4100C  |. E8 EFAA0700    |CALL D2Game.6FCBBB00
-		mem_seek R7(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000, 0000);
+		mem_seek R8(D2Game, 1097B, 10C4B, 11058, 8BCD1, C3CB1, 5F301, 0000, 0000, 0000);
 		MEMC_REF4( D2GameGetObject, version_D2Game == V110?caller_updateItem: caller_updateItem_9);
 		//6FC41057  |. E8 A4AA0700    ||CALL D2Game.6FCBBB00
 	}
 	// Update client on loading
-	mem_seek R7(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12, E7548);//6FC325D4-6FC30000
+	mem_seek R8(D2Game, 23EB, 2426, 25D4, 53482, C6A32, ED502, 4BF12, E7548, 139A20);//6FC325D4-6FC30000
-	memt_byte( 0x5F ,0xE8); // CALL
+    if (version_D2Game == V114d) {
-	MEMT_REF4( 0xC0335D5E , caller_updateClientPlayerOnLoading);
+        memt_byte(0x5F, 0xE8); // CALL
        MEMT_REF4(0x5BC0335E, caller_updateClientPlayerOnLoading_114);
    } else {
        memt_byte(0x5F, 0xE8); // CALL
        MEMT_REF4(0xC0335D5E, caller_updateClientPlayerOnLoading);
    }
 	//6FC325D4  |> 5F             POP EDI
 	//6FC325D5  |. 5E             POP ESI
 	//6FC325D6  |. 5D             POP EBP
@ -353,8 +426,12 @@ void Install_PlayerCustomData()
 	//6FD0754B  |. 33C0           XOR EAX,EAX
 	// Free custom data.
-	mem_seek R7(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D, 1705D);
+	mem_seek R8(D2Common, 7055C, 7065C, 80483, 4F82D, 5C9CD, 5856D, 3093D, 1705D, 2220DD);
-	MEMJ_REF4( D2FreeMem, free_PlayerCustomData);
+    if (version_D2Common == V114d) {
        MEMT_REF4(0xFFDE939F, free_PlayerCustomData);
    } else {
        MEMJ_REF4(D2FreeMem, free_PlayerCustomData);
    }
 	//01BD0482  |. E8 C53E0000    CALL <JMP.&Fog.#10046>
 	//6FD9F82C  |. E8 E399FBFF    CALL <JMP.&Fog.#10046>
 	//6FDAC9CC  |. E8 3BC8FAFF    CALL <JMP.&Fog.#10046>
@ -363,8 +440,12 @@ void Install_PlayerCustomData()
 	//6FD6705C  |. E8 CF3EFFFF    CALL <JMP.&Fog.#10046>
 	// Free item in Stash (Server-side)
-	mem_seek R7(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162, 6F7C2);
+	mem_seek R8(D2Game, 7D12B, 7D62B, 8D5A4, 99112, BFDB2, 94242, E1162, 6F7C2, 155B34);
-	MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerServer_getNextItemToFree_111 : version_D2Game == V110 ? callerServer_getNextItemToFree : callerServer_getNextItemToFree_9);//0x0005E204
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x000E8468, callerServer_getNextItemToFree_114);
    } else {
        MEMJ_REF4(D2UnitGetNextItem, version_D2Game >= V111 ? callerServer_getNextItemToFree_111 : version_D2Game == V110 ? callerServer_getNextItemToFree : callerServer_getNextItemToFree_9);//0x0005E204
    }
                                                                                                                                                                                          //6FCBD5A3   . E8 04E20500    CALL <JMP.&D2Common.#10304>
 	//02019111  |. E8 5016F7FF    |CALL <JMP.&D2Common.#10934>
 	//0202FDB1  |. E8 30AAF4FF    |CALL <JMP.&D2Common.#11140>
@ -373,8 +454,13 @@ void Install_PlayerCustomData()
 	//6FC8F7C1  |. E8 44AEF9FF    |CALL <JMP.&D2Common.#10879>
 	// Free item in Stash (Client-side)
-	mem_seek R7(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94, 621E4);//6FB29B31-6FAA0000
+	mem_seek R8(D2Client, 8EF8F, 8E30F, 89B32, 26404, 4C264, 1F2D4, A5C94, 621E4, 66D02);//6FB29B31-6FAA0000
-	MEMJ_REF4( D2UnitGetNextItem, version_D2Game >= V111 ? callerClient_getNextItemToFree_111 : version_D2Game == V110 ? callerClient_getNextItemToFree : callerClient_getNextItemToFree_9);//0x00040F34
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x001D729A, callerClient_getNextItemToFree_114);
    } else {
        MEMJ_REF4(D2UnitGetNextItem, version_D2Game >= V111 ? callerClient_getNextItemToFree_111 : version_D2Game == V110 ? callerClient_getNextItemToFree : callerClient_getNextItemToFree_9);//0x00040F34
    }
    //6FB29B31   E8 340F0400      CALL <JMP.&D2Common.#10304>
 	//6FAD6403  |. E8 925DFEFF    |CALL <JMP.&D2Common.#10934>
 	//6FAFC263  |. E8 38FFFBFF    |CALL <JMP.&D2Common.#11140>
@ -385,8 +471,8 @@ void Install_PlayerCustomData()
 	if ( version_D2Common >= V110 )
 	{
 		// Test if it's already removed from inventory
-		mem_seek R7(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23, 3B393);
+		mem_seek R8(D2Common, 0000, 0000, 4E689, 26E33, 42133, 6AE93, 21B23, 3B393, 23ADB5);
-		memt_byte( 0x0D , 0x07);
+		memt_byte( version_D2Common == V114d ? 0x0E : 0x0D , 0x07);
 		//01D2E688   75 0D            JNZ SHORT D2Common.01D2E697
 		//6FD76E32  |. 74 0D          JE SHORT D2Common.6FD76E41
 		//6FD92132  |. 74 0D          JE SHORT D2Common.6FD92141
@ -394,18 +480,18 @@ void Install_PlayerCustomData()
 		//6FD71B22  |. 74 0D          JE SHORT D2Common.6FD71B31
 		//6FD8B392  |. 74 0D          JE SHORT D2Common.6FD8B3A1
 	} else {
-		mem_seek R7(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Game, 7D176, 7D676, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x74 , 0x90);//MOV EAX,EDI
 		memt_byte( 0x35 , 0x90);//NOP
 		//6FCAD176  |. 74 35          |JE SHORT D2Game.6FCAD1AD
-		mem_seek R7(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 8F0CA, 8E44A, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x0F , 0x90);//MOV EAX,EDI
 		memt_byte( 0x84 , 0x90);//NOP
 		memt_dword( 0x000000BF , 0x90909090);//NOP
 		//6FB2F0CA  |. 0F84 BF000000  |JE D2Client.6FB2F18F
-		mem_seek R7(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 8F13C, 8E4BC, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x74 , 0x90);//MOV EAX,EDI
 		memt_byte( 0x6F , 0x90);//NOP
 		//6FB2F13C  |. 74 6F          |JE SHORT D2Client.6FB2F1AD
--- a/PlugY/PlugYFiles.cpp
+++ b/PlugY/PlugYFiles.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Adding custom data.
 	Save and load infinity & shared Stash
@ -79,6 +80,17 @@ ISNOTMODDATA:
 	JMP DWORD PTR CS:[LeaveCriticalSection]
 }}
 FCT_ASM( caller_isModFile_114 )
    PUSH EBX
    CALL isModFile
    TEST EAX, EAX
    JE ISNOTMODDATA
    MOV EDX, 0x1
 ISNOTMODDATA :
    LEA EAX, DWORD PTR SS : [EBP - 0x108]
    RETN
 }}
 void Install_PlugYFiles()
 {
 	static int isInstalled = false;
@ -87,10 +99,14 @@ void Install_PlugYFiles()
 	log_msg("Patch Storm to found custom file. (PlugYFiles)\n");
 	// Try in Diablo II\PlugY\ if file not found
-	mem_seek R7(Storm,	192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89, 2DA79);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) );
+	mem_seek R8(Storm,	192C6, 19296, 18677, 2CC69, 14259, 121E9, 28D89, 2DA79, 19369);//( (DWORD)D2Storm268 + V7(Storm, 01A8, 01A8, 01AB, 0429, 0429, 0429, 0000) );
-	memt_byte( 0xFF ,0x90); // NOP
+	memt_byte( version_D2Client == V114d ? 0x8D : 0xFF ,0x90); // NOP
-	memt_byte( 0x15 ,0xE8); // CALL
+	memt_byte( version_D2Client == V114d ? 0x85 : 0x15 ,0xE8); // CALL
-	MEMD_REF4( LeaveCriticalSection, version_Storm >= V111 ? caller_isModFile_111 : caller_isModFile);
+    if (version_Storm == V114d) {
        MEMT_REF4(0xFFFFFEF8, caller_isModFile_114);
    } else {
        MEMD_REF4(LeaveCriticalSection, version_Storm == V114d ? caller_isModFile_114 : version_Storm >= V111 ? caller_isModFile_111 : caller_isModFile);
    }
 	//6FFC8677  |. FF15 F411FE6F  CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
 	//6FC1CC69  |. FF15 3832C36F  CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
 	//6FC04259  |. FF15 3832C36F  CALL DWORD PTR DS:[<&KERNEL32.LeaveCriti>; \LeaveCriticalSection
@ -148,12 +164,26 @@ void STDCALL freeCustomImages()
 	freeImagesFile(statsBackgroundImages);
 }
 FCT_ASM( caller_loadCustomImages_114 )
    CALL loadCustomImages
    POP EAX
    PUSH 0x6CC8B8
    JMP EAX
 }}
 FCT_ASM ( caller_loadCustomImages )
 	CALL loadCustomImages
 	MOV ECX,0x0C
 	RETN
 }}
 FCT_ASM( caller_freeCustomImages_114 )
    CALL freeCustomImages
    POP EAX
    PUSH 0x7BEF30
    JMP EAX
 }}
 FCT_ASM ( caller_freeCustomImages )
 	CALL freeCustomImages
 	MOV ECX,0x0C
@ -170,9 +200,9 @@ void Install_PlugYImagesFiles()
 	log_msg("Patch D2Client to load/free custom images. (PlugYImagesFiles)\n");
 	// Load custom images
-	mem_seek R7(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE, 6E0BE);
+    mem_seek R8(D2Client, 57E21, 57E21, 5E4B1, 2E101, B67E1, 82761, 27EAE, 6E0BE, 96955);
-	memt_byte( 0xB9 ,0xE8);
+    memt_byte(V8(D2Client, B9, B9, B9, B9, B9, B9, B9, B9, 68), 0xE8);
-	MEMT_REF4( 0x0000000C , caller_loadCustomImages);
+    MEMT_REF4(version_D2Client == V114d ? 0x006CC8B8 : 0x0000000C, version_D2Client == V114d ? caller_loadCustomImages_114 : caller_loadCustomImages);
    //6FAFE4B1  |. B9 0C000000    MOV ECX,0C
    //6FADE101  |. B9 0C000000    MOV ECX,0C
    //6FB667E1  |. B9 0C000000    MOV ECX,0C
@ -181,9 +211,9 @@ void Install_PlugYImagesFiles()
    //6FB1E0BE  |. B9 0C000000    MOV ECX,0C
 	// Free custom images
-	mem_seek R7(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D, 6D07D);
+	mem_seek R8(D2Client, 57FA9, 57FA9, 5E639, 2D12D, B580D, 8158D, 26F8D, 6D07D, 96AFB);
-	memt_byte( 0xB9 ,0xE8);
+	memt_byte(V8(D2Client, B9, B9, B9, B9, B9, B9, B9, B9, 68),0xE8);
-	MEMT_REF4( 0x0000000C , caller_freeCustomImages);
+	MEMT_REF4(version_D2Client == V114d ? 0x007BEF30 : 0x0000000C, version_D2Client == V114d ? caller_freeCustomImages_114 : caller_freeCustomImages);
 	//6FAFE639  |> B9 0C000000    MOV ECX,0C
 	//6FADD12D  |> B9 0C000000    MOV ECX,0C
 	//6FB6580D  |> B9 0C000000    MOV ECX,0C
@ -245,8 +275,8 @@ void Install_PlugYTxtFiles()
 //	lookupItemStatCost =  (void*)R7(D2Common, A1D70, A1D70, AA1D8, 0000, 0000, 0000, 0000);
 	// Load custom txt files
-	mem_seek R7(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4, 855E4);
+	mem_seek R8(D2Common, 7F4B, 7F4B, 2F7D7, 76854, 37444, 81C44, 5D6E4, 855E4, 25A560);
-	MEMC_REF4( D2LoadSuperuniques, version_D2Common >= V111 ? caller_loadTxtFiles_111 : caller_loadTxtFiles );
+	MEMC_REF4( D2LoadSuperuniques, version_D2Common == V114d ? caller_loadTxtFiles : version_D2Common >= V111 ? caller_loadTxtFiles_111 : caller_loadTxtFiles );
 	//6FD47F4A  |. E8 B1750100    CALL D2Common.6FD5F500
 	//6FD47F4A  |. E8 C1750100    CALL D2Common.6FD5F510
 	//01B6F7D6  |. E8 C5A7FFFF    CALL D2Common.01B69FA0
@ -257,8 +287,12 @@ void Install_PlugYTxtFiles()
 	//6FDD55E3  |. E8 58B6FFFF    CALL D2Common.6FDD0C40                   ; \D2Common.6FDD0C40
 	// Free custom txt files
-	mem_seek R7(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3, FAA3);
+	mem_seek R8(D2Common, 79EC, 79EC, 10186, 332B3, 15AB3, 44E13, 5E8B3, FAA3, 25A1C8);
-	MEMJ_REF4( D2Fog10212, caller_freeTxtFiles );
+    if (version_D2Common == V114d) {
        MEMT_REF4(0x00062EE4, caller_freeTxtFiles);
    } else {
        MEMJ_REF4(D2Fog10212, caller_freeTxtFiles);
    }
 	//6FD479EB   . E8 C8C00600    CALL <JMP.&Fog.#10212>
 	//6FD479EB   . E8 C8C00600    CALL <JMP.&Fog.#10212>
 	//01B50185  |. E8 F8410700    CALL <JMP.&Fog.#10212>
--- a/PlugY/SavePath.cpp
+++ b/PlugY/SavePath.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Changing the current save path.
@ -49,6 +50,46 @@ END_CHANGESP:
 	RETN
 }}
 FCT_ASM( changeSavePath_114 )
    PUSH EAX
    PUSH EDI
    PUSH EDX
    PUSH ESI
    MOV ESI, EBX
    MOV EDI, DWORD PTR DS : [savePath]
    XOR AL, AL
    CLD
    OR ECX, 0xFFFFFFFF
    REPNE SCAS BYTE PTR ES : [EDI]
    NOT ECX
    SUB EDI, ECX
    XCHG EDI, ESI
    CMP BYTE PTR[ESI + 1], ':'
    JE END_CHANGESP
    //RELATIVE_PATH:
    MOV EDX, ECX
    OR ECX, 0xFFFFFFFF
    REPNE SCAS BYTE PTR ES : [EDI]
    DEC EDI
    CMP BYTE PTR[EDI - 1], '\\'
    JE NEXT
    MOV BYTE PTR[EDI], '\\'
    INC EDI
    NEXT :
    MOV ECX, EDX
    END_CHANGESP :
    REP MOVS BYTE PTR ES : [EDI], BYTE PTR DS : [ESI]
    POP ESI
    POP EDX
    POP EDI
    POP EAX
    CMP EAX, -1
    JE DONOT_JMP
    ADD DWORD PTR SS : [ESP], 5
 DONOT_JMP :
    RETN
 }}
 FCT_ASM( changeSavePath_111 )
 	PUSH EAX
 	PUSH EDI
@ -88,6 +129,29 @@ DONOT_JMP:
 	RETN
 }}
 FCT_ASM( forCreateSavePath_114 )
    PUSH EDI
    MOV ESI, EBX
    MOV EDI, DWORD PTR DS : [savePath]
    MOV ECX, EDI
    CMP BYTE PTR DS : [EDI + 1], ':'
    JNZ END_CREATESP
    PUSH ESI
    XOR AL, AL
    CLD
    OR ECX, 0xFFFFFFFF
    REPNE SCAS BYTE PTR ES : [EDI]
    NOT ECX
    SUB EDI, ECX
    XCHG EDI, ESI
    REP MOVS BYTE PTR ES : [EDI], BYTE PTR DS : [ESI]
    POP ESI
 END_CREATESP :
    POP EDI
    MOV DWORD PTR SS : [ESP + 8], ECX
    JMP D2Storm503
 }}
 FCT_ASM ( forCreateSavePath )
 	PUSH EDI
 	MOV EDI,DWORD PTR DS:[savePath]
@ -121,10 +185,10 @@ void Install_ChangingSavePath()
 	if (version_Fog >= V111)
 	{
-		// Appel de notre fct d'ajout d'un sous-répertoire
+		// Appel de notre fct d'ajout d'un sous-r<EFBFBD>pertoire
-		mem_seek R7(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86, 1E146);
+		mem_seek R8(Fog, 000, 000, 000, 185F6, 1C106, 1F086, 17F86, 1E146, 71A6);
 		memt_byte( 0x83 ,0xE8);				// CALL changeSavePath
-		MEMT_REF4( 0x0575FFF8, changeSavePath_111);
+		MEMT_REF4( 0x0575FFF8, version_Fog == V114d ? changeSavePath_114 : changeSavePath_111);
 		//6FF685F6   . 83F8 FF        CMP EAX,-1
 		//6FF685F9   . 75 05          JNZ SHORT fog.6FF68600
 		//6FF6C106   . 83F8 FF        CMP EAX,-1
@ -136,9 +200,13 @@ void Install_ChangingSavePath()
 		//6FF6E146   . 83F8 FF        CMP EAX,-1
 		//6FF6E149   . 75 05          JNZ SHORT Fog.6FF50F64
-		// Pour créer le bon chemin de sauvegarde
+		// Pour cr<63>er le bon chemin de sauvegarde
-		mem_seek R7(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6, 1E166);
+		mem_seek R8(Fog, 000, 000, 000, 18616, 1C126, 1F0A6, 17FA6, 1E166, 71CA);
-		MEMJ_REF4( D2Storm503, forCreateSavePath);
+        if (version_Fog == V114d) {
            MEMT_REF4(0x0000C582, forCreateSavePath_114);
        } else {
            MEMJ_REF4(D2Storm503, forCreateSavePath);
        }
 		//6FF68615   . E8 A246FFFF    CALL <JMP.&Storm.#503>
 		//6FF6C125   . E8 C20BFFFF    CALL <JMP.&Storm.#503>
 		//6FF6F0A5   . E8 34DDFEFF    CALL <JMP.&Storm.#503>
@ -147,10 +215,10 @@ void Install_ChangingSavePath()
 		// Remove registry update
-		mem_seek R7(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA, 1E16A);
+		mem_seek R8(Fog, 000, 000, 000, 1861A, 1C12A, 1F0AA, 17FAA, 1E16A, 71E9);
-		memt_byte( 0x56 ,0xEB); 			// JMP SHORT fog.6FF6862C
+		memt_byte( version_Fog == V114d ? 0x53 : 0x56 ,0xEB); 			// JMP SHORT fog.6FF6862C
 		memt_byte( 0x6A ,0x10);				//
-		memt_byte( 0x00 ,0x90);				// NOP
+		memt_byte( version_Fog == V114d ? 0x01 : 0x00 ,0x90);				// NOP
 		//6FF6861A   . 56             PUSH ESI
 		//6FF6861B   . 6A 00          PUSH 0
 		//6FF6861D   . 68 7C7BF76F    PUSH fog.6FF77B7C                                    ;  ASCII "Save Path"
@ -173,7 +241,7 @@ void Install_ChangingSavePath()
 	} else {
-		// Appel de notre fct d'ajout d'un sous-répertoire
+		// Appel de notre fct d'ajout d'un sous-r<EFBFBD>pertoire
 		mem_seek( (DWORD)D2FogGetSavePath + 0x28);//6FF61928-6FF50000
 		memt_byte( 0x56 ,0x90);				// NOP
 		memt_byte( 0xFF ,0xE8);				// CALL changeSavePath
@ -182,7 +250,7 @@ void Install_ChangingSavePath()
 		//6FF61929   FFD5             CALL EBP
 		//6FF6192B   83F8 FF          CMP EAX,-1
-		// Pour créer le bon chemin de sauvegarde
+		// Pour cr<EFBFBD>er le bon chemin de sauvegarde
 		mem_seek( (DWORD)D2FogGetSavePath + 0xBD);//6FF619BC
 		MEMJ_REF4( D2Storm503, forCreateSavePath);
 		//6FF619BC   . E8 5D2A0000    CALL <JMP.&Storm.#503>
--- a/PlugY/SavePlayerData.cpp
+++ b/PlugY/SavePlayerData.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
    Save Player Custom Data.
@ -45,6 +46,12 @@ void STDCALL SaveSPPlayerCustomData(Unit* ptChar)
 	log_msg("End saving.\n\n");
 }
 FCT_ASM( caller_SaveSPPlayerCustomData_114 )
    CALL D2FogGetSavePath
    PUSH EDI
    CALL SaveSPPlayerCustomData
    RETN
 }}
 FCT_ASM ( caller_SaveSPPlayerCustomData_111 )
 	CALL D2FogGetSavePath
@ -279,7 +286,7 @@ DWORD STDCALL ReceiveSaveFilesToSave(t_rcvMsg* msg)
 {
 	if( (msg->packID != customPackID) || !msg->isCustom) return 0;
-	log_msg("Saving Receive Packet: type=%X\t init=%d\t finalSize=%X\t packSize=%02X\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data);
+	log_msg("Saving Receive Packet: id = %d\ttype=%X\t init=%d\t finalSize=%X\t packSize=%02X\t data=%08X\n", msg->type, msg->init, msg->finalSize, msg->packSize, msg->data);
 	bool isShared;
@ -359,7 +366,42 @@ void STDCALL SaveMPPlayerCustomData(BYTE* dataD2Savefile )
 }
 void STDCALL SaveMPPlayerCustomData_114()
 {
    if (!D2isLODGame()) return;
    log_msg("\n--- Start SaveMPPlayerCustomData ---\n");
    Unit* ptChar = D2GetClientPlayer();
    if (PCPY->selfStashIsOpened)
    {
        DWORD curSizeExt = 0;
        DWORD maxSizeExt = 0x4000;
        BYTE* dataExt = new BYTE[maxSizeExt];
        ZeroMemory(dataExt, maxSizeExt);
        d2_assert(!dataExt, "Error : Memory allocation Extended SaveFile", __FILE__, __LINE__);
        saveExtendedSaveFile(ptChar, &dataExt, &maxSizeExt, &curSizeExt);
        writeExtendedSaveFile(PCPlayerData->name, dataExt, curSizeExt);
        delete[] dataExt;
    }
    if (active_sharedStash && PCPY->sharedStashIsOpened)
    {
        DWORD curSizeShr = 0;
        DWORD maxSizeShr = 0x4000;
        BYTE* dataShr = new BYTE[maxSizeShr];
        ZeroMemory(dataShr, maxSizeShr);
        d2_assert(!dataShr, "Error : Memory allocation Shared SaveFile", __FILE__, __LINE__);
        saveSharedSaveFile(ptChar, &dataShr, &maxSizeShr, &curSizeShr);
        NetClient* ptClient = D2GetClient(ptChar, __FILE__, __LINE__);
        writeSharedSaveFile(PCPlayerData->name, dataShr, curSizeShr, 0/*ptClient->isHardCoreGame*/);
        delete[] dataShr;
    }
    log_msg("End saving.\n\n");
 }
 /*
@ -487,6 +529,16 @@ continue_rcvFct:
 //	JMP DWORD PTR SS:[ESP+0x5F0]
 }}
 FCT_ASM( caller_SaveMPPlayerCustomData_114 )
    PUSH EAX
    PUSH ECX
    CALL SaveMPPlayerCustomData_114
    POP ECX
    POP EAX
    CMP ECX, 0xAA55AA55
    RETN
 }}
 FCT_ASM ( caller_SaveMPPlayerCustomData_111 )
 	PUSH EAX
 	PUSH ECX
@ -519,9 +571,13 @@ void Install_SavePlayerData()
 	log_msg("Patch D2Game & D2Client for save Player's custom data. (SavePlayerData)\n");
-	//Save single player custom data.
+	// Save single player custom data.
-	mem_seek R7(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35, 39835);
+	mem_seek R8(D2Game, 4DF04, 4E304, 5A624, B9365, 25475, 44165, 53F35, 39835, 132276);
-	MEMJ_REF4( D2FogGetSavePath, version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 : version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0xFFED4DD6, caller_SaveSPPlayerCustomData_114);
    } else {
        MEMJ_REF4(D2FogGetSavePath, version_D2Game >= V111 ? caller_SaveSPPlayerCustomData_111 : version_D2Game != V109b ? caller_SaveSPPlayerCustomData : caller_SaveSPPlayerCustomData_9);
    }
    //6FC8A623   E8 3E210900      CALL <JMP.&Fog.#10115>
 	//02039364  |. E8 3B0FF5FF    CALL <JMP.&Fog.#10115>
 	//01F95474  |. E8 C34EFEFF    CALL <JMP.&Fog.#10115>
@ -529,8 +585,19 @@ void Install_SavePlayerData()
 	//6FC73F34  |. E8 DD63FBFF    CALL <JMP.&Fog.#10115>
 	//6FC59834  |. E8 FB0AFDFF    CALL <JMP.&Fog.#10115>
    if (version_D2Game == V114d) {
        // Save multiplayer player custom data.
        mem_seek R8(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2, 5C565);
        memt_byte(0x81, 0xE8); // CALL
        MEMT_REF4(0x55AA55F9, caller_SaveMPPlayerCustomData_114);
        memt_byte(0xAA, 0x90); // CALL
        log_msg("\n");
        isInstalled = true;
        return;
    }
 	//Send SaveFiles
-	mem_seek R7(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB, 397AB);
+	mem_seek R8(D2Game, 4DFFA, 4E3FA, 5A720, B92DB, 253EB, 440DB, 53EAB, 397AB, 132398);
 	memt_byte( 0x8B ,0x90); // NOP
 	memt_byte( version_D2Game >= V111 ? 0x44 : version_D2Game != V109b ? 0x7C : 0x74 ,0xE8); // CALL
 	MEMT_REF4( version_D2Game >= V111 ? 0xC0850424 : version_D2Game != V109b ? 0xFF851024 : 0xF6851024, version_D2Game >= V111 ? caller_SendSaveFilesToSave_111 : version_D2Game != V109b ? caller_SendSaveFilesToSave : caller_SendSaveFilesToSave_9);
@ -547,7 +614,7 @@ void Install_SavePlayerData()
 	//6FC597AB  |. 8B4424 04      MOV EAX,DWORD PTR SS:[ESP+4]
 	//6FC597AF  |. 85C0           TEST EAX,EAX
-	mem_seek R7(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173, BEDD3);
+	mem_seek R8(D2Game, 7993, 7A13, 7BBB, E2943, E6D83, A89D3, 2D173, BEDD3, 138FEC/*12E110*/);
 	memt_byte( 0x8B ,0x90); // NOP
 	memt_byte( version_D2Game >= V110 ? 0x8E : 0x86 ,0xE8); // CALL
 	MEMT_REF4( version_D2Game >= V110 ? 0x0000017C : version_D2Game == V109d ? 0x0000174 : 0x00000150, version_D2Game >= V110 ? caller_ManageNextPacketToSend : version_D2Game == V109d ? caller_ManageNextPacketToSend_9d : caller_ManageNextPacketToSend_9);
@ -568,7 +635,7 @@ void Install_SavePlayerData()
 	if ( version_D2Game >= V111 )
 	{
 		//Received SaveFiles
-		mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946, 448E6);
+		mem_seek R8(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 43946, 448E6, 448E6);
 		memt_byte( 0x0F ,0xE8);
 		MEMT_REF4( 0x0C2444B6, caller_ReceivedSaveFilesToSave_111);
 		//6FB39246  |. 0FB64424 0C    |MOVZX EAX,BYTE PTR SS:[ESP+C]
@ -578,7 +645,7 @@ void Install_SavePlayerData()
 		//6FAF48E6  |. 0FB64424 0C    |MOVZX EAX,BYTE PTR SS:[ESP+C]
 		// Save multiplayer player custom data.
-		mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2);
+		mem_seek R8(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, AC572, 829C2, 829C2);
 		memt_byte( 0x81 ,0xE8); // CALL
 		MEMT_REF4( 0x55AA55F9, caller_SaveMPPlayerCustomData_111);
 		memt_byte( 0xAA ,0x90); // CALL
@ -589,14 +656,14 @@ void Install_SavePlayerData()
 		//6FB329C2  |. 81F9 55AA55AA  CMP ECX,AA55AA55
 	} else {
 		//Received SaveFiles
-		mem_seek R7(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 0000, 0000);
+		mem_seek R8(D2Client, 116F0, 116E0, 11CB0, 89246, 32076, 7BCD6, 0000, 0000, 0000);
 		memt_byte( 0x81 ,0x90); // NOP
 		memt_byte( 0xEC ,0xE8); // CALL
 		MEMT_REF4( 0x000005F4, caller_ReceivedSaveFilesToSave);
 		//6FAB1CB0  |$ 81EC F4050000  SUB ESP,5F4
 		// Save multiplayer player custom data.
-		mem_seek R7(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000, 0000);
+		mem_seek R8(D2Client, 117FC, 117EC, 11DBC, 99AE2, BD7F2, 64A22, 0000, 0000, 0000);
 		memt_byte( 0x8B ,0xE8); // CALL
 		MEMT_REF4( 0x04518B01, caller_SaveMPPlayerCustomData);
 		//6FAB1DBC  |. 8B01           MOV EAX,DWORD PTR DS:[ECX]
--- a/PlugY/SkillPerLevelUp.cpp
+++ b/PlugY/SkillPerLevelUp.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Change Skill win per level up.
@ -35,14 +36,18 @@ void Install_SkillPerLevelUp()
 	log_msg("Patch D2Game for change Skill points win per level up. (SkillPerLevelUp)\n");
-	mem_seek R7(D2Game,	42261,	42651,	4ED60, D7AE5, 79695, AA455, EB1E5, EDCA5);
+	mem_seek R8(D2Game,	42261,	42651,	4ED60, D7AE5, 79695, AA455, EB1E5, EDCA5, 1709D1);
-	MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeSkillPerLevelUp_111 : caller_changeSkillPerLevelUp);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x000B68DB, caller_changeSkillPerLevelUp);
    } else {
        MEMJ_REF4(V2AddPlayerStat, version_D2Game >= V111 ? caller_changeSkillPerLevelUp_111 : caller_changeSkillPerLevelUp);
        //6FC7ED5F  |. E8 56CB0900    CALL <JMP.&D2Common.#10518>
        //02057AE4  |. E8 9F28F3FF    CALL <JMP.&D2Common.#10109>
        //01FE9694  |. E8 1B0DF9FF    CALL <JMP.&D2Common.#10627>
        //6FCCA454  |. E8 5F01F6FF    CALL <JMP.&D2Common.#10762>
        //6FD0B1E4  |. E8 E9F2F1FF    CALL <JMP.&D2Common.#10551>
        //6FD0DCA4  |. E8 FDC6F1FF    CALL <JMP.&D2Common.#10645>
    }
 	log_msg("\n");
--- a/PlugY/SkillsPoints.cpp
+++ b/PlugY/SkillsPoints.cpp
@ -42,6 +42,8 @@ void UnassignAllSkillsPoints(Unit* ptChar)
 	DWORD nbPoints = 0;
 	void* ptClient = D2GetClient(ptChar,__FILE__,__LINE__);
 	SkillData* ptSkill = PCSkills->ptFirstSkill;
    log_msg("\n\nUNASSIGN SKILL POINTS\n\n");
 	while (ptSkill)
 	{
 		if (getCharClass(ptSkill) == ptChar->nPlayerClass)//ptSkill->ptSkillBin->charclass
--- a/PlugY/StatPerLevelUp.cpp
+++ b/PlugY/StatPerLevelUp.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Change Stat win per level up.
@ -33,14 +34,18 @@ void Install_StatPerLevelUp()
 	log_msg("Patch D2Game for change Stat points win per level up. (StatPerLevelUp)\n");
-	mem_seek R7(D2Game,	42258,	42648,	4ED55, D7ADA, 7968A, AA44A, EB1DA, EDC9A);
+	mem_seek R8(D2Game,	42258,	42648,	4ED55, D7ADA, 7968A, AA44A, EB1DA, EDC9A, 1709C6);
-	MEMJ_REF4( V2AddPlayerStat, version_D2Game >= V111 ? caller_changeStatPerLevelUp_111 : caller_changeStatPerLevelUp);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x000B68E6, caller_changeStatPerLevelUp);
    } else {
        MEMJ_REF4(V2AddPlayerStat, version_D2Game >= V111 ? caller_changeStatPerLevelUp_111 : caller_changeStatPerLevelUp);
        //6FC7ED54  |. E8 61CB0900    CALL <JMP.&D2Common.#10518>
        //02057AD9  |. E8 AA28F3FF    CALL <JMP.&D2Common.#10109>
        //01FE9689  |. E8 260DF9FF    CALL <JMP.&D2Common.#10627>
        //6FCCA449  |. E8 6A01F6FF    CALL <JMP.&D2Common.#10762>
        //6FD0B1D9  |. E8 F4F2F1FF    CALL <JMP.&D2Common.#10551>
        //6FD0DC99  |. E8 08C7F1FF    CALL <JMP.&D2Common.#10645>
    }
 	log_msg("\n");
--- a/PlugY/StatsPoints.cpp
+++ b/PlugY/StatsPoints.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Unassign Stats Point for futher re-assignment.
@ -249,6 +250,13 @@ END_UNASSGNSTATS:
 	RETN
 }}
 FCT_ASM( caller_setValue_114 )
    MOV CL, 0x3A
    OR DX, WORD PTR DS : [ESI]
    ADD DL, currentMsgID
    MOV CH, DL
    RETN
 }}
 FCT_ASM ( caller_setValue_111 )
 	ADD CL,currentMsgID
@ -288,6 +296,21 @@ DWORD STDCALL pushDown (DWORD num)
 	return 0;
 }
 FCT_ASM( caller_pushDown_114 )
    PUSH EDX
    PUSH DWORD PTR SS : [EBP + 0x8]
    CALL pushDown
    POP EDX
    TEST EAX, EAX
    JNZ end_pushDown
    SUB DWORD PTR SS : [ESP], 0x22
    RETN
 end_pushDown :
    MOV EAX, DWORD PTR SS : [EBP + 0x8]
    LEA ECX, DWORD PTR DS : [EAX * 8]
    RETN
 }}
 FCT_ASM ( caller_pushDown_111 )
 	PUSH EDX
 	PUSH EDX
@ -329,11 +352,11 @@ void Install_StatsPoints()
 	log_msg("Patch D2Client for unassign stat points when specified key is press. (StatsPoints)\n");
 	// Always print stat button images.
-	mem_seek R7(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955);
+	mem_seek R8(D2Client, 29B12, 29B02, 30073, 82BBA, 8963A, 6B59A, BD1B5, BF955, A7FFB);
 	memt_byte( 0x8B, 0xEB );	// JMP SHORT D2Client.6FAD0088
-	memt_byte( 0x4C, V7(D2Client, 12, 12, 13, 13, 13, 13, 13, 13) );
+	memt_byte( version_D2Client == V114d ? 0x4D : 0x4C, V8(D2Client, 12, 12, 13, 13, 13, 13, 13, 13, 12) );
-	memt_byte( 0x24, 0x90 );	// NOP
+	memt_byte( version_D2Client == V114d ? 0xF8 : 0x24, 0x90 );	// NOP
-	memt_byte( V7(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C), 0x90 );			// NOP (V109d:0x20 , V110:0x14
+	if (version_D2Client < V114d) memt_byte( V8(D2Client, 20, 20, 14, 1C, 1C, 1C, 1C, 1C, 1C), 0x90 );			// NOP (V109d:0x20 , V110:0x14
 	//6FAD0073     8B4C24 14      MOV ECX,DWORD PTR SS:[ESP+14]
 	//6FB32BBA   > 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
 	//6FB3963A   > 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
@ -342,8 +365,12 @@ void Install_StatsPoints()
 	//6FB6F955   > 8B4C24 1C      MOV ECX,DWORD PTR SS:[ESP+1C]
 	//print our buttons
-	mem_seek R7(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE);
+	mem_seek R8(D2Client, 29B9D, 29B8D, 300FD, 82C54, 896D4, 6B637, BD23E, BF9DE, A808C);
-	MEMJ_REF4( D2PrintImage, caller_printUnassignStatsBtn);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0x0004E3F0, caller_printUnassignStatsBtn);
    } else {
        MEMJ_REF4(D2PrintImage, caller_printUnassignStatsBtn);
    }
 	//6FB32C53   . E8 82A3F8FF    CALL <JMP.&D2gfx.#10047>
 	//6FB396D3   . E8 D238F8FF    CALL <JMP.&D2gfx.#10044>
 	//6FB1B636   . E8 431AFAFF    CALL <JMP.&D2gfx.#10024>
@ -351,9 +378,10 @@ void Install_StatsPoints()
 	//6FB6F9DD   . E8 ECD5F4FF    CALL <JMP.&D2gfx.#10042>
 	// Always manage push down.
-	mem_seek R7(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9, BF579);
+    mem_seek R8(D2Client, 2AA7B, 2AA6B, 3134D, 827D9, 89259, 6B1B9, BCDD9, BF579, A77E4);
 	memt_byte( 0x74, 0x90 );	// NOP
-	memt_byte( 0x4E, 0x90 );	// NOP
+    memt_byte(version_D2Client == V114d ? 0x62 : 0x4E, 0x90);	// NOP
 	//6FAD134D     74 4E          JE SHORT D2Client.6FAD139D
 	//6FB327D9   . 74 4E          JE SHORT D2Client.6FB32829
 	//6FB39259   . 74 4E          JE SHORT D2Client.6FB392A9
@ -364,12 +392,20 @@ void Install_StatsPoints()
 	if ( version_D2Client >= V111 )
 	{
 		// On Push down.
-		mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4);
+		mem_seek R8(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 6B224, BCE44, BF5E4, A7863);
-		memt_byte( 0x6B, 0xE8 );
+        if (version_D2Client == V114d) {
-		MEMT_REF4( 0x01BF0ED2, caller_pushDown_111);
+            memt_byte(0x8B, 0xE8);
-		memt_byte( 0x00, 0x6B );	// IMUL EDX,EDX,0E
+            MEMT_REF4(0x0C8D0845, caller_pushDown_114);
-		memt_byte( 0x00, 0xD2 );
+            memt_byte(0xC5, 0x90);
-		memt_byte( 0x00, 0x0E );
+            memt_dword(0x00000000, 0x90909090);
        } else {
            memt_byte(0x6B, 0xE8);
            MEMT_REF4(0x01BF0ED2, caller_pushDown_111);
            memt_byte(0x00, 0x6B);	// IMUL EDX,EDX,0E
            memt_byte(0x00, 0xD2);
            memt_byte(0x00, 0x0E);
        }
 		//6FB32844   > 6BD2 0E        IMUL EDX,EDX,0E
 		//6FB32847   . BF 01000000    MOV EDI,1
 		//6FB392C4   > 6BD2 0E        IMUL EDX,EDX,0E
@ -383,7 +419,7 @@ void Install_StatsPoints()
 	} else {
 		// On Push down.
-		mem_seek R7(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 2AAE6, 2AAD6, 313B8, 82844, 892C4, 0000, 0000, 0000, 0000);
 		memt_byte( 0x8D, 0xE8 );	// CALL
 		MEMT_REF4( 0x0000D504, caller_pushDown);
 		memt_byte( 0x00, 0x90 );	// NOP
@ -391,13 +427,15 @@ void Install_StatsPoints()
 		//6FAD13B8   8D04D5 00000000  LEA EAX,DWORD PTR DS:[EDX*8]
 	}
 	if ( version_D2Client >= V110 )
 	{
 		// Always manage push up.
-		mem_seek R7(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49, C05E9);
+		mem_seek R8(D2Client, 0000, 0000, 3152E, 83869, 8A2E9, 6C249, BDE49, C05E9, A7976);
-		memt_byte( 0x74, 0x90 );	// NOP
+		memt_byte( version_D2Client == V114d ? 0x0F : 0x74, 0x90 );	// NOP
-		memt_byte( version_D2Client >= V111 ? 0x65 : 0x68, 0x90 );	// NOP
+		memt_byte(version_D2Client == V114d ? 0x84 : version_D2Client >= V111 ? 0x65 : 0x68, 0x90 );	// NOP
        if (version_D2Client == V114d) {
            memt_dword(0x000000BB, 0x90909090);
        }
 		//6FAD152E     74 68          JE SHORT D2Client.6FAD1598
 		//6FB33869   . 74 65          JE SHORT D2Client.6FB338D0
 		//6FB3A2E9   . 74 65          JE SHORT D2Client.6FB3A350
@ -406,7 +444,7 @@ void Install_StatsPoints()
 		//6FB705E9   . 74 65          JE SHORT D2Client.6FB70650
 		// Unassign stats point when ctrl is push.
-		mem_seek R7(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB, C069B);
+		mem_seek R8(D2Client, 0000, 0000, 315D3, 8391B, 8A39B, 6C2FB, BDEFB, C069B, A79F2);
 		memt_byte( 0x66, 0xE8 );	// CALL
 		MEMT_REF4( 0x077CC085, caller_UnassignStats);
 		//6FAD15D3   . 66:85C0        TEST AX,AX
@ -423,24 +461,28 @@ void Install_StatsPoints()
 		//6FB7069E   . 7C 07          JL SHORT D2Client.6FB706A7
 	} else {
 		// Always manage push up.
-		mem_seek R7(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 2AC55, 2AC45, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0x0F, 0x90 );	// NOP
 		memt_byte( 0x84, 0x90 );	// NOP
 		memt_dword( 0x000000AE, 0x90909090 );	// NOP NOP NOP NOP
 		//6FACAC45   . 0F84 AE000000  JE D2Client.6FACACF9
 		// Unassign stats point when ctrl is push.
-		mem_seek R7(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000, 0000);
+		mem_seek R8(D2Client, 2ACD9, 2ACC9, 0000, 0000, 0000, 0000, 0000, 0000, 0000);
 		memt_byte( 0xB8, 0xE8 );	// CALL
 		MEMT_REF4( 0x00000001, caller_UnassignStats_9);
 		//6FACACC9   . B8 01000000    MOV EAX,1
 	}
 	// Set the id for the calling function.
-	mem_seek R7(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E, C06DE);
+	mem_seek R8(D2Client, 2AD02, 2ACF2, 31611, 8395E, 8A3DE, 6C33E, BDF3E, C06DE, A7A29);
 	if ( version_D2Client >= V111 ) {
-		memt_byte( 0x66, 0xE8 );	// CALL
+		memt_byte( version_D2Client == V114d ? 0xB1 : 0x66, 0xE8 );	// CALL
-		MEMT_REF4( 0x15244C89, caller_setValue_111);
+        if (version_D2Client == V114d) {
            MEMT_REF4(0x160B663A, caller_setValue_114);
        } else {
            MEMT_REF4(0x15244C89, caller_setValue_111);
        }
 		//6FB3395E   . 66:894C24 15   MOV WORD PTR SS:[ESP+15],CX
 		//6FB3A3DE   . 66:894C24 15   MOV WORD PTR SS:[ESP+15],CX
 		//6FB1C33E   . 66:894C24 15   MOV WORD PTR SS:[ESP+15],CX              ; |
@ -482,7 +524,7 @@ void Install_StatsLimitShiftClick()
 	log_msg("Patch D2Client for limit the assigment of stat points when shift is used. (LimitShift)\n");
 	// Limit the assigment of stat points.
-	mem_seek R7(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5, C0695);
+	mem_seek R8(D2Client, 2ACD0, 2ACC0, 315CD, 83915, 8A395, 6C2F5, BDEF5, C0695, A79EC);
 	memt_byte( 0xFF, 0x90 );	// NOP
 	memt_byte( 0x15, 0xE8 );	// CALL
 	MEMD_REF4( GetKeyState, version_D2Client >= V111 ? caller_LimitShift_111 : caller_LimitShift);
--- a/PlugY/UberQuest.cpp
+++ b/PlugY/UberQuest.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Uber Quest Management.
@ -314,6 +315,15 @@ void FASTCALL uberBaalIA(Game* ptGame, Unit* ptMonster, DWORD* ptData)
 	D2BaalIA(ptGame, ptMonster, ptData);
 }
 FCT_ASM ( caller_spawnUber )
    PUSHAD
    PUSH EDX
    PUSH ECX
    CALL spawnUber
    POPAD
    RETN
 }}
 void Install_UberQuest()
 {
 	static int isInstalled = false;
@ -327,27 +337,41 @@ void Install_UberQuest()
 	DWORD oldProtection;
 	// open Red Portal
-	VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, PAGE_EXECUTE_READWRITE, &oldProtection);
+	VirtualProtect((LPVOID)R8(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4, 2E11D0), 8, PAGE_EXECUTE_READWRITE, &oldProtection);
-	mem_seek R7(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0, FA2C4);
+	mem_seek R8(D2Game, 0000, 0000, 0000, FA480, FA7B8, FA228, FA5F0, FA2C4, 2E11D0);
-	MEMT_DWORD( D2OpenPandPortal , openPandPortal);
+    if (version_D2Game == V114d) {
-	MEMT_DWORD( D2OpenPandFinalPortal , openPandFinalPortal);
+        MEMT_DWORD(0x00565A90, openPandPortal);
        MEMT_DWORD(0x00565AA0, openPandFinalPortal);
    } else {
        MEMT_DWORD(D2OpenPandPortal, openPandPortal);
        MEMT_DWORD(D2OpenPandFinalPortal, openPandFinalPortal);
    }
 	//0201E357  |. FFD0           |CALL EAX
 	//01FA77E7  |. FFD0           |CALL EAX
 	//6FCF3CC7  |. FFD0           |CALL EAX
 	//6FC92437  |. FFD0           |CALL EAX
 	//6FCB7127  |. FFD0           |CALL EAX
-	VirtualProtect((LPVOID)R7(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4), 8, oldProtection, &oldProtection);
+	VirtualProtect((LPVOID)R8(D2Game,0,0,0,FA480,FA7B8, FA228, FA5F0, FA2C4, 2E11D0), 8, oldProtection, &oldProtection);
 	// manage uberIA (fct table at 0209E7E8)
-	VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection);
+	VirtualProtect((LPVOID)(R8(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00, 33CA18) + 145*0x10), 0x30, PAGE_EXECUTE_READWRITE, &oldProtection);
-	mem_seek R7(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618);
+    if (version_D2Game == V114d) {
-	MEMT_DWORD( D2UberBaalIA , uberBaalIA);
+        mem_seek R8(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618, 33D330);
-	mem_seek R7(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628);
+        MEMT_DWORD(0x005FD200, uberBaalIA);
-	MEMT_DWORD( D2UberMephIA , uberMephIA);
+        mem_seek R8(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628, 33D340);
-	mem_seek R7(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638);
+        MEMT_DWORD(0x005F81C0, uberMephIA);
-	MEMT_DWORD( D2UberDiabloIA , uberDiabloIA);
+        mem_seek R8(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638, 33D350);
-	VirtualProtect((LPVOID)(R7(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00) + 145*0x10), 0x30, oldProtection, &oldProtection);
+        MEMT_DWORD(0x005E9DF0, uberDiabloIA);
    } else {
        mem_seek R8(D2Game, 0000, 0000, 0000, 10F100, 10F5E8, 10F870, 10F0A0, 10F618, 33D330);
        MEMT_DWORD(D2UberBaalIA, uberBaalIA);
        mem_seek R8(D2Game, 0000, 0000, 0000, 10F110, 10F5F8, 10F880, 10F0B0, 10F628, 33D340);
        MEMT_DWORD(D2UberMephIA, uberMephIA);
        mem_seek R8(D2Game, 0000, 0000, 0000, 10F120, 10F608, 10F890, 10F0C0, 10F638, 33D350);
        MEMT_DWORD(D2UberDiabloIA, uberDiabloIA);
    }
 	VirtualProtect((LPVOID)(R8(D2Game,0,0,0,10E7E8,10ECD0,10EF58,10E788, 10ED00, 33CA18) + 145*0x10), 0x30, oldProtection, &oldProtection);
 	//0202ADA7  |> B8 E8E70902    MOV EAX,D2Game.0209E7E8
 	//01FD2BE7  |> B8 D0EC0702    MOV EAX,D2Game.0207ECD0
 	//6FC3B597  |> B8 58EFD26F    MOV EAX,D2Game.6FD2EF58
@ -359,8 +383,12 @@ void Install_UberQuest()
 //	MEMJ_REF4( D2WarpPlayer , spawnUber);
 	//02028DAC  |. E8 491CF7FF    CALL <JMP.&D2Common.#10872>
-	mem_seek R7(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB, BE9AB);
+	mem_seek R8(D2Game, 0000, 0000, 0000, E26E2, E6B52, A850B, 2CCAB, BE9AB, 12D1DC);
-	MEMC_REF4( D2Game235C0 , spawnUber);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x00015960, caller_spawnUber);
    } else {
        MEMC_REF4(D2Game235C0, spawnUber);
    }
 	//020726E1  |. E8 2A46FFFF    ||CALL D2Game.02066D10
 	//02056B51  |. E8 6ACAF3FF    ||CALL D2Game.01F935C0
 	//6FCC850A  |. E8 014FF6FF    ||CALL D2Game.6FC2D410
--- a/PlugY/UpdateClient.cpp
+++ b/PlugY/UpdateClient.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Updating client.
@ -66,6 +67,15 @@ DWORD FASTCALL handleClientUpdate(DataPacket* packet)
 	}
 }
 FCT_ASM( caller_handleClientUpdate_114 )
    LEA ECX, DWORD PTR SS : [ESP]
    CALL handleClientUpdate
    POP EDI
    POP ESI
    MOV ESP, EBP
    POP EBP
    RETN
 }}
 FCT_ASM ( caller_handleClientUpdate_111 )
 	LEA ECX,DWORD PTR SS:[ESP+8]
@ -93,8 +103,8 @@ void Install_UpdateClient()
 	log_msg("Patch D2Client for received Item packet. (UpdateClient)\n");
 	// execute if it's our packet else continue
-	mem_seek R7(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896, 84D96);
+	mem_seek R8(D2Client, 14236, 14226, 145B6, 9C6B6, BFE86, 66E06, AE896, 84D96, 5EC99);
-	MEMT_REF4( version_D2Client >= V111  ? 0x000000CF : 0x000000D6, version_D2Client >= V111 ? caller_handleClientUpdate_111 : caller_handleClientUpdate);
+	MEMT_REF4( version_D2Client == V114d ? 0x000000CE : version_D2Client >= V111  ? 0x000000CF : 0x000000D6, version_D2Client == V114d ? caller_handleClientUpdate_114 : version_D2Client >= V111 ? caller_handleClientUpdate_111 : caller_handleClientUpdate);
 	//6FAB45B4  |. 0F87 D6000000  JA D2Client.6FAB4690
 	//6FB4C6B4  |. 0F87 CF000000  JA D2Client.6FB4C789
 	//6FB6FE84  |. 0F87 CF000000  JA D2Client.6FB6FF59
--- a/PlugY/UpdateServer.cpp
+++ b/PlugY/UpdateServer.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	Updating server.
@ -90,6 +91,26 @@ int STDCALL handleServerUpdate(Unit* ptChar, WORD param)
 	}
 }
 FCT_ASM( caller_handleServerUpdate_114 )
    PUSH ESI
    PUSH EBX
    CALL handleServerUpdate
    TEST EAX, EAX
    JNZ END_RCM
    MOV EAX, ESI
    AND EAX, 0xFF
    SHR ESI, 8
    MOV EDI, EAX
    RETN
 END_RCM :
    ADD ESP, 8
    POP EDI
    POP ESI
    XOR EAX, EAX
    POP EBX
    RETN 8
 }}
 FCT_ASM( caller_handleServerUpdate)
 	PUSH ESI
 	PUSH EBX
@ -139,11 +160,11 @@ void Install_UpdateServer()
 	log_msg("Patch D2Game for received button click message. (UpdateServer)\n");
 	// manage button click message from Client.
-	mem_seek R7(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983, 676C3);
+	mem_seek R8(D2Game, 4A702, 4AAC2, 56EA2, 54AE3, 2C773, 975C3, CC983, 676C3, 14BD38);
 	if (version_D2Game >= V111) {
 		memt_byte( 0xC1, 0x57 );	// PUSH EDI
 		memt_byte( 0xEE, 0xE8 );	// CALL caller_handleServerUpdate
-		MEMT_REF4( 0xF88B5708, caller_handleServerUpdate);
+		MEMT_REF4( 0xF88B5708, version_D2Game == V114d ? caller_handleServerUpdate_114 : caller_handleServerUpdate);
 		//01FD4AE3   . C1EE 08        SHR ESI,8
 		//01FD4AE6   . 57             PUSH EDI
 		//01FD4AE7   . 8BF8           MOV EDI,EAX
--- a/PlugY/WorldEvent.cpp
+++ b/PlugY/WorldEvent.cpp
@ -1,6 +1,7 @@
 /*=================================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
 	World Event Management.
@ -119,6 +120,11 @@ DWORD STDCALL verifIfWEItem (Unit* ptItem, DWORD flags, DWORD line, const char*
 	ItemsBIN* ptItemStats = D2GetItemsBIN(ptItem->nTxtFileNo);
 	ItemsBIN* ptWantedItemStats = D2GetItemsBIN(itemNeeded.ID);
    log_msg("D2CheckItemType() = %u\n\n", D2CheckItemType(ptItem, itemNeeded.ID));
    log_msg("D2GetUniqueID() = %u\n\n", D2GetUniqueID(ptItem));
    log_msg("D2isEtheral() = %u\n\n", D2isEtheral2(ptItem, 0, 0, 0, 0, 0, 0));
    log_msg("itemNeeded.ID = %u\n\n", itemNeeded.ID);
 	if((itemNeeded.byItemTypeID && D2CheckItemType(ptItem,itemNeeded.ID))
 	|| (itemNeeded.byItemID && (itemNeeded.ID == 0xFFFF))
 	|| (itemNeeded.byItemID && !itemNeeded.includeUpgradedVersions && ((DWORD)itemNeeded.ID == ptItem->nTxtFileNo))
@ -197,6 +203,32 @@ FCT_ASM ( caller_spawnDClone_111b )
 	RETN 0x14
 }}
 FCT_ASM( caller_spawnDClone_114 )
    PUSH EBX
    PUSH ECX
    PUSH EDX
    PUSH EDI
    PUSH ESI
    PUSH 0
    PUSH EBX
    PUSH 0xFFFFFFFF
    PUSH DWORD PTR SS : [ESP + 0x30]
    PUSH DWORD PTR SS : [ESP + 0x30]
    PUSH DWORD PTR SS : [ESP + 0x30]
    MOV ECX, EDI
    MOV EDX, EAX
    CALL spawnDClone
    POP ESI
    POP EDI
    POP EDX
    POP ECX
    POP EBX
    RETN 0x18
 }}
 FCT_ASM( caller_addClientForWE_111 )
 	PUSH EAX
 	CALL initWorldEventVariables
@ -231,8 +263,12 @@ void Install_WorldEvent()
 	log_msg("Patch D2Game for active World Event. (WorldEvent)\n");
 	// spawn DClone
-	mem_seek R7(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280, CFBD0);
+	mem_seek R8(D2Game, 0000, 0000, 3F720, 4BCB1, ECF10, 41570, 25280, CFBD0, 1A4A4F);
-	MEMC_REF4( V2SpawnMonster , version_D2Game >= V111b ? (DWORD)caller_spawnDClone_111b : version_D2Game == V111 ? (DWORD)caller_spawnDClone_111 : (DWORD)spawnDClone);
+    if (version_D2Client == V114d) {
        MEMT_REF4(0xFFFFBF8D, caller_spawnDClone_114);
    } else {
        MEMC_REF4(V2SpawnMonster, version_D2Game >= V111b ? (DWORD)caller_spawnDClone_111b : version_D2Game == V111 ? (DWORD)caller_spawnDClone_111 : (DWORD)spawnDClone);
    }
    //6FC6F71F  |. E8 FCFAFFFF    CALL D2Game.6FC6F220
 	//01FCBCB0  |. E8 2BEFFFFF    CALL D2Game.01FCABE0                     ; \D2Game.01FCABE0
 	//0205CF0F  |. E8 CCF8FFFF    CALL D2Game.0205C7E0                     ; \D2Game.0205C7E0
@ -241,8 +277,12 @@ void Install_WorldEvent()
 	//6FCEFBCF  |. E8 4CE2FFFF    CALL D2Game.6FCEDE20                     ; \D2Game.6FCEDE20
 	// verify if the item sold is a trigger of WE
-	mem_seek R7(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29, 72BE9);
+	mem_seek R8(D2Game, 0000, 0000, 977D0, 8E799, 92859, 84499, BFB29, 72BE9, 179667);
-	MEMJ_REF4( D2TestFlags , verifIfWEItem);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0x000AEA35, verifIfWEItem);
    } else {
        MEMJ_REF4(D2TestFlags, verifIfWEItem);
    }
 	//6FCC77CF  |. E8 32400500    CALL <JMP.&D2Common.#10707>
 	//0200E798  |. E8 E9BDF7FF    CALL <JMP.&D2Common.#10911>
 	//02002858  |. E8 E57DF7FF    CALL <JMP.&D2Common.#10303>
@ -251,8 +291,12 @@ void Install_WorldEvent()
 	//6FC92BE8  |. E8 DD7AF9FF    CALL <JMP.&D2Common.#10458>
 	// management of the WorldEvent
-	mem_seek R7(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791, E5F51);
+	mem_seek R8(D2Game, 0000, 0000, 3CE0, 51F01, C5681, EBF41, 4A791, E5F51, 1389B1);
-	MEMC_REF4( V2GetGameByClientID , version_D2Game >= V111 ? (DWORD)WEManagement : (DWORD)caller_WEManagement_1XX);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0xFFFF752B, caller_WEManagement_1XX);
    } else {
        MEMC_REF4(V2GetGameByClientID, version_D2Game >= V111 ? (DWORD)WEManagement : (DWORD)caller_WEManagement_1XX);
    }
 	//6FC33CDF   . E8 FC570000    CALL D2Game.6FC394E0
 	//01FD1F00  |. E8 1BE60800    CALL D2Game.02060520
 	//02035680  |. E8 1BF30100    CALL D2Game.020549A0
@ -261,8 +305,13 @@ void Install_WorldEvent()
 	//6FD05F50  |. E8 AB67FDFF    CALL D2Game.6FCDC700
 	// add client for the WorldEvent
-	mem_seek R7(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF, D556F);
+	mem_seek R8(D2Game, 0000, 0000, 1AEF, 3786A, 7055A, 6265F, CB0BF, D556F, 13F2D2);
-	MEMC_REF4( D2AddClient , version_D2Game >= V111 ? caller_addClientForWE_111 : caller_addClientForWE);
+    if (version_D2Game == V114d) {
        MEMT_REF4(0xFFFED27A, caller_addClientForWE);
    }
    else {
        MEMC_REF4(D2AddClient, version_D2Game >= V111 ? caller_addClientForWE_111 : caller_addClientForWE);
    }
 	//6FC31AEE  |. E8 6D510000    CALL D2Game.6FC36C60
 	//01FB7869  |. E8 32C50A00    CALL D2Game.02063DA0
 	//01FE0559  |. E8 B27C0700    CALL D2Game.02058210
--- a/PlugY/d2functions.h
+++ b/PlugY/d2functions.h
@ -1,6 +1,7 @@
 /*================================================
 	File created by Yohann NICOLAS.
 	Add support 1.13d by L'Autour.
    Add support 1.14d by haxifix.
    This file implements some common and useful
    function related to some Diablo II mechanisms.
@ -41,8 +42,8 @@ extern s_shifting shifting;
 #define PCPY ((PYPlayerData*)((DWORD)PCPlayerData+shifting.ptPYPlayerData)) //->ptPYPlayerData
 #define PCSkills (*(Skills**)((DWORD)(ptChar)+shifting.ptSkills)) //->ptSkills
-#define R7(Z,A,B,C,D,E,F,G,H) (offset_##Z + (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A))))))))
+#define R8(Z,A,B,C,D,E,F,G,H,I) (offset_##Z + (version_##Z == V114d? 0x##I : (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A)))))))))
-#define V7(Z,A,B,C,D,E,F,G,H) (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A)))))))
+#define V8(Z,A,B,C,D,E,F,G,H,I) (version_##Z == V114d? 0x##I : (version_##Z == V113d? 0x##H : (version_##Z == V113c? 0x##G : (version_##Z == V112? 0x##F : (version_##Z == V111b? 0x##E : (version_##Z == V111? 0x##D : (version_##Z == V110? 0x##C : (version_##Z == V109d? 0x##B : 0x##A))))))))
 #define RX(v) (WindowStartX+(v))
 #define RY(v) (ResolutionY+NegWindowStartY-(v))
@ -54,9 +55,9 @@ extern s_shifting shifting;
 #define E2S(F, A, R, N, P)	typedef R (STDCALL  *T##N) P; extern T##N N;
 #define E2F(F, A, R, N, P)	typedef R (FASTCALL *T##N) P; extern T##N N;
 #define E2C(F, A, T, N)		extern T* pt##N;
-#define F7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL  *T##N) P; extern T##N N;
+#define F8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) typedef R (X##CALL  *T##N) P; extern T##N N;
-#define A7(X, Z, A,B,C,D,E,F,G,H, R, N, P) typedef R (X##CALL  *T##N) P; extern T##N N;
+#define A8(X, Z, A,B,C,D,E,F,G,H,I, R, N, P) typedef R (X##CALL  *T##N) P; extern T##N N;
-#define C7(Z, A,B,C,D,E,F,G,H, T, N)       extern T* pt##N;
+#define C8(Z, A,B,C,D,E,F,G,H,I, T, N)       extern T* pt##N;
 #include "../Commons/D2Funcs.h"
 extern DataTables* SgptDataTables;
@ -75,9 +76,9 @@ extern DataTables* SgptDataTables;
 //E2F(D2Client,0,	void,		D2CleanStatMouseUp, ());
-#undef F7
+#undef F8
-#undef A7
+#undef A8
-#undef C7
+#undef C8
 #undef D2S
 #undef D2F
 #undef E2S
--- a/PlugY/extraOptions.h
+++ b/PlugY/extraOptions.h
@ -18,6 +18,7 @@ extern int active_EnabledTXTFilesWithMSExcel;
 extern int active_DisplayBaseStatsValue;
 extern int active_LadderRunewords;
 extern int active_EnabledCowPortalWhenCowKingWasKill;
 extern int active_DoNotCloseNihlathakPortal;
 void Install_DisplayItemLevel();
 void Install_SendPlayersCommand();
@ -28,5 +29,6 @@ void Install_EnabledTXTFilesWithMSExcel();
 void Install_DisplayBaseStatsValue();
 void Install_LadderRunewords();
 void Install_EnabledCowPortalWhenCowKingWasKill();
 void Install_DoNotCloseNihlathakPortal();
 /*================================= END OF FILE =================================*/
--- a/PlugY/modifMemory.h
+++ b/PlugY/modifMemory.h
@ -31,4 +31,6 @@ void memc_ref4(DWORD old, DWORD ref);
 #define MEMD_REF4(O, R) memd_ref4((DWORD)(O), (DWORD)(R))
 void memd_ref4(DWORD old, DWORD ref);
 void patchMemory4(DWORD value);
 /*================================= END OF FILE =================================*/
--- a/PlugY/parameters.h
+++ b/PlugY/parameters.h
@ -6,7 +6,7 @@
 =================================================================*/
 #pragma once
-#define PLUGY_VERSION "11.02"
+#define PLUGY_VERSION "12.00"
 enum TargetMod
 {