Bits operators

#include "a_samp"
#define T<%0> a%0

enum{a0,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13,a14,a15}

main()
{
    /*
        Bitwise OR

        0 OR 0 = 0
        0 OR 1 = 1
        1 OR 0 = 1
        1 OR 1 = 1

    */
    func("|", "0011", T<1> | T<2>, false); // 0001 | 0010 = 0011
    func("|", "0101", T<1> | T<4>, false); // 0001 | 0100 = 0101
    func("|", "0111", T<1> | T<2> | T<4>, false); // 0001 | 0010 | 0100 = 0111
    func("|", "1001", T<1> | T<8>, false); // 0001 | 1000 = 1001
    func("|", "1010", T<2> | T<8>, false); // 0010 | 1000 = 1010
    func("|", "1011", T<1> | T<2> | T<8>, false); // 0001 | 0010 | 1000 = 1011
    func("|", "1011", T<1> | T<10>, false); // 0001 | 1010 = 1011
    func("|", "1101", T<8> | T<5>, false); // 1000 | 0101 = 1101
    func("|", "1111", T<10> | T<5>, false); // 1010 | 0101 = 1111

    //------------------------------------------------------------------------------------------------------

    /*
        Bitwise AND

        0 AND 0 = 0
        0 AND 1 = 0
        1 AND 0 = 0
        1 AND 1 = 1

    */
    func("&", "0000", T<4> & T<8>, false); // 0100 & 1000 = 0000
    func("&", "0001", T<1> & T<5>, false); // 0001 & 0101 = 0001
    func("&", "0010", T<2> & T<10>, false); // 0010 & 1010 = 0010
    func("&", "0100", T<4> & T<5>, false); // 0100 & 0101 = 0100
    func("&", "1000", T<8> & T<10>, false); // 1000 & 1010 = 1000
    func("&", "1010", T<10> & T<11>, false); // 1010 & 1011 = 1010
    func("&", "0010", (T<10> & T<15>) & T<2>, false); // (1010 & 1111) & 0010 = 1010 & 0010 = 0010

    //------------------------------------------------------------------------------------------------------

    /*
        Bitwise XOR

        0 XOR 0 = 1
        0 XOR 1 = 0
        1 XOR 0 = 0
        1 XOR 1 = 1

    */
    func("^", "0010", T<8> ^ T<10>, false); // 1000 ^ 1010 = 0010
    func("^", "0100", T<11> ^ T<15>, false); // 1011 ^ 1111 = 0100

    //------------------------------------------------------------------------------------------------------

    /*
        Bitwise NOT

        NOT 0 = 1
        NOT 1 = 0

    */
    func("~", "11111111111111111111111111111010", ~T<5>);
    // ~00000000000000000000000000000101 = 11111111111111111111111111111010

    func("~", "11111111111111111111111111110011", ~(T<4> | T<8>));
    // ~(0100 | 1000) = ~00000000000000000000000000001100 = 11111111111111111111111111110011

    func("~", "11111111111111111111111111110011", ~(T<5> & T<15>));
    // ~(0101 & 1111) = ~00000000000000000000000000000101 = 11111111111111111111111111110011

    //------------------------------------------------------------------------------------------------------

    // Bitwise arithmetic shift
    func("<<", "0010", T<1> << 1, false); // 0001 << 1 = 0010
    func("<<", "0100", T<1> << 2, false); // 0001 << 2 = 0100
    func("<<", "1000", T<1> << 3, false); // 0001 << 3 = 1000
    func("<<", "1010", T<5> << 1, false); // 0101 << 1 = 1010
    func(">>", "0100", T<8> >> 1, false); // 1000 >> 1 = 0100
    func(">>", "0010", T<8> >> 2, false); // 0001 >> 2 = 0010
    func(">>", "0001", T<8> >> 3, false); // 0001 >> 3 = 0001
    func(">>", "0101", T<10> >> 1, false); // 1010 >> 1 = 0101

    /*
        Attention, if you use the bit right shift and the 32th bit is 1 (so a value negative),
        the bits will not shift, but will be added.

        Example, you think that this operation will give this result ? :
        11111111111111111111111111111000 (-8) >> 2 = 00111111111111111111111111111110 (1073741822)

        But no, this operation will give this result :
        11111111111111111111111111111000 (-8) >> 2 = 11111111111111111111111111111110 (-2)

        Conclusion, when you use the bit right shift on negative value, it remains negative.
    */

    func(">>", "11111111111111111111111111111110", 0b11111111111111111111111111111000 >> 2);

    //------------------------------------------------------------------------------------------------------

    /*
        Bitwise logical shift

        If you understood the explanations before for the bit right shift, there is solution
        to shift to the right on a negative value with the bit logical shift operator.

        Let us take the example of before :
        11111111111111111111111111111000 (-8) >> 2 = 00111111111111111111111111111110 (1073741822)

        It is false, but if I use the bit logical shift operator :
        11111111111111111111111111111000 (-8) >>> 2 = 00111111111111111111111111111110 (1073741822)

        This is true.

        You are wondering if there is the bit logical shift "left" ? In Pawn : no.
        That's why when we say "bit logical shift", we don't mention the "direction",
        because there only the right.

    */

    func(">>>", "00111111111111111111111111111110", 0b11111111111111111111111111111000 >>> 2);
}

func(const o[], const str[], value, bool:b32 = true)
{
    static
        n = 1;

    if(b32)
    {
        printf("________________________________%03d (%s)", n, o);
        print(str);
        printf("%032b", value);
        print("¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯");
    }

    else
    {
        printf("____%03d (%s)", n, o);
        print(str);
        printf("%04b", value);
        print("¯¯¯¯");
    }

    n++;
}