#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;
}