Tick:GetTickCount

#include <a_samp>

native Tick:TICK_GetTickCount() = GetTickCount;
#if defined _ALS_GetTickCount
    #undef GetTickCount
#else
    #define _ALS_GetTickCount
#endif
#define GetTickCount TICK_GetTickCount

stock Tick:operator-(Tick:a, Tick:b)
{
    if (a < 0)
    {
        if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else if (b < 0)
        {
            return Tick:(_:b - _:a);
        }
        else
        {
            return Tick:((cellmax - _:b) + (_:a - cellmin));
        }
    }
    else
    {
        if (b < 0)
        {
            return Tick:((cellmax - _:a) + (_:b - cellmin));
        }
        else if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else
        {
            return Tick:(_:b - _:a);
        }
    }
}

stock Tick:operator-(Tick:a, _:b)
{
    if (a < 0)
    {
        if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else if (b < 0)
        {
            return Tick:(_:b - _:a);
        }
        else
        {
            return Tick:((cellmax - _:b) + (_:a - cellmin));
        }
    }
    else
    {
        if (b < 0)
        {
            return Tick:((cellmax - _:a) + (_:b - cellmin));
        }
        else if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else
        {
            return Tick:(_:b - _:a);
        }
    }
}

stock Tick:operator-(_:a, Tick:b)
{
    if (a < 0)
    {
        if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else if (b < 0)
        {
            return Tick:(_:b - _:a);
        }
        else
        {
            return Tick:((cellmax - _:b) + (_:a - cellmin));
        }
    }
    else
    {
        if (b < 0)
        {
            return Tick:((cellmax - _:a) + (_:b - cellmin));
        }
        else if (b < a)
        {
            return Tick:(_:a - _:b);
        }
        else
        {
            return Tick:(_:b - _:a);
        }
    }
}

stock Tick:operator=(_:a)
{
    return Tick:a;
}

stock Tick:operator+(Tick:a, Tick:b) return Tick:a - Tick:(-(_:b));
stock Tick:operator+(Tick:a, _:b) return Tick:a - Tick:(-(_:b));
stock Tick:operator+(_:a, Tick:b) return Tick:a - Tick:(-(_:b));