library Utils uses Typecast, Memory, Bitwise, StringId, ObjectData


    function ConvertHandle takes handle h returns integer
        if GetHandleId( h ) > 0 then
            return RMem( RMem( RMem( RMem( GameState ) + 28 ) + 412 ) + GetHandleId( h ) * 12 - 0x2FFFFF * 4 )
        endif
        return 0
    endfunction

    function ConvertPointer takes integer ptr returns integer
        local integer i = RMem( ptr )
        if i < 0 then
            return RMem( RMem( pointers + 44 ) - i * 8 + 4 ) //checkme
        endif
        return RMem( RMem( pointers + 12 ) + i * 8 + 4 )
    endfunction

    function IsFlagBitSet takes integer flags, integer bit returns boolean
        if bit != 0 then
            return flags / bit * 0x80000000 != 0
        endif
        return false
    endfunction
    
    function GetUnitFlags0x5C takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return RMem( LastConvertedHandle + 0x5C )
        endif
        return 0
    endfunction

    function SetUnitFlags0x5C takes unit u, integer i returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0x5C, i )
        endif
    endfunction

    function AddUnitFlags0x5C takes unit u, integer i returns nothing
        local integer f
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            set f = RMem( LastConvertedHandle + 0x5C )
            if i > 0 then
                if not IsFlagBitSet( f, i ) then
                    call WMem( LastConvertedHandle + 0x5C, f + i )
                endif
            else
                if IsFlagBitSet( f, -i ) then
                    call WMem( LastConvertedHandle + 0x5C, f + i )
                endif
            endif
        endif
    endfunction

//armor types:
// 0 - Light; 1 - Medium; 2 - Heavy; 3 - Fortified; 4 - Normal; 5 - Hero; 6 - Divine; 7 - unarmored; 
//rest seems to have Light properties
    function GetUnitArmorType takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return RMem( LastConvertedHandle + 0xE4 )
        endif
        return 0
    endfunction

    function SetUnitArmorType takes unit u, integer id returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0xE4, id )
        endif
    endfunction

    function GetUnitArmor takes unit u returns real
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return mI2R( RMem( LastConvertedHandle + 0xE0 ) )
        endif
        return 0.
    endfunction

    function SetUnitArmor takes unit u, real r returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0xE0, mR2I( r ) )
        endif
    endfunction

    function SetUnitTypeId takes unit u, integer i returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0x30, i )
        endif
    endfunction

    function GetUnitTypeIdReal takes integer i returns integer
        return RMem( i + 0x30 )
    endfunction

    function GetUnitTypeId2 takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitTypeIdReal( LastConvertedHandle )
        endif
        return 0
    endfunction

    function SetUnitPhased takes unit u returns nothing
        local integer data = GetObjectDataCaching( pUnitData , GetUnitTypeId( u ) ) + 0x1AC
        local integer p1 = RMem( data )
        local integer p2 = RMem( data + 4 )
//	call BJDebugMsg(Int2Hex((data-107)*4))
        call WMem( data, 8 )
        call WMem( data + 4, 16 )
        call SetUnitPathing( u, true )
        call WMem( data, p1 )
        call WMem( data + 4, p2 )
    endfunction

    function GetUnitFlags0x20 takes unit u returns integer
        local integer a = ConvertHandle( u )
        if a > 0 then
            return RMem( a + 0x20 )
        endif
        return 0
    endfunction

    function SetUnitFlags0x20 takes unit u, integer i returns nothing
        local integer a = ConvertHandle( u )
        if a > 0 then
            call WMem( a + 0x20, i )
        endif
    endfunction

    function AddUnitFlags0x20 takes unit u, integer flag returns nothing
        local integer a = ConvertHandle( u )
        local integer f
        if a > 0 then
            set f = RMem( a + 0x20 )
            if IsFlagBitSet( f, flag ) then
                return
            endif
            call WMem( a + 0x20, f + flag )
        endif
    endfunction

    function ModifyUnitFlags0x20 takes unit u, integer flag returns nothing
        local integer a = ConvertHandle( u )
        local integer f
        if a > 0 then
            set f = RMem( a + 0x20 )
            if flag > 0 then
                if IsFlagBitSet( f, flag ) then
                    return
                endif
                call WMem( a + 0x20, f + flag )
            else
                if IsFlagBitSet( f, -flag ) then
                    call WMem( a + 0x20, f + flag )
                endif
            endif
        endif
    endfunction

// Real - addres in memory

    function GetRealPlayerById takes integer i returns integer
        local integer pladdr = RMem( pGlobalPlayerClass )
        if pladdr > 0 then
            return RMem( pladdr + ( i * 4 ) + 0x58 )
        endif
        return 0
    endfunction

    function GetLocalPlayerIdReal takes nothing returns integer
        local integer pladdr = RMem( pGlobalPlayerClass )
        if pladdr > 0 then
            return RMem( pladdr + 0xA )
        endif
        return - 1
    endfunction

    function GetLocalPlayerReal takes nothing returns integer
        return GetRealPlayerById( GetLocalPlayerIdReal( ) )
    endfunction

// Get Selected Unit
    function GetPlayerSelectedUnitReal takes integer realplayer returns integer
        local integer pladdr = realplayer + 0x34
        set pladdr = RMem( pladdr )
        if pladdr > 0 then
            return RMem( pladdr + 0x1E0 )
        endif
        return - 1
    endfunction
    
    function SetPlayerSelectedUnitReal takes integer realplayer, integer pConvertedHandle returns nothing
        local integer pladdr = realplayer + 0x34
        set pladdr = RMem( pladdr )
        if pladdr > 0 then
            call WMem( pladdr + 0x1E0, pConvertedHandle )
        endif
    endfunction
    
    function GetJassContext takes integer id returns integer
        return ReadUnrealMemory( ReadUnrealMemory( ReadUnrealMemory( RMem( pJassEnvAddress ) / 4 + 5 ) / 4 + 36 ) / 4 + id )
    endfunction

    function GetStringAddress takes string s returns integer
        if s == EXTRADLLNAME then
            if ExtraDLLStringAddress == 0 then
                set ExtraDLLStringAddress = ReadUnrealMemory( ReadUnrealMemory( ReadUnrealMemory( ReadUnrealMemory( GetJassContext( 1 ) / 4 + 2589 ) / 4 + 2 ) / 4 + SH2I( EXTRADLLNAME ) * 4 + 2 ) / 4 + 7 )
            endif
            return ExtraDLLStringAddress
        endif
        return ReadUnrealMemory( ReadUnrealMemory( ReadUnrealMemory( ReadUnrealMemory( GetJassContext( 1 ) / 4 + 2589 ) / 4 + 2 ) / 4 + SH2I( s ) * 4 + 2 ) / 4 + 7 )
    endfunction

    function WriteNullTerminatedString takes string s, integer a returns nothing
        call WMem( a, GetStringAddress( s ) )
    endfunction

    function GetDefAddr takes integer id, integer class, integer first, integer currentOffset returns integer
        local integer FirstDataDefEntry
        local integer CurrentDefAddr = 0
        local integer FirstDefAddr
        local integer CurrentDefId = 0
        if first < 1 then
            //set tt_str1 = "Not found DefAddr 0 id=" + I2S( id ) + " class=" + I2S( class )
            call ExecuteFunc( "JassLogWrapper" )
            return 0
        endif
        set FirstDataDefEntry = RMem( first )
        if FirstDataDefEntry > 0 then
            set CurrentDefAddr = RMem( FirstDataDefEntry + 8 )
        endif
        set CurrentDefAddr = CurrentDefAddr + currentOffset
        set FirstDefAddr = CurrentDefAddr
        if FirstDataDefEntry < currentOffset then
            //set tt_str1 = "Not found DefAddr 1 id=" + I2S( id ) + " class=" + I2S( class )
            call ExecuteFunc( "JassLogWrapper" )
            return 0
        endif
        loop
            set CurrentDefId = RMem( CurrentDefAddr + 8 )
//		call echo("CurDefVal: "+Int2Hex(CurrentDefId) +" "+ Int2Hex(CurrentDefAddr))
            if HaveSavedInteger( ObjectDataPointersTable, class, CurrentDefId ) == false and CurrentDefAddr > 0xC then
                call SaveInteger( ObjectDataPointersTable, class, CurrentDefId, CurrentDefAddr - 0xC )
            endif
            exitwhen CurrentDefId == id or CurrentDefAddr < 1
            set CurrentDefAddr = RMem( CurrentDefAddr )
            if CurrentDefAddr < 1 or CurrentDefAddr == FirstDefAddr then
                //set tt_str1 = "Not found DefAddr 2 id=" + I2S( id ) + " class=" + I2S( class )
                call ExecuteFunc( "JassLogWrapper" )
                return 0
            endif
        endloop
        if CurrentDefAddr < 0xD then
            //set tt_str1 = "Not found DefAddr 3 id=" + I2S( id ) + " class=" + I2S( class ) + " curDef=" + I2S( CurrentDefAddr )
            call ExecuteFunc( "JassLogWrapper" )
            return 0
        endif
        set CurrentDefAddr = CurrentDefAddr - 0xC
        if CurrentDefAddr == Actual0xAB5948ForVersion then
            return 0
        endif
        return CurrentDefAddr// as GetObjectData * 4 but search only by id..
    endfunction

    function GetDefAddrCaching takes integer id, integer class, integer first, integer currentOffset returns integer
        if HaveSavedInteger( ObjectDataPointersTable, class, id ) then
//		call echo("loaded")
            return LoadInteger( ObjectDataPointersTable, class, id )
        endif
        return GetDefAddr( id, class, first, currentOffset )
    endfunction

    

//1 = str, 2 = int, 3 = agi
    function GetHeroPrimaryAttribute takes unit u returns integer
        local integer a = ConvertHandle( u )
        if a > 0 then
            set a = RMem( a + 0x1F0 )
            if a > 0 then
                return RMem( a + 0xCC )
            endif
        endif
        return 0
    endfunction

    function SetHeroPrimaryAttribute takes unit u, integer i returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            if IsHeroUnitId( GetUnitTypeId( u ) ) then
                set LastConvertedHandle = RMem( LastConvertedHandle + 0x1F0 )
                if LastConvertedHandle > 0 then
                    call WMem( LastConvertedHandle + 0xCC, i )
                endif
            endif
        endif
    endfunction

    function SetAbilityManaCost takes integer abil, integer level, integer cost returns nothing
        local integer a = GetObjectDataCaching( pAbilityData, abil )
        if a > 0 then
            set a = RMem( a + 0x54 )
            if a > 0 then
                call WMem( a - 0x58 + level * 0x68, cost )
            endif
        endif
    endfunction

    function GetAbilityManaCost takes integer abil, integer level returns integer
        local integer a = GetObjectDataCaching( pAbilityData, abil )
        if a > 0 then
            set a = RMem( a + 0x54 )
            if a > 0 then
                return RMem( a - 0x58 + level * 0x68 )
            endif
        endif
        return 0
    endfunction

    function GetAbilityManaCostAddr takes integer add, integer level returns integer
        local integer a = RMem( add + 0x54 )
        if a > 0 then
            return RMem( a + level * 0x68 )
        endif
        return 0
    endfunction

    function SetAbilityManaCostAddr takes integer add, integer level, integer mc returns nothing
        local integer a = RMem( add + 0x54 )
        if a > 0 then
            call WMem( a + level * 0x68, mc )
        endif
    endfunction

    function SetAbilityCD takes integer abil, integer level, real cool returns nothing
        local integer a = GetObjectDataCaching( pAbilityData, abil )
        if a > 0 then
            set a = RMem( a + 0x54 )
            if a > 0 then
                call WMem( a - 0x54 + level * 0x68, mR2I( cool ) )
            endif
        endif
    endfunction

    function GetAbilityCD takes integer abil, integer level returns real
        local integer a = GetObjectDataCaching( pAbilityData, abil )
        if abil == 'A1P8'then//DotA - specific, charge of darkness
            return 12.
        endif
        if a > 0 then
            set a = RMem( a + 0x54 )
            if a > 0 then
                return mI2R( RMem( a - 0x54 + level * 0x68 ) )
            endif
        endif
        return 0.
    endfunction

    function GetAbilityMaxLevel takes integer abil returns integer
        local integer a
        if abil == 0 then
            return 0
        endif
        set a = GetObjectDataCaching( pAbilityData, abil )
        if a > 0 then
            return RMem( a + 0x50 )
        endif
        return 0
    endfunction

    function AddAbilityCooldownConverted takes integer a, real seconds returns nothing
        local integer pData = RMem( a + 0xDC )
        if pData > 0 then
            call WMem( pData + 4, mR2I( seconds + mI2R( RMem( pData + 4 ) ) ) )
        endif
    endfunction

    function GetAbilityCurrentCooldownConverted takes integer a returns real
        local integer pData = RMem( a + 0xDC )
        if pData > 0 then
            return mI2R( RMem( pData + 4 ) ) - mI2R( RMem( RMem( pData + 0xC ) + 0x40 ) )
        endif
        return .0
    endfunction

//function GetRealGameTime takes nothing returns integer 
//desync-able, do not use
//returns ms value (1s = 1000 here)
//	return RMem(pGameTime)
//endfunction

    function IsAbilityOnCooldown takes integer a returns boolean
        return IsFlagBitSet( RMem( a + 0x20 ), 512 )
    endfunction

    function SetAbilityDisabled takes integer pAbility, integer count returns nothing
        if pAbility > 0 then
            call WMem( pAbility + 0x3C, count )
        endif
	//not safe unless used with PauseUnit. Button will be blacked, but current casts of that ability won’t be interrupted.
    endfunction

    function GetAbilityDisabledCount takes integer pAbility returns integer
        if pAbility > 0 then
            return RMem( pAbility + 0x3C )
        endif
        return 0
    endfunction

    function SetAbilityHidden takes integer pAbility, integer count returns nothing
        call WMem( pAbility + 0x40, count )
	//This one is 100% safe. This hides the ability button, and order can’t be issued.
    endfunction

    function AddAbilityHidden takes integer a, integer d returns nothing
        call WMem( a + 0x40, RMem( a + 0x40 ) + d )
    endfunction

    function SetAbilityDisabled2 takes integer pAbility, integer count returns nothing
        call WMem( pAbility + 0x44, count )
	//This one is used by Orb of Slow or Windwalk. Button is blacked, but cooldown is stil displayed.
    endfunction

    function GetAbilityDisabled2 takes integer pAbility returns integer
        return RMem( pAbility + 0x44 )
    endfunction

    function DisableUnitsMovement takes unit u, boolean disable returns nothing
        local integer i = 2
        local integer a = GetHandleId( u )
        if a < 1 then
            return
        endif
        if disable == false then
            set i = 1
        endif
        call PauseUnit( u, true )
        set a = ConvertHandle( u )
        if a > 0 then
            set a = RMem( a + 0x1EC )
            if a > 0 then
                call SetAbilityDisabled( a, i )
            endif
        endif
        call PauseUnit( u, false )
    endfunction
//pointer to 'Amov' is located at offset 123 of unit object, Aatk is at offset 122, and AInv is offset 124

//Hides all command buttons and sets the Ward flag. Unit will keep its current order, and player can’t give new orders
//Notice the the unit can’t be ordered with triggers as well. To issue an order you need to temporarily reenable control
    function DisableUnitControl takes unit u returns nothing
        local integer pUnit = ConvertHandle( u )
        local integer flags
        local integer Amov
        local integer Aatk
        local integer AInv
        if pUnit > 0 then
            set flags = RMem( pUnit + 0x248 )
            set Amov = RMem( pUnit + 0x1EC )
            set Aatk = RMem( pUnit + 0x1E8 )
            set AInv = RMem( pUnit + 0x1F8 )
	//	call echo("disabled on "+GetUnitName(u))
            if not IsFlagBitSet( flags, 512 ) then
                call WMem( pUnit + 0x248, flags + 512 )
            endif
            if Amov > 0 then
                call WMem( Amov + 0x40, RMem( Amov + 0x40 ) + 1 )
            endif
            if Aatk > 0 then
                call WMem( Aatk + 0x40, RMem( Aatk + 0x40 ) + 1 )
            endif
            if AInv > 0 then
                call WMem( AInv + 0x3C, RMem( AInv + 0x3C ) + 1 )
            endif
		
        endif
    endfunction

//Removes the Ward flag and reenables Amov and Aatk
    function EnableUnitControl takes unit u returns nothing
        local integer pUnit = ConvertHandle( u )
        local integer flags
        local integer Amov
        local integer Aatk
        local integer AInv
        if pUnit > 0 then
            set flags = RMem( pUnit + 0x248 )
            set Amov = RMem( pUnit + 0x1EC )
            set Aatk = RMem( pUnit + 0x1E8 )
            set AInv = RMem( pUnit + 0x1F8 )
	//	call echo("disabled on "+GetUnitName(u))
            if IsFlagBitSet( flags, 512 ) then
                call WMem( pUnit + 0x248, flags - 512 )
            endif
            if Amov > 0 then
                call WMem( Amov + 0x40, RMem( Amov + 0x40 ) - 1 )
            endif
            if Aatk > 0 then
                call WMem( Aatk + 0x40, RMem( Aatk + 0x40 ) - 1 )
            endif
            if AInv > 0 then
                call WMem( AInv + 0x3C, RMem( AInv + 0x3C ) - 1 )
            endif
        endif
    endfunction

    function SetUnitPortrait takes integer uiobjectaddr, string s returns nothing
        call WriteNullTerminatedString( s, uiobjectaddr + 0x34 )
    endfunction

    function SetUnitModel takes integer uiobjectaddr, string s returns nothing
        call WriteNullTerminatedString( s, uiobjectaddr + 0x30 )
    endfunction

    function SetUnitModelUFAddress takes integer address, string s returns nothing
        call SetUnitModel( address, s )
    endfunction

    function GetUnitAttackAbilityForAddress takes integer pConvertedHandle returns integer
        return RMem( pConvertedHandle + 0x1E8 )
    endfunction

    function GetUnitAttackAbility takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitAttackAbilityForAddress( LastConvertedHandle )
        endif
        return 0
    endfunction

    function SetUnitAttackAbilityForAddress takes integer pConvertedHandle, integer pAddr returns nothing
        call WMem( pConvertedHandle + 0x1E8, pAddr )
    endfunction

    function SetUnitAttackAbility takes unit u , integer pAddr returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call SetUnitAttackAbilityForAddress( LastConvertedHandle, pAddr )
        endif
    endfunction

    function GetUnitMoveAbilityForAddress takes integer pConvertedHandle returns integer
        return RMem( pConvertedHandle + 0x1EC )
    endfunction

    function GetUnitMoveAbility takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitMoveAbilityForAddress( LastConvertedHandle )
        endif
        return 0
    endfunction

    function SetUnitMoveAbilityForAddress takes integer pConvertedHandle, integer pAddr returns nothing
        call WMem( pConvertedHandle + 0x1EC, pAddr )
    endfunction

    function SetUnitMoveAbility takes unit u, integer pAddr returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call SetUnitMoveAbilityForAddress( LastConvertedHandle, pAddr )
        endif
    endfunction

    function GetUnitHeroAbilityForAddress takes integer pConvertedHandle returns integer
        return RMem( pConvertedHandle + 0x1F0 )
    endfunction

    function GetUnitHeroAbility takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitHeroAbilityForAddress( LastConvertedHandle )
        endif
        return 0
    endfunction

    function GetUnitBuildAbilityForAddress takes integer pConvertedHandle returns integer
        return RMem( pConvertedHandle + 0x1F4 )
    endfunction

    function GetUnitBuildAbility takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitBuildAbilityForAddress( LastConvertedHandle )
        endif
        return 0
    endfunction

    function GetUnitInventoryAbilityForAddress takes integer pConvertedHandle returns integer
        return RMem( pConvertedHandle + 0x1F8 )
    endfunction

    function GetUnitInventoryAbility takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return GetUnitInventoryAbilityForAddress( LastConvertedHandle )
        endif
        return 0
    endfunction


// Alternative for sub_6F4786B0 (126a)
    function GetSomeAddress takes integer pAddr1 , integer pAddr2 returns integer
//I just split your function into 2, it should be working as before
        local integer pOff1 = 0x2C
        if pAddr1 == -1 and pAddr2 == -1 then
            return 0
        endif
        if pAddr1 >= 0 then
            set pOff1 = 0xC
        endif
        set pOff1 = RMem( pGameClass1 ) + pOff1
        set pOff1 = RMem( pOff1 )
        if pOff1 == 0 then
            return 0
        endif
	
        set pOff1 = RMem( pOff1 + 8 * pAddr1 + 4 )
        if pOff1 == 0 or RMem( pOff1 + 0x18 ) != pAddr2 then
            return 0
        endif
        return pOff1
    endfunction

    function GetSomeAddressForAbility takes integer pAddr1 , integer pAddr2 returns integer //Second part of GetSomeAddressForAbility
        local integer pOff1 = GetSomeAddress( pAddr1, pAddr2 )
        if pOff1 == 0 or RMem( pOff1 + 0x20 ) != 0 then
            return 0
        endif
        return RMem( pOff1 + 0x54 )
    endfunction

    function GetSomeAddressForLocustFlags takes integer pAddr1 , integer pAddr2 returns integer
        local integer i = GetSomeAddress( pAddr1, pAddr2 )
        return RMem( i + 0x94 )
    endfunction

    function SetLocustFlags takes unit u, integer i returns nothing //These flags can make unit immune to truesight
        local integer pOff1
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            set LastConvertedHandle = LastConvertedHandle + 0x16C
            set pOff1 = GetSomeAddressForLocustFlags( RMem( LastConvertedHandle ), RMem( LastConvertedHandle + 4 ) )
            if pOff1 > 0 then
                call WMem( pOff1 + 0x34, i )
            endif
        endif
    endfunction

    function EnableTruesightImmunity takes unit u returns nothing
//I don’t really know what other side effects may be caused by this, at least GroupEnum is not affected
        call SetLocustFlags( u, 0x08000000 )
    endfunction

    function DisableTruesightImmunity takes unit u returns nothing
        call SetLocustFlags( u, 0 )
    endfunction

    function UnStunUnit takes unit u returns nothing
	//unsafe, do not use unless you tested it through
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0x198, 0 )
        endif
    endfunction

    function IsUnitStunned2 takes unit u returns boolean
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return RMem( LastConvertedHandle + 0x198 ) > 0
        endif
        return false
    endfunction

    function IsUnitInvulnerable takes unit u returns boolean // проверяет только флаг неуязвимости
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return IsFlagBitSet( RMem( LastConvertedHandle + 0x20 ), 8 )
        endif
        return false
    endfunction

    function IsUnitInvulnerable2 takes unit u returns boolean // проверяет только счетчик неуязвимости
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return RMem( LastConvertedHandle + 0xE8 ) > 0
        endif
        return false
    endfunction

    function GetUnitInvulnerableCounter takes unit u returns integer
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            return RMem( LastConvertedHandle + 0xE8 )
        endif
        return 0
    endfunction

    function SetUnitInvulnerableCounter takes unit u, integer i returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0xE8, i )
        endif
    endfunction

    function ModifyInvulnerableCounter takes unit u, integer diff returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call WMem( LastConvertedHandle + 0xE8, RMem( LastConvertedHandle + 0xE8 ) + diff )
        endif
    endfunction

    function GetUnitAbilityForAddresss takes integer pConvertedHandle, integer abilid returns integer
        local integer pAddr1 = pConvertedHandle + 0x1DC
        local integer pAddr2 = pConvertedHandle + 0x1E0
        local integer pOff1 = 0
        set pAddr1 = RMem( pAddr1 )
        set pAddr2 = RMem( pAddr2 )
        if pAddr1 == 0 or pAddr2 == 0 or ( pAddr1 == -1 and pAddr2 == -1 ) then
            return 0
        endif
        set pOff1 = GetSomeAddressForAbility( pAddr1, pAddr2 )
        loop
            exitwhen pOff1 <= 0
            if RMem( pOff1 + 0x34 ) == abilid then
                return pOff1
            endif
            set pOff1 = GetSomeAddressForAbility( RMem( pOff1 + 0x24 ), RMem( pOff1 + 0x28 ) )
        endloop
        return pOff1
    endfunction

    function GetAbilityOrderID takes integer pAbility returns integer
        local integer pOffset2
        if pAbility < 1 then
            return 0
        endif
//	call BJDebugMsg(Int2Hex(pAbility)+" sent")
//	call PolledWait(1.)

	//  mov ecx,[esp+04]
	//  mov edx,[ecx+6C]
	//  cmp edx,D0142 { 852290 }
	//  je 0493413A
	//  mov eax,00000000 { 0 }
	//  ret 
	//  mov ecx,[ecx]
	//  mov ecx,[ecx+00000308]
	//  call ecx
	//  ret 
	
        if RMem( pGetAbilityOrderID ) == 0 then
            call WMem( pGetAbilityOrderID, 0x04244C8B )
            call WMem( pGetAbilityOrderID + 4, 0x816C518B )
            call WMem( pGetAbilityOrderID + 8, 0x0D0142FA )
            call WMem( pGetAbilityOrderID + 12, 0xB8067400 )
            call WMem( pGetAbilityOrderID + 16, 0x00000000 )
            call WMem( pGetAbilityOrderID + 20, 0x8B098BC3 )
            call WMem( pGetAbilityOrderID + 24, 0x00030889 )
            call WMem( pGetAbilityOrderID + 28, 0x90E1FF00 )
        endif
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pGetAbilityOrderID )
        else
            call WMem( pIgnoredUnitsOffset, pGetAbilityOrderID )
        endif
	

        if pIgnoredUnitsOffset != 0 then
            set pOffset2 = IgnoredUnits( pAbility )
            call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
            return pOffset2
        endif
	
        return 0
    endfunction

    function PrintAllUnitAbilities takes integer pConvertedHandle returns nothing
        local integer pAddr1 = pConvertedHandle + 476
        local integer pAddr2 = pConvertedHandle + 480

        local integer pOff1 = 0

        set pAddr1 = RMem( pAddr1 )
        set pAddr2 = RMem( pAddr2 )
        if pAddr1 == 0 or pAddr2 == 0 or BitwiseAnd( pAddr1, pAddr2 ) == -1 then
            return
        endif

        set pOff1 = GetSomeAddressForAbility( pAddr1, pAddr2 )
	
        if pOff1 == 0 then
            return
        endif
	
        loop
            exitwhen pOff1 == 0

            call DisplayTimedTextToPlayer( GetLocalPlayer( ), 0.0, 0.0, 40, "Address:" + Int2Hex( pOff1 ) + ". ID:" + Id2String( RMem( pOff1 + 52 ) ) + " name: " + GetObjectName( RMem( pOff1 + 52 ) ) )
		
            set pOff1 = GetSomeAddressForAbility( RMem( pOff1 + 36 ), RMem( pOff1 + 40 ) )
        endloop
	
    endfunction

    function GetAllUnitAbilities takes unit u returns nothing
        local integer pConvertedHandle = ConvertHandle( u )
        local integer pAddr1
        local integer pAddr2
        local integer i = 0
        local integer h = GetHandleId( u )
        local integer pOff1 = 0
        local integer id
        call FlushChildHashtable( gg_htb_HashData, h )
        if pConvertedHandle < 1 then
            return
        endif
        set pAddr1 = pConvertedHandle + 0x1DC
        set pAddr2 = pConvertedHandle + 0x1E0
        set pAddr1 = RMem( pAddr1 )
        set pAddr2 = RMem( pAddr2 )
        if ( pAddr1 == -1 and pAddr2 == -1 ) or pAddr1 == 0 or pAddr2 == 0 then
            return
        endif
        set pOff1 = GetSomeAddressForAbility( pAddr1, pAddr2 )
        loop
            exitwhen pOff1 <= 0
            set id = RMem( pOff1 + 0x34 )
            if id != 'Amov' and id != 'AHer' and id != 'Aatk' and id != 'AInv' then
                call SaveInteger( gg_htb_HashData, h, i, pOff1 )//address
                call SaveInteger( gg_htb_HashData, h + 1, i, RMem( pOff1 + 0x34 ) )//ability id
                set i = i + 1
            endif
            set pOff1 = GetSomeAddressForAbility( RMem( pOff1 + 36 ), RMem( pOff1 + 40 ) )
        endloop
        call SaveInteger( gg_htb_HashData, 'abil', 0, i )
    endfunction


    function CallFastCallWith1Args takes integer pFuncFastcallAddr, integer arg1 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith1Args ) == 0 then
            call WMem( pCallFastCallWith1Args, 0xB9F68B56 )
            call WMem( pCallFastCallWith1Args + 8, 0xBEF68B90 )
            call WMem( pCallFastCallWith1Args + 16, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith1Args + 4, arg1 )
        call WMem( pCallFastCallWith1Args + 12, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith1Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith1Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction


    function CallFastCallWith2Args takes integer pFuncFastcallAddr, integer arg1, integer arg2 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith2Args ) == 0 then
            call WMem( pCallFastCallWith2Args, 0xBAF68B56 )
            call WMem( pCallFastCallWith2Args + 8, 0xB9F68B90 )
            call WMem( pCallFastCallWith2Args + 16, 0xBEF68B90 )
            call WMem( pCallFastCallWith2Args + 24, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith2Args + 4, arg2 )
        call WMem( pCallFastCallWith2Args + 12, arg1 )
        call WMem( pCallFastCallWith2Args + 20, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith2Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith2Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction


    function CallFastCallWith3Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith3Args ) == 0 then
            call WMem( pCallFastCallWith3Args, 0x68F68B56 )
            call WMem( pCallFastCallWith3Args + 8, 0xBAF68B90 )
            call WMem( pCallFastCallWith3Args + 16, 0xB9F68B90 )
            call WMem( pCallFastCallWith3Args + 24, 0xBEF68B90 )
            call WMem( pCallFastCallWith3Args + 32, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith3Args + 4, arg3 )
        call WMem( pCallFastCallWith3Args + 12, arg2 )
        call WMem( pCallFastCallWith3Args + 20, arg1 )
        call WMem( pCallFastCallWith3Args + 28, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith3Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith3Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function FUCKINGCallWith4Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4 returns integer
        local integer pOffset1
        if RMem( pFUCKINGCallWith4Args ) == 0 then
            call WMem( pFUCKINGCallWith4Args, 0x68F68B56 )
            call WMem( pFUCKINGCallWith4Args + 8, 0x68F68B90 )
            call WMem( pFUCKINGCallWith4Args + 16, 0xB8F68B90 )
            call WMem( pFUCKINGCallWith4Args + 24, 0xBFF68B90 )
            call WMem( pFUCKINGCallWith4Args + 32, 0xBEF68B90 )
            call WMem( pFUCKINGCallWith4Args + 40, 0xC35ED6FF )
        endif
        call WMem( pFUCKINGCallWith4Args + 4, arg4 )
        call WMem( pFUCKINGCallWith4Args + 12, arg3 )
        call WMem( pFUCKINGCallWith4Args + 20, arg2 )
        call WMem( pFUCKINGCallWith4Args + 28, arg1 )
        call WMem( pFUCKINGCallWith4Args + 36, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pFUCKINGCallWith4Args )
        else
            call WMem( pIgnoredUnitsOffset, pFUCKINGCallWith4Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallFastCallWith4Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith4Args ) == 0 then
            call WMem( pCallFastCallWith4Args, 0x68F68B56 )
            call WMem( pCallFastCallWith4Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith4Args + 16, 0xBAF68B90 )
            call WMem( pCallFastCallWith4Args + 24, 0xB9F68B90 )
            call WMem( pCallFastCallWith4Args + 32, 0xBEF68B90 )
            call WMem( pCallFastCallWith4Args + 40, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith4Args + 4, arg4 )
        call WMem( pCallFastCallWith4Args + 12, arg3 )
        call WMem( pCallFastCallWith4Args + 20, arg2 )
        call WMem( pCallFastCallWith4Args + 28, arg1 )
        call WMem( pCallFastCallWith4Args + 36, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith4Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith4Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallFastCallWith5Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith5Args ) == 0 then
            call WMem( pCallFastCallWith5Args, 0x68F68B56 )
            call WMem( pCallFastCallWith5Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith5Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith5Args + 24, 0xBAF68B90 )
            call WMem( pCallFastCallWith5Args + 32, 0xB9F68B90 )
            call WMem( pCallFastCallWith5Args + 40, 0xBEF68B90 )
            call WMem( pCallFastCallWith5Args + 48, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith5Args + 4, arg5 )
        call WMem( pCallFastCallWith5Args + 12, arg4 )
        call WMem( pCallFastCallWith5Args + 20, arg3 )
        call WMem( pCallFastCallWith5Args + 28, arg2 )
        call WMem( pCallFastCallWith5Args + 36, arg1 )
        call WMem( pCallFastCallWith5Args + 44, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith5Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith5Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallFastCallWith6Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5, integer arg6 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith6Args ) == 0 then
            call WMem( pCallFastCallWith6Args, 0x68F68B56 )
            call WMem( pCallFastCallWith6Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith6Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith6Args + 24, 0x68F68B90 )
            call WMem( pCallFastCallWith6Args + 32, 0xBAF68B90 )
            call WMem( pCallFastCallWith6Args + 40, 0xB9F68B90 )
            call WMem( pCallFastCallWith6Args + 48, 0xBEF68B90 )
            call WMem( pCallFastCallWith6Args + 56, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith6Args + 4, arg6 )
        call WMem( pCallFastCallWith6Args + 12, arg5 )
        call WMem( pCallFastCallWith6Args + 20, arg4 )
        call WMem( pCallFastCallWith6Args + 28, arg3 )
        call WMem( pCallFastCallWith6Args + 36, arg2 )
        call WMem( pCallFastCallWith6Args + 44, arg1 )
        call WMem( pCallFastCallWith6Args + 52, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith6Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith6Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction
    
    function CallFastCallWith7Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5, integer arg6, integer arg7 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith7Args ) == 0 then
            call WMem( pCallFastCallWith7Args, 0x68F68B56 )
            call WMem( pCallFastCallWith7Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith7Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith7Args + 24, 0x68F68B90 )
            call WMem( pCallFastCallWith7Args + 32, 0x68F68B90 )
            call WMem( pCallFastCallWith7Args + 40, 0xBAF68B90 )
            call WMem( pCallFastCallWith7Args + 48, 0xB9F68B90 )
            call WMem( pCallFastCallWith7Args + 56, 0xBEF68B90 )
            call WMem( pCallFastCallWith7Args + 64, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith7Args + 4, arg7 )
        call WMem( pCallFastCallWith7Args + 12, arg6 )
        call WMem( pCallFastCallWith7Args + 20, arg5 )
        call WMem( pCallFastCallWith7Args + 28, arg4 )
        call WMem( pCallFastCallWith7Args + 36, arg3 )
        call WMem( pCallFastCallWith7Args + 44, arg2 )
        call WMem( pCallFastCallWith7Args + 52, arg1 )
        call WMem( pCallFastCallWith7Args + 60, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith7Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith7Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction
    
    function CallFastCallWith8Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5, integer arg6, integer arg7, integer arg8 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith8Args ) == 0 then
            call WMem( pCallFastCallWith8Args, 0x68F68B56 )
            call WMem( pCallFastCallWith8Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith8Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith8Args + 24, 0x68F68B90 )
            call WMem( pCallFastCallWith8Args + 32, 0x68F68B90 )
            call WMem( pCallFastCallWith8Args + 40, 0x68F68B90 )
            call WMem( pCallFastCallWith8Args + 48, 0xBAF68B90 )
            call WMem( pCallFastCallWith8Args + 56, 0xB9F68B90 )
            call WMem( pCallFastCallWith8Args + 64, 0xBEF68B90 )
            call WMem( pCallFastCallWith8Args + 72, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith8Args + 4, arg8 )
        call WMem( pCallFastCallWith8Args + 12, arg7 )
        call WMem( pCallFastCallWith8Args + 20, arg6 )
        call WMem( pCallFastCallWith8Args + 28, arg5 )
        call WMem( pCallFastCallWith8Args + 36, arg4 )
        call WMem( pCallFastCallWith8Args + 44, arg3 )
        call WMem( pCallFastCallWith8Args + 52, arg2 )
        call WMem( pCallFastCallWith8Args + 60, arg1 )
        call WMem( pCallFastCallWith8Args + 68, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith8Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith8Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallFastCallWith11Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5, integer arg6, integer arg7, integer arg8, integer arg9, integer arg10, integer arg11 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith11Args ) == 0 then
            call WMem( pCallFastCallWith11Args, 0x68F68B56 )
            call WMem( pCallFastCallWith11Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 24, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 32, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 40, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 48, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 56, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 64, 0x68F68B90 )
            call WMem( pCallFastCallWith11Args + 72, 0xBAF68B90 )
            call WMem( pCallFastCallWith11Args + 80, 0xB9F68B90 )
            call WMem( pCallFastCallWith11Args + 88, 0xBEF68B90 )
            call WMem( pCallFastCallWith11Args + 96, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith11Args + 4, arg11 )
        call WMem( pCallFastCallWith11Args + 12, arg10 )
        call WMem( pCallFastCallWith11Args + 20, arg9 )
        call WMem( pCallFastCallWith11Args + 28, arg8 )
        call WMem( pCallFastCallWith11Args + 36, arg7 )
        call WMem( pCallFastCallWith11Args + 44, arg6 )
        call WMem( pCallFastCallWith11Args + 52, arg5 )
        call WMem( pCallFastCallWith11Args + 60, arg4 )
        call WMem( pCallFastCallWith11Args + 68, arg3 )
        call WMem( pCallFastCallWith11Args + 76, arg2 )
        call WMem( pCallFastCallWith11Args + 84, arg1 )
        call WMem( pCallFastCallWith11Args + 92, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith11Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith11Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallFastCallWith12Args takes integer pFuncFastcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5, integer arg6, integer arg7, integer arg8, integer arg9, integer arg10, integer arg11, integer arg12 returns integer
        local integer pOffset1
        if RMem( pCallFastCallWith12Args ) == 0 then
            call WMem( pCallFastCallWith12Args, 0x68F68B56 )
            call WMem( pCallFastCallWith12Args + 8, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 16, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 24, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 32, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 40, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 48, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 56, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 64, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 72, 0x68F68B90 )
            call WMem( pCallFastCallWith12Args + 80, 0xBAF68B90 )
            call WMem( pCallFastCallWith12Args + 88, 0xB9F68B90 )
            call WMem( pCallFastCallWith12Args + 96, 0xBEF68B90 )
            call WMem( pCallFastCallWith12Args + 104, 0xC35ED6FF )
        endif
        call WMem( pCallFastCallWith12Args + 4, arg12 )
        call WMem( pCallFastCallWith12Args + 12, arg11 )
        call WMem( pCallFastCallWith12Args + 20, arg10 )
        call WMem( pCallFastCallWith12Args + 28, arg9 )
        call WMem( pCallFastCallWith12Args + 36, arg8 )
        call WMem( pCallFastCallWith12Args + 44, arg7 )
        call WMem( pCallFastCallWith12Args + 52, arg6 )
        call WMem( pCallFastCallWith12Args + 60, arg5 )
        call WMem( pCallFastCallWith12Args + 68, arg4 )
        call WMem( pCallFastCallWith12Args + 76, arg3 )
        call WMem( pCallFastCallWith12Args + 84, arg2 )
        call WMem( pCallFastCallWith12Args + 92, arg1 )
        call WMem( pCallFastCallWith12Args + 100, pFuncFastcallAddr )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallFastCallWith12Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallFastCallWith12Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallThisCallWith1Args takes integer pFuncThiscallAddr, integer arg1 returns integer
        return CallFastCallWith2Args( pFuncThiscallAddr, arg1, 0 )
    endfunction

    function CallThisCallWith2Args takes integer pFuncThiscallAddr, integer arg1, integer arg2 returns integer
        return CallFastCallWith3Args( pFuncThiscallAddr, arg1, 0, arg2 )
    endfunction

    function CallThisCallWith3Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3 returns integer
        return CallFastCallWith4Args( pFuncThiscallAddr, arg1, 0, arg2, arg3 )
    endfunction

    function CallThisCallWith4Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4 returns integer
        return CallFastCallWith5Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4 )
    endfunction

    function CallThisCallWith5Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4, integer arg5 returns integer
        return CallFastCallWith6Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4, arg5 )
    endfunction

    function CallThisCallWith6Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4, integer arg5, integer arg6 returns integer
        return CallFastCallWith7Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4, arg5, arg6 )
    endfunction

    function CallThisCallWith7Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4, integer arg5, integer arg6, integer arg7 returns integer
        return CallFastCallWith8Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4, arg5, arg6, arg7 )
    endfunction

    function CallThisCallWith10Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4, integer arg5, integer arg6, integer arg7, integer arg8, integer arg9, integer arg10 returns integer
        return CallFastCallWith11Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 )
    endfunction

    function CallThisCallWith11Args takes integer pFuncThiscallAddr, integer arg1, integer arg2, integer arg3, integer arg4, integer arg5, integer arg6, integer arg7, integer arg8, integer arg9, integer arg10, integer arg11 returns integer
        return CallFastCallWith12Args( pFuncThiscallAddr, arg1, 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11 )
    endfunction
    
    function CallStdcallWith1Args takes integer pFuncStdcallAddr, integer arg1 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith1Args ) == 0 then
            call WMem( pCallStdcallWith1Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith1Args + 8, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith1Args + 16, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith1Args + 4, arg1 ) // push arg1
        call WMem( pCallStdcallWith1Args + 12, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith1Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith1Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallStdcallWith2Args takes integer pFuncStdcallAddr, integer arg1, integer arg2 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith2Args ) == 0 then
            call WMem( pCallStdcallWith2Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith2Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith2Args + 16, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith2Args + 24, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith2Args + 4, arg2 ) // push arg2
        call WMem( pCallStdcallWith2Args + 12, arg1 ) // push arg1
        call WMem( pCallStdcallWith2Args + 20, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith2Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith2Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallStdcallWith3Args takes integer pFuncStdcallAddr, integer arg1, integer arg2, integer arg3 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith3Args ) == 0 then
            call WMem( pCallStdcallWith3Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith3Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith3Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith3Args + 24, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith3Args + 32, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith3Args + 4, arg3 ) // push arg3
        call WMem( pCallStdcallWith3Args + 12, arg2 ) // push arg2
        call WMem( pCallStdcallWith3Args + 20, arg1 ) // push arg1
        call WMem( pCallStdcallWith3Args + 28, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith3Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith3Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallStdcallWith4Args takes integer pFuncStdcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith4Args ) == 0 then
            call WMem( pCallStdcallWith4Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith4Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith4Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith4Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith4Args + 32, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith4Args + 40, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith4Args + 4, arg4 ) // push arg4
        call WMem( pCallStdcallWith4Args + 12, arg3 ) // push arg3
        call WMem( pCallStdcallWith4Args + 20, arg2 ) // push arg2
        call WMem( pCallStdcallWith4Args + 28, arg1 ) // push arg1
        call WMem( pCallStdcallWith4Args + 36, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith4Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith4Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallStdcallWith5Args takes integer pFuncStdcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith5Args ) == 0 then
            call WMem( pCallStdcallWith5Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith5Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith5Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith5Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith5Args + 32, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith5Args + 40, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith5Args + 48, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith5Args + 4, arg5 ) // push arg5
        call WMem( pCallStdcallWith5Args + 12, arg4 ) // push arg4
        call WMem( pCallStdcallWith5Args + 20, arg3 ) // push arg3
        call WMem( pCallStdcallWith5Args + 28, arg2 ) // push arg2
        call WMem( pCallStdcallWith5Args + 36, arg1 ) // push arg1
        call WMem( pCallStdcallWith5Args + 44, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith5Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith5Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallStdcallWith6Args takes integer pFuncStdcallAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5 , integer arg6 returns integer
        local integer pOffset1
        if RMem( pCallStdcallWith6Args ) == 0 then
            call WMem( pCallStdcallWith6Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 32, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 40, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallStdcallWith6Args + 48, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallStdcallWith6Args + 56, 0xC359D1FF ) // call ecx, pop ecx, ret
        endif
        call WMem( pCallStdcallWith6Args + 4, arg6 ) // push arg6
        call WMem( pCallStdcallWith6Args + 12, arg5 ) // push arg5
        call WMem( pCallStdcallWith6Args + 20, arg4 ) // push arg4
        call WMem( pCallStdcallWith6Args + 28, arg3 ) // push arg3
        call WMem( pCallStdcallWith6Args + 36, arg2 ) // push arg2
        call WMem( pCallStdcallWith6Args + 44, arg1 ) // push arg1
        call WMem( pCallStdcallWith6Args + 52, pFuncStdcallAddr ) // mov ecx, pFuncStdcallAddr
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallStdcallWith6Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallStdcallWith6Args )
        endif
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith1Args takes integer pFuncCdeclAddr, integer arg1 returns integer
        local integer pOffset1
        if RMem( pCallCdeclWith1Args ) == 0 then
            call WMem( pCallCdeclWith1Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith1Args + 8, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith1Args + 16, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith1Args + 20, 0xCCC35904 ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith1Args + 4, arg1 ) // push arg1
        call WMem( pCallCdeclWith1Args + 12, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith1Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith1Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith2Args takes integer pFuncCdeclAddr, integer arg1, integer arg2 returns integer
        local integer pOffset1
        if RMem( pCallCdeclWith2Args ) == 0 then
            call WMem( pCallCdeclWith2Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith2Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith2Args + 16, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith2Args + 24, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith2Args + 28, 0xCCC35908 ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith2Args + 4, arg2 ) // push arg2
        call WMem( pCallCdeclWith2Args + 12, arg1 ) // push arg1
        call WMem( pCallCdeclWith2Args + 20, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith2Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith2Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith3Args takes integer pFuncCdeclAddr, integer arg1, integer arg2, integer arg3 returns integer
        local integer pOffset1
        if RMem( pCallCdeclWith3Args ) == 0 then
            call WMem( pCallCdeclWith3Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith3Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith3Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith3Args + 24, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith3Args + 32, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith3Args + 36, 0xCCC3590C ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith3Args + 4, arg3 ) // push arg3
        call WMem( pCallCdeclWith3Args + 12, arg2 ) // push arg2
        call WMem( pCallCdeclWith3Args + 20, arg1 ) // push arg1
        call WMem( pCallCdeclWith3Args + 28, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith3Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith3Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith4Args takes integer pFuncCdeclAddr, integer arg1, integer arg2, integer arg3 , integer arg4 returns integer
        local integer pOffset1
        if RMem( pCallCdeclWith4Args ) == 0 then
            call WMem( pCallCdeclWith4Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith4Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith4Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith4Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith4Args + 32, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith4Args + 40, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith4Args + 44, 0xCCC35910 ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith4Args + 4, arg4 ) // push arg4
        call WMem( pCallCdeclWith4Args + 12, arg3 ) // push arg3
        call WMem( pCallCdeclWith4Args + 20, arg2 ) // push arg2
        call WMem( pCallCdeclWith4Args + 28, arg1 ) // push arg1
        call WMem( pCallCdeclWith4Args + 36, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith4Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith4Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith5Args takes integer pFuncCdeclAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5 returns integer
        local integer pOffset1
        if RMem( pCallCdeclWith5Args ) == 0 then
            call WMem( pCallCdeclWith5Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith5Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith5Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith5Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith5Args + 32, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith5Args + 40, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith5Args + 48, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith5Args + 52, 0xCCC35914 ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith5Args + 4, arg5 ) // push arg5
        call WMem( pCallCdeclWith5Args + 12, arg4 ) // push arg4
        call WMem( pCallCdeclWith5Args + 20, arg3 ) // push arg3
        call WMem( pCallCdeclWith5Args + 28, arg2 ) // push arg2
        call WMem( pCallCdeclWith5Args + 36, arg1 ) // push arg1
        call WMem( pCallCdeclWith5Args + 44, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith5Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith5Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction

    function CallCdeclWith6Args takes integer pFuncCdeclAddr, integer arg1, integer arg2, integer arg3 , integer arg4, integer arg5 , integer arg6 returns integer
        local integer pOffset1
	
        if RMem( pCallCdeclWith6Args ) == 0 then
            call WMem( pCallCdeclWith6Args, 0x68C98B51 ) // push ecx. mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 8, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 16, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 24, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 32, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 40, 0x6890C98B ) // mov ecx, ecx
            call WMem( pCallCdeclWith6Args + 48, 0xB990C98B ) // mov ecx, ecx , nop
            call WMem( pCallCdeclWith6Args + 56, 0xC483D1FF ) // call ecx, add esp, 
            call WMem( pCallCdeclWith6Args + 60, 0xCCC35918 ) // 4, pop ecx, ret
        endif
        call WMem( pCallCdeclWith6Args + 4, arg6 ) // push arg6
        call WMem( pCallCdeclWith6Args + 12, arg5 ) // push arg5
        call WMem( pCallCdeclWith6Args + 20, arg4 ) // push arg4
        call WMem( pCallCdeclWith6Args + 28, arg3 ) // push arg3
        call WMem( pCallCdeclWith6Args + 36, arg2 ) // push arg2
        call WMem( pCallCdeclWith6Args + 44, arg1 ) // push arg1
        call WMem( pCallCdeclWith6Args + 52, pFuncCdeclAddr ) // mov ecx, pFuncCdeclAddr
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pCallCdeclWith6Args )
        else
            call WMem( pIgnoredUnitsOffset, pCallCdeclWith6Args )
        endif
	
        set pOffset1 = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        return pOffset1
    endfunction
    
    function ConvertNullTerminatedStringToString takes integer pNullTerminatedString returns string
        if pNullTerminatedString > 0 then
            return I2SH( CallThisCallWith1Args( pConvertString, pNullTerminatedString ) )
        endif
        return null
    endfunction
    
    function GetUnitAbilityReal takes integer UnitAddress, integer AbilCode, integer unk1, integer unk2, integer unk3, integer unk4 returns integer
        return CallThisCallWith6Args( pGetUnitAbility, UnitAddress, AbilCode, unk1, unk2, unk3, unk4 )
    endfunction

    function GetUnitAddress takes unit u returns integer
        return CallThisCallWith1Args( pGetUnitAddress, GetHandleId( u ) )
    endfunction
    
    function GetModuleHandle takes string nDllName returns integer
        return CallStdcallWith1Args( RMem( pGetModuleHandle ), GetStringAddress( nDllName ) )
    endfunction

    function GetModuleProcAddress takes string nDllName, string nProcName returns integer
        return CallStdcallWith2Args( RMem( pGetProcAddress ), GetModuleHandle( nDllName ), GetStringAddress( nProcName ) )
    endfunction
    
    function GetUnitAbility takes unit u, integer abilid returns integer
        local integer a
        if u == null or abilid < 1 or GetUnitAbilityLevel( u, abilid ) == 0 then
            return 0
        endif
        set a = ConvertHandle( u )//GetUnitAddress( u )
	//call echo(Int2Hex(a)+" "+Int2Hex(ConvertHandle(u)))
        if a > 1 then
            return CallThisCallWith6Args( pGetUnitAbility, a, abilid, 0, 1, 1, 1 )
        endif
        return 0
    endfunction

    function GetUnitAbilityByBase takes unit u, integer abilid returns integer
        local integer a
        if u == null or abilid < 1 then
            return 0
        endif
        set a = ConvertHandle( u )//GetUnitAddress( u )
	//call echo(Int2Hex(a)+" "+Int2Hex(ConvertHandle(u)))
        if a > 1 then
            return CallThisCallWith6Args( pGetUnitAbility, a, abilid, 0, 0, 1, 1 )
        endif
        return 0
    endfunction

    function GetUnitAbilityByAddress takes integer u, integer abilid returns integer
        return CallThisCallWith6Args( pGetUnitAbility, u, abilid, 0, 1, 1, 1 )
    endfunction

    function GetAbilityOrderIdAny takes integer a returns integer
        local integer base = RMem( a + 0x54 )
        if base != 0 and RMem( a + 0x6C ) != 0 then
            set base = RMem( base + 0x30 )
            if base > 0 then
                if base == 'ANcl' then
                    return RMem( a + 0x124 )
                else
                    return GetAbilityOrderID( a )
                endif
            endif
        endif
        return 0
    endfunction

    function ShowAbilityById_Main takes integer ConvertedHandle, integer d returns nothing
        if ConvertedHandle > 0 and RMem( ConvertedHandle ) > 0 then
            call WMem( ConvertedHandle + 0x40, RMem( ConvertedHandle + 0x40 ) + d )
        endif
    endfunction

    function StartAbilityCooldown takes unit whichUnit, integer abilityId, real cd returns boolean
        local integer pAbility = 0
        if GetUnitAbilityLevel( whichUnit, abilityId ) == 0 or cd == 0.00 then
            return false
        endif
        
        set pAbility = GetUnitAbility( whichUnit, abilityId )
        
        if pAbility < 1 then
            return false
        else
            if RMem( pAbility + 0x134 ) == -1 and RMem( pAbility + 0x138 ) == -1 then
                call WMem( pAbility + 0x134, 0 )
                call WMem( pAbility + 0x138, 0 )
                if not InGame then
                    call BJDebugMsg( "Start Cooldown WARNING!" )
                    call BJDebugMsg( "ADRESS-VAL1-VAL2" )
                    call BJDebugMsg( Int2Hex(pAbility)+" - "+Int2Hex(RMem( pAbility + 0x134 ))+" - "+Int2Hex(RMem( pAbility + 0x134 )))
                    call BJDebugMsg( "abil-"+Id2String(abilityId) +" owner-"+ Int2Hex(pAbility)  )
                endif
            endif
            set Memory[pReserverdIntArg1 / 4] = mR2I( cd )
            call CallThisCallWith2Args( pStartAbilityCD, pAbility, pReserverdIntArg1 )
            return IsAbilityOnCooldown( pAbility )
        endif
        return false
    endfunction
    
    function DisableUnitAbilityById takes unit whichUnit, integer id, boolean flag returns boolean
        local integer pAbility = 0
        local integer pDisableCount = 0
    
        if whichUnit == null or id == 0 or GetUnitAbilityLevel( whichUnit, id ) < 1 then
            return false
        endif
    
        set pAbility = GetUnitAbilityForAddresss( ConvertHandle( whichUnit ), id )
        
        set pDisableCount = RMem( pAbility + 0x3C )
        
        if pDisableCount < 0 then 
            call BJDebugMsg( DEBUG + " счетчик безмолвия не верен - " + Int2Hex( pAbility ) + " = " + I2S( pDisableCount ) )
            call BJDebugMsg( INFO )
        endif
        
        if flag then
            call SetAbilityDisabled( pAbility, pDisableCount + 1 )
        else
            call SetAbilityDisabled( pAbility, IMaxBJ( pDisableCount - 1, 0 ) )
        endif
        
        return true
    endfunction
    
    function HideAbilityButton takes unit u, integer id, boolean hide returns nothing
        local integer offset
        if u != null and id != 0 then
            set offset = GetUnitAbility( u, id )
            if offset != 0 then
                if hide then
                    call ShowAbilityById_Main( offset, 1 )
                else
                    call ShowAbilityById_Main( offset, -1 )
                endif
            endif
        endif
    endfunction
   
    function GetAbilityUIDefById takes integer id returns integer
        local integer a = CallThisCallWith1Args( pGetAbilityUIDefAlt, id )
        if a > 0 then
            return a + 4
        endif
        return a
    endfunction
    
    
    function GetAbilityUIDefCaching takes integer id returns integer
        local integer a
        if HaveSavedInteger( ObjectDataPointersTable, DEF_ADR_ABILITY_UI, id ) then
            return LoadInteger( ObjectDataPointersTable, DEF_ADR_ABILITY_UI, id )
        endif
        set a = GetAbilityUIDefById( id )
        if a > 0 then
            call SaveInteger( ObjectDataPointersTable, DEF_ADR_ABILITY_UI, id, a )
        endif
        return a
    endfunction

    function GetAbilityStringParam takes integer id, integer off returns string
        local integer k = GetAbilityUIDefCaching( id )
        if k < 1 then
            return ""
        endif
//	call echo(Int2Hex(k))
        set k = k + off
        if RMem( k ) > 0 then
            return ConvertNullTerminatedStringToString( RMem( k ) )
        endif
        return ""
    endfunction

    function SetAbilityStringParam takes integer id, integer off, string newVal returns boolean
        local integer k = GetAbilityUIDefCaching( id )
        if k < 1 then
            return false
        endif
        call WMem( k + off, GetStringAddress( newVal ) )
        return true
    endfunction

    function GetAbilityStringParam2 takes integer id, integer off, integer lvl returns string
        local integer k = GetAbilityUIDefCaching( id )
        if k < 1 then
            return null
        endif
        set k = k + off
        set lvl = lvl - 1
        if RMem( k ) + lvl * 4 > 0 then
            return ConvertNullTerminatedStringToString( RMem( RMem( k ) + lvl * 4 ) )
        endif
        return null
    endfunction

    function SetAbilityStringParam2 takes integer id, integer off, string newVal, integer lvl returns boolean
        local integer k = GetAbilityUIDefCaching( id )
        if k < 1 then
            return false
        endif
        set k = k + off
        if RMem( k ) > 0 then
            call WMem( RMem( k + lvl * 4 - 4 ), GetStringAddress( newVal ) )
            return true
        endif
        return false
    endfunction
    
    function SetAbilityUbertip takes integer id, integer lvl, string s returns boolean
        return SetAbilityStringParam2( id, 0x158, s, lvl )
    endfunction

    function GetAbilityUbertip takes integer id, integer lvl returns string
        return GetAbilityStringParam2( id, 0x158, lvl )
    endfunction

    function ChangeItemId takes item it, integer targetID returns nothing
        local integer cid = ConvertHandle( it )
        local integer curID
        if cid < 1 then
            return
        endif
        set curID = RMem( cid + 0x30 )
        call WMem( cid + 0x30, targetID )
    endfunction

    function Player2Flag takes player p returns integer
        return R2I( Pow( 2, GetPlayerId( p ) ) )
    endfunction

    function GetUnitVisibilityClass takes unit u returns integer
        local integer a = ConvertHandle( u )
        local integer res = 0
        if a > 0 then
            set res = RMem( a + 0x130 )
            if res > 0 then
                set res = GetSomeAddressForAbility( res, RMem( a + 0x134 ) )
            endif
        endif
        return res
    endfunction

    function GetUnitDetectedClass takes unit u returns integer
        local integer a = ConvertHandle( u )
        local integer res = 0
        if a > 0 then
            set res = RMem( a + 0x13C )
            if res > 0 then
                set res = GetSomeAddressForAbility( res, RMem( a + 0x140 ) )
            endif
        endif
        return res
    endfunction

    function SetEffectSize takes effect e, real size returns nothing
        set Memory[Memory[ConvertHandle( e ) / 4 + 0x28 / 4] / 4 + 0xE8 / 4] = cleanInt( realToIndex( size ) )
    endfunction

    function AddAlwaysVisibleFlag takes unit u, boolean flag returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 1 then
            if flag and IsFlagBitSet( RMem( LastConvertedHandle + 0x20 ), 0x10 ) == false then
                call WMem( LastConvertedHandle + 0x20, RMem( LastConvertedHandle + 0x20 ) + 0x10 )
            elseif IsFlagBitSet( RMem( LastConvertedHandle + 0x20 ), 0x10 ) then
                call WMem( LastConvertedHandle + 0x20, RMem( LastConvertedHandle + 0x20 ) - 0x10 )
            endif
        endif
    endfunction

    function GetBuffLevel takes integer pBuff returns integer
        if pBuff < 1 then
            return 0
        endif
        return Memory[( pBuff + 0xb0 ) / 4] + 1
    endfunction

    function SetBuffLevel takes integer pBuff, integer level returns nothing
        if pBuff < 1 or level < 1 then
            return
        endif
        set Memory[( pBuff + 0xb0 ) / 4] = level - 1
    endfunction

    function SetUnitGreenBonusDamage takes unit u, integer i returns nothing
        set Memory[GetUnitAttackAbility( u ) / 4 + 0xAC / 4] = i
    endfunction

    function GetUnitGreenBonusDamage takes unit u returns integer
        return Memory[GetUnitAttackAbility( u ) / 4 + 0xAC / 4]
    endfunction

    function AddUnitGreenBonusDamage takes unit u, integer i returns nothing
        call SetUnitGreenBonusDamage( u, GetUnitGreenBonusDamage( u ) + i )
    endfunction
//! nocjass
    function GetUnitBaseDamage takes unit u returns integer
        return Memory[GetUnitAttackAbility( u ) / 4 + 0xA0 / 4]
    endfunction
//! endnocjass

    function RefreshUnitsCommandPanel takes unit u returns nothing
        set LastConvertedHandle = ConvertHandle( u )
        if LastConvertedHandle > 0 then
            call CallThisCallWith2Args( pRefreshUnitsCommandPanel, LastConvertedHandle, 852290 )
        endif
    endfunction

    function AddAbilityCharges takes unit u, integer id, integer c returns nothing
        local integer a = GetUnitAbility( u, id )
        if a > 0 then
            call WMem( a + 0x124, RMem( a + 0x124 ) + c )
        endif
        call RefreshUnitsCommandPanel( u )//else changes will be visible only at next redraw
    endfunction

    function IsUnitDetectedByPlayer takes unit u, player p returns boolean
	//shared vision-like effect, used for Faerie fire / Wand of evil eye
	//have no reveal effect by itself, used only as detector?
        local integer a = GetUnitDetectedClass( u )
        if a > 0 then
            return IsFlagBitSet( RMem( a + 0x24 ), Player2Flag( p ) )
        endif
        return false
    endfunction

    function RemoveAnyDetectionFromUnit takes unit u returns nothing
        local integer a = ConvertHandle( u )
        if a > 0 then
            call WMem( a + 0x148, 0 )
            call WMem( a + 0x14C, 0 )
            set a = GetUnitVisibilityClass( u )
            if a > 0 then
                call WMem( a + 0x24, 0 )
            endif
        endif
    endfunction

   
    function RecountAnyDetectionForUnit takes unit u returns nothing
        local integer a = ConvertHandle( u )
        local integer sum = 0
        local integer i = 0
        if a > 0 then
            set a = GetUnitDetectedClass( u )
            if a > 0 then
                loop
                    if RMem( a + 0x2C + 4 * i ) > 0 then
                        set sum = sum + R2I( Pow( 2, i ) )
                    endif
                    set i = i + 1
                    exitwhen i > 15
                endloop
                call WMem( a + 0x14C, sum )
                call WMem( a + 0x148, sum )
                set sum = 0
                set i = 0
            endif
            set a = GetUnitVisibilityClass( u )
            if a > 0 then
                loop
                    if RMem( a + 0x2C + 4 * i ) > 0 then
                        set sum = sum + R2I( Pow( 2, i ) )
                    endif
                    set i = i + 1
                    exitwhen i > 15
                endloop
                call WMem( a + 0x24, sum )
            endif
        endif
    endfunction

    function GetHeroAbilityFromList takes unit uHero, integer list returns integer
        set LastConvertedHandle = ConvertHandle( uHero )
    
        if IsUnitType( uHero, UNIT_TYPE_HERO ) and LastConvertedHandle > 1 and list > 0 then
            return RMem( RMem( LastConvertedHandle + 496 ) + 240 + 4 * list )
        endif

        return 0
    endfunction

    function IsUnitAbilityDisabled takes unit whichUnit, integer id returns boolean
        if whichUnit == null or id == 0 or GetUnitAbilityLevel( whichUnit, id ) < 1 then
            return false
        endif
    
        set LastConvertedHandle = GetUnitAbilityForAddresss( ConvertHandle( whichUnit ), id )
        
        if LastConvertedHandle < 1 then
            return false
        endif
        
        return GetAbilityDisabledCount( LastConvertedHandle ) > 0
    endfunction
    
    function ThrowTargetSpellTargetUnit takes unit who, integer id, widget target returns nothing
        local integer a = ConvertHandle( target )
        local integer x
        local integer y
        local integer flags
        if a > 0 and GetHandleId( who ) > 0 then
            set x = RMem( a + 0xC )
            set y = RMem( a + 0x10 )
            if x > 0 and y > 0 then
                set a = ConvertHandle( who )
                if a < 1 then
                    return
                endif
                set a = GetUnitAbility( who, id )
                if a > 0 then
                    call WMem( a + 0xE4, x )//for any target ( widget )
                    call WMem( a + 0xE8, y )
                    set flags = RMem( a + 0x20 )
                    if not IsFlagBitSet( flags, 0x10000 ) then
					//0x19804 stands for "target", 0x1F020 stands for "target item",0x9800 stands for point target
                        call WMem( a + 0x20, flags + 0x10000 )
                        set flags = flags + 0x10000
                        if not IsFlagBitSet( flags, 0x1 ) then
                            call WMem( a + 0x20, flags + 0x1 )
                        endif
                    endif
                    set a = CallThisCallWith1Args( pCastAbility, a )
                endif
            endif
        endif
    endfunction
    
    function IsCooldownUIHided takes integer pAbility returns boolean

        if pAbility < 1 then
            return false
        endif

        return IsFlagBitSet( RMem( pAbility + 0x20 ), 0x400 )
    endfunction

    function HideCooldownUIById takes unit whichUnit, integer id, boolean hide returns nothing
        local integer pAbility = GetUnitAbilityForAddresss( ConvertHandle( whichUnit ), id )
   
        if pAbility < 1 then
            return
        endif
    
        set pAbility = pAbility + 0x20
    
       if hide and not IsFlagBitSet( RMem( pAbility ), 0x400 ) then
            call WMem( pAbility, RMem( pAbility ) + 0x400 )
        elseif not hide and IsFlagBitSet( RMem( pAbility ), 0x400 ) then
            call WMem( pAbility, RMem( pAbility ) - 0x400 )
        endif

    endfunction
    
    function AllocateExecutableMemory takes integer size returns integer
        local integer retval = 0
        if pVirtualAlloc != 0 then
            if pMergeUnitsOffset == 0 then
                set pMergeUnitsOffset = CreateJassNativeHook( pMergeUnits, RMem( pVirtualAlloc ) )
            else
                call WMem( pMergeUnitsOffset, RMem( pVirtualAlloc ) )
            endif
            set retval = B2I( MergeUnits( 0, size + 4, 0x3000, 0x40 ) )
            call WMem( pMergeUnitsOffset, pMergeUnits )
        endif
	
        if retval == 0 then
            return 0
        endif
	
        return ( retval + 4 ) / 4 * 4
    endfunction
    
    function ReadSomeRegisterOffset takes integer register, integer offset returns integer
        local integer retval = 0
        call WMem( pReadStack, 0xCCC3008B + register )
	
        if pIgnoredUnitsOffset == 0 then
            set pIgnoredUnitsOffset = CreateJassNativeHook( pIgnoredUnits, pReadStack )
        else
            call WMem( pIgnoredUnitsOffset, pReadStack )
        endif
	
        set retval = IgnoredUnits( 0 )
        call WMem( pIgnoredUnitsOffset, pIgnoredUnits )
        if offset == 0 then
            return retval
        endif
        return RMem( retval + offset )
    endfunction

    function FlushInstructionCache takes integer a, integer size returns nothing
        if pFlushInstructionCache == 0 then
            set pFlushInstructionCache = GetModuleProcAddress( EXTRADLLNAME, "_FlushInstructionCache" )
        endif
        if pFlushInstructionCache != 0 then
            call CallStdcallWith2Args( pFlushInstructionCache, a, size )
        endif
    endfunction

// Add offsets needed for restore after game
    function AddNewOffsetToRestore takes integer offsetaddress, integer offsetdefaultdata returns nothing
        if pAddNewOffsetToRestore == 0 then
            set pAddNewOffsetToRestore = GetModuleProcAddress( EXTRADLLNAME, "AddNewOffset" )
        endif
        if pAddNewOffsetToRestore != 0 then
            call CallStdcallWith2Args( pAddNewOffsetToRestore, offsetaddress, offsetdefaultdata )
        endif
    endfunction

    function ChangeOffsetProtection takes integer pRealOffset, integer memSize, integer pProtectFlag returns integer
        local integer a
        local integer nIndex = 0
	
        if pVirtualProtect == 0 then
            set pVirtualProtect = GetModuleProcAddress( "Kernel32.dll", "VirtualProtect" )
        endif
        if pVirtualProtect != 0 then
            call AddNewOffsetToRestore( pRealOffset, RMem( pRealOffset ) )
            if memSize > 4 then
                set nIndex = memSize / 4 - 1
                set a = pRealOffset
                loop
                    exitwhen nIndex < 1
                    set a = a + 4
                    call AddNewOffsetToRestore( a, RMem( a ) )
                    set nIndex = nIndex - 1
                endloop
            endif
            call CallStdcallWith4Args( pVirtualProtect, pRealOffset, memSize, pProtectFlag, pReserverdIntArg1 )
            call FlushInstructionCache( pRealOffset, memSize )
            return RMem( pReserverdIntArg1 )
        endif

        return 0
    endfunction

    function ReadEAX takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_EAX, 0 )
    endfunction

    function ReadEBX takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_EBX, 0 )
    endfunction

    function ReadECX takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_ECX, 0 )
    endfunction

    function ReadEDX takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_EDX, 0 )
    endfunction

    function ReadESI takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_ESI, 0 )
    endfunction

    function ReadEDI takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_EDI, 0 )
    endfunction

    function ReadEBP takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_EBP, 0 )
    endfunction

    function ReadESP takes nothing returns integer
        return ReadSomeRegisterOffset( REGISTER_ESP, 0 )
    endfunction

    function ReadEAX_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_EAX, offset )
    endfunction

    function ReadEBX_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_EBX, offset )
    endfunction

    function ReadECX_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_ECX, offset )
    endfunction

    function ReadEDX_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_EDX, offset )
    endfunction

    function ReadESI_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_ESI, offset )
    endfunction

    function ReadEDI_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_EDI, offset )
    endfunction

    function ReadEBP_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_EBP, offset )
    endfunction

    function ReadESP_offset takes integer offset returns integer
        return ReadSomeRegisterOffset( REGISTER_ESP, offset )
    endfunction
    
    function TestMissileHandlerWorker takes nothing returns nothing
        local integer offset = RMem( pDamageEspData )
        local integer target = RMem( pDamageTarget )
   
        if offset > 0 then
            set offset = Memory[offset / 4 + 2]//RMem( offset + 0x8 )
        endif
        if DamageIncrementer > 8000 then
            set DamageIncrementer = 10
        endif
        set DamageIncrementer = DamageIncrementer + 1
    //call BJDebugMsg("dmg event "+I2S(DamageIncrementer)+" source="+Id2String(RMem(target+0x30))+" val="+R2S(mI2R(Memory[offset/4+0x10/4])))
        if offset > 0 then
            set DamageAttackTypes[DamageIncrementer] = Memory[offset / 4 + 0x20 / 4]//RMem( offset + 0x20 )
            set DamageDamageTypes[DamageIncrementer] = Memory[offset / 4 + 0x14 / 4]//RMem( offset + 0x14 )
            set DamageValues[DamageIncrementer] = mI2R( Memory[offset / 4 + 0x10 / 4] )//RMem( offset + 0x10 ) )
        //call ExecuteFunc("PreDamageWorker")
        endif
    endfunction
 
    function TestMissileHandler takes nothing returns nothing
        local integer offset = RMem( RMem( pDamageEspData ) + 0x8 )
        local integer IsMelee = 0x100
        local integer d
  
  
        if DamageIncrementer > 8000 then
            set DamageIncrementer = 10
        endif
        //call TestMissileHandlerWorker( )

        set DamageIncrementer = DamageIncrementer + 1
        set DamageValues[DamageIncrementer] = mI2R( RMem( offset + 0x10 ) )
        set DamageAttackTypes[DamageIncrementer] = RMem( offset + 0x20 )
        set DamageDamageTypes[DamageIncrementer] = RMem( offset + 0x14 )
//  call TestIfdamageHookCrash()
//  return
//  call ExecuteFunc("PreDamageWorker")
    //Barrage missiles always have 0x8 == 0x10000000
    
        call BJDebugMsg( I2S( DamageAttackTypes[DamageIncrementer] ) + " - тип аттаки" )
    
        set d = DamageDamageTypes[DamageIncrementer]
    
        call BJDebugMsg( I2S( d ) + " - тип урона" )
    
    
    
  //call BJDebugMsg("Target" + Int2Hex(RMem(pDamageTarget)))
  //call BJDebugMsg(Int2Hex(RMem(RMem(RMem(pDamageEspData)+0x8)+0x0)))//source
  //call BJDebugMsg(Int2Hex(RMem(RMem(RMem(pDamageEspData)+0x8)+0x8)))//proj or link onto something
// 
        set IsMelee = RMem( RMem( RMem( pDamageEspData ) + 0x8 ) + 0xC )
        if IsMelee == 0x100 then
            call BJDebugMsg( "is melle = true" )
        endif
    
        if IsMelee == 0x101 then
            call BJDebugMsg( "is ranged = true" )
        endif
    
        if IsMelee != 0x100 and IsMelee != 0x101 then
            call BJDebugMsg( "is melle = false and is ranged false" )
        endif
    
  //0x101 == ranged, 0x100 == melee
        call BJDebugMsg( "Damage:" + R2S( mI2R( RMem( RMem( RMem( pDamageEspData ) + 0x8 ) + 0x10 ) ) ) )//damage val
    endfunction
 
    function InitializeDamageHandler takes integer pTriggerHandle returns nothing
        local integer pUnitDamageHandler = pUnitVtable + 0x120
        local integer oldprotection = ChangeOffsetProtection( pUnitDamageHandler, 4, 0x40 )
    
        set Memory[pReservedMemoryForDamageHandler / 4 + 0] = 0xB890C08B
        set Memory[pReservedMemoryForDamageHandler / 4 + 1] = pDamageTarget
        set Memory[pReservedMemoryForDamageHandler / 4 + 2] = 0xB8900889
        set Memory[pReservedMemoryForDamageHandler / 4 + 3] = pDamageEspData
        set Memory[pReservedMemoryForDamageHandler / 4 + 4] = 0x68602089
        set Memory[pReservedMemoryForDamageHandler / 4 + 5] = pTriggerHandle
        set Memory[pReservedMemoryForDamageHandler / 4 + 6] = 0xB890C08B
        set Memory[pReservedMemoryForDamageHandler / 4 + 7] = pTriggerExecute
        set Memory[pReservedMemoryForDamageHandler / 4 + 8] = 0xC483D0FF
        set Memory[pReservedMemoryForDamageHandler / 4 + 9] = 0xB8906104
        set Memory[pReservedMemoryForDamageHandler / 4 + 10] = pRealUnitDamageHandler
        set Memory[pReservedMemoryForDamageHandler / 4 + 11] = 0xCCCCE0FF
 
     //call BJDebugMsg(Int2Hex(pReservedMemoryForDamageHandler))
   
        call WMem( pUnitDamageHandler, pReservedMemoryForDamageHandler )
   
        set oldprotection = ChangeOffsetProtection( pUnitDamageHandler, 4, oldprotection )
   
    endfunction
 
  
    
endlibrary