DO64

#include <a_samp>

// A bit array could save memory but would be slower...

#define Int64:: \
    Int64_

#define long<%0> \
    %0[2]

//Shitty syntax
static stock long <Int64::Result>;

/*
 * Arithmetic Operations:
 * - Addition
 * - Subtracion
 * - Multiplication (ToDo)
 * - Division (ToDo)
 */

stock Int64::Add (long <a>, long <b>, bool: carryin = false)
{
    new
        c = _: carryin,
        s,
        i;

    Int64::Result [0] = Int64::Result [1] = 0;

    for (new j = 1; j >= 0; --j)
    {
        s = (a [j] ^ b [j]);
        for (i = 0; i < 32; ++i)
        {
            Int64::Result [j] |= ((s ^ (c << i)) & (1 << i));
            c <<= i;
            c = (((a [j] & b [j]) | (a [j] & c) | (b [j] & c)) >> i) & 1;
        }
    }
    return Int64::Result;
}

stock Int64::Sub (long <a>, long <b>)
{
    Int64::Result = Int64::Add (a, Int64::NOT (b), true);
    return Int64::Result;
}

/*
 * Logical Operations:
 * - NOT
 * - AND
 * - OR
 * - XOR
 * - NAND
 * - NOR
 * - XNOR
 */

stock Int64::NOT (long <a>)
{
    Int64::Result [0] = ~a [0];
    Int64::Result [1] = ~a [1];

    return Int64::Result;
}

stock Int64::AND (long <a>, long <b>)
{
    Int64::Result [0] = a [0] & b [0];
    Int64::Result [1] = a [1] & b [1];

    return Int64::Result;
}

stock Int64::OR (long <a>, long <b>)
{
    Int64::Result [0] = a [0] | b [0];
    Int64::Result [1] = a [1] | b [1];

    return Int64::Result;
}

stock Int64::XOR (long <a>, long <b>)
{
    Int64::Result [0] = a [0] ^ b [0];
    Int64::Result [1] = a [1] ^ b [1];

    return Int64::Result;
}

stock Int64::NAND (long <a>, long <b>)
{
    Int64::Result [0] = ~(a [0] & b [0]);
    Int64::Result [1] = ~(a [1] & b [1]);

    return Int64::Result;
}

stock Int64::NOR (long <a>, long <b>)
{
    Int64::Result [0] = ~(a [0] | b [0]);
    Int64::Result [1] = ~(a [1] | b [1]);

    return Int64::Result;
}

stock Int64::XNOR (long <a>, long <b>)
{
    Int64::Result [0] = ~(a [0] ^ b [0]);
    Int64::Result [1] = ~(a [1] ^ b [1]);

    return Int64::Result;
}

/*
 * Misc. Operations:
 * - ToString
 * - Equal
 * - Less
 * - Greater
 */

stock bool: Int64::Equal (long <a>, long <b>)
{
    Int64::Result = Int64::XNOR (a, b);
    return (!Int64::Result [0] && !Int64::Result [1]);
}

stock bool: Int64::Less (long <a>, long <b>)
{
    Int64::Result = Int64::Sub (a, b);
    return bool: (Int64::Result [0] >>> 31); // Will be 1 or 0.
}

stock bool: Int64::Greater (long <a>, long <b>)
{
    Int64::Result = Int64::Sub (b, a);
    return bool: (Int64::Result [0] >>> 31); // Will be 1 or 0.
}

stock Int64::ToString (long <a>)
{
    new
        string [65],
        i;

    for (new j = 0; j < 2; ++j)
        for (i = 0; i < 32; ++i)
            string [(32 * j) + i] = '0' + ((a [j] >> (31 - i)) & 1);

    return string;
}