// empty line needed here

Number.prototype.add32 = function(x) { return (this + x) | 0; };

Number.prototype.sub32 = function(x) { return (this - x) | 0; };

Number.prototype.mul32 = function(x) { 

    return (((this * (x >> 16)) << 16) + this * (x & 0xFFFF)) | 0;

};

Number.prototype.toInt8 = function()  { return (this << 24) >> 24; };

Number.prototype.toInt16 = function() { return (this << 16) >> 16; };

var __m32 = 0xFFFFFFFF;

Number.prototype.next32 = function(low) {

  if (this === 0) {

    return low;

  }

  var l = new Number(low);

  l.hi = this | 0;

  return l;

};

Number.prototype.high32 = function() { 

    return this.hi ? this.hi : (Math.floor(this / (__m32+1))) | 0;

};

Number.prototype.toInt32 = function() { return this | 0; };

Number.prototype.toFP = function() {

    return this.hi ? this.hi * (__m32+1) + this : this;

};

Number.prototype.toLong = function() {

    var hi = (this > __m32) ? (Math.floor(this / (__m32+1))) | 0 : 0;

    return hi.next32(Math.floor(this % (__m32+1)));

};

Number.prototype.toExactString = function() {

    if (this.hi) {

        var res = 0;

        var a = [ 6,9,2,7,6,9,4,9,2,4 ];

        var s = '';

        var digit;

        var neg = this.hi < 0;

        if (neg) {

            var x = this.neg64();

            var hi = x.hi;

            var low = x;

        } else {

            var hi = this.hi;

            var low = this;

        }

        for (var i = 0; i < a.length; i++) {

            res += hi * a[i];

            var low_digit = low % 10;

            digit = (res % 10) + low_digit;

            low = Math.floor(low / 10);

            res = Math.floor(res / 10);

            if (digit >= 10) {

                digit -= 10;

                res++;

            }

            s = String(digit).concat(s);

        }

        return (neg ? '-' : '').concat(res).concat(s);

    }

    return String(this);

};

Number.prototype.add64 = function(x) {

    var low = this + x;

    carry = 0;

    if (low > __m32) {

        carry = 1;

        low -= (__m32+1);

    }

    var hi = (this.high32() + x.high32() + carry) | 0;

    return hi.next32(low);

};

Number.prototype.sub64 = function(x) {

    var low = this - x;

    carry = 0;

    if (low < 0) {

        carry = 1;

        low += (__m32+1);

    }

    var hi = (this.high32() - x.high32() - carry) | 0;

    return hi.next32(low);

};

Number.prototype.mul64 = function(x) {

    var low = this.mul32(x);

    low += (low < 0) ? (__m32+1) : 0;

    // first count upper 32 bits of (this.low * x.low)

    var hi_hi = 0;

    var hi_low = 0;

    var m = 1;

    for (var i = 0; i < 32; i++) {

        if (x & m) {

            hi_hi += this >>> 16;

            hi_low += this & 0xFFFF

        }

        hi_low >>= 1;

        hi_low += (hi_hi & 1) ? 0x8000 : 0;

        hi_hi >>= 1;

        m <<= 1;

    }

    var hi = (hi_hi << 16) + hi_low;

    var m1 = this.high32().mul32(x);

    var m2 = this.mul32(x.high32());

    hi = hi.add32(m1).add32(m2);

    return hi.next32(low);

};

Number.prototype.div64 = function(x) {

    var low = Math.floor(this.toFP() / x.toFP()); // TODO: not exact enough

    if (low > __m32) {

        var hi = Math.floor(low / (__m32+1)) | 0;

        return hi.next32(low % (__m32+1));

    }

    return low;

};

Number.prototype.and64 = function(x) {

    var low = this & x;

    low += (low < 0) ? (__m32+1) : 0;

    if (this.hi && x.hi) {

        var hi = this.hi & x.hi;

        return hi.next32(low);

    };

    return low;

};

Number.prototype.or64 = function(x) {

    var low = this | x;

    low += (low < 0) ? (__m32+1) : 0;

    if (this.hi || x.hi) {

        var hi = this.hi | x.hi;

        return hi.next32(low);

    };

    return low;

};

Number.prototype.xor64 = function(x) {

    var low = this ^ x;

    low += (low < 0) ? (__m32+1) : 0;

    if (this.hi || x.hi) {

        var hi = this.hi ^ x.hi;

        return hi.next32(low);

    };

    return low;

};

Number.prototype.shl64 = function(x) {

    if (x >= 32) {

        var hi = this << (x - 32);

        return hi.next32(0);

    } else {

        var hi = this.high32() << x;

        var low_reminder = this >> (32 - x);

        hi |= low_reminder;

        var low = this << x;

        low += (low < 0) ? (__m32+1) : 0;

        return hi.next32(low);

    }

};

Number.prototype.shr64 = function(x) {

    if (x >= 32) {

        var low = this.high32() >> (x - 32);

        low += (low < 0) ? (__m32+1) : 0;

        return low;

    } else {

        var low = this >> x;

        var hi_reminder = this.high32() << (32 - x);

        low |= hi_reminder;

        low += (low < 0) ? (__m32+1) : 0;

        var hi = this.high32() >> x;

        return hi.next32(low);

    }

};

Number.prototype.ushr64 = function(x) {

    if (x >= 32) {

        var low = this.high32() >>> (x - 32);

        low += (low < 0) ? (__m32+1) : 0;

        return low;

    } else {

        var low = this >>> x;

        var hi_reminder = this.high32() << (32 - x);

        low |= hi_reminder;

        low += (low < 0) ? (__m32+1) : 0;

        var hi = this.high32() >>> x;

        return hi.next32(low);

    }

};

Number.prototype.compare64 = function(x) {

    if (this.hi == x.hi) {

        return (this == x) ? 0 : ((this < x) ? -1 : 1);

    }

    return (this.hi < x.hi) ? -1 : 1;

};

Number.prototype.neg64 = function() {

    var hi = this.high32();

    var low = this;

    if ((hi === 0) && (low < 0)) { return -low; }

    hi = ~hi;

    low = ~low;

    low += (low < 0) ? (__m32+1) : 0;

    var ret = hi.next32(low);

    return ret.add64(1);

};