nedoPC.org

TernaryI32 = (function () {
   "use strict";

   let MAX_VALUE =  926510094425920;
   let MIN_VALUE = -926510094425920;

   function ctor(value) {
      let result = new.target ? this : Object.create(ctor.prototype);
      if (value instanceof ctor) {
         result.pos = value.pos;
         result.neg = value.neg;
      } else {
         let pos = 0, neg = 0, rem;
         value = Math.trunc(value);
         if (!Number.isSafeInteger(value)) value = 0;
         for (let i = 1; i && value; i <<= 1) {
            rem = value % 3;
            rem = (rem % 2 * 3 - rem) / 2;
            if (rem > 0) pos += i;
            if (rem < 0) neg += i;
            value = (value - rem) / 3;
         }
         result.pos = pos;
         result.neg = neg;
      }
      return result;
   };

   function abs(a) {
      return sign(a) < 0 ? neg(a) : ctor(a);
   };

   function add(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      let pos_XOR = pos_A ^ pos_B;
      let neg_XOR = neg_A ^ neg_B;
      let t = pos_XOR & neg_XOR;
      pos_XOR ^= t;
      neg_XOR ^= t;
      let pos_AND = pos_A & pos_B;
      let neg_AND = neg_A & neg_B;
      let pos_P = pos_XOR | pos_AND;
      let neg_P = neg_XOR | neg_AND;
      let pos_G = pos_XOR | neg_AND;
      let neg_G = neg_XOR | pos_AND;
      let pos_SUM = pos_G;
      let neg_SUM = neg_G;
      for (let step = 1; step <= 16; step += step) {
         let pos_Pr = pos_P << step;
         let neg_Pr = neg_P << step;
         let pos_Gr = pos_G << step;
         let neg_Gr = neg_G << step;
         t = pos_Gr | neg_Gr;
         pos_P &= pos_Pr | ~(pos_G | (neg_G & neg_Pr & ~t));
         neg_P &= neg_Pr | ~(neg_G | (pos_G & pos_Pr & ~t));
         t = (pos_G & pos_Pr) | (neg_G & neg_Pr);
         pos_G = t & pos_Gr;
         neg_G = t & neg_Gr;
      }
      pos_P <<= 1;
      neg_P <<= 1;
      pos_XOR = pos_P ^ pos_SUM;
      pos_XOR = neg_P ^ neg_SUM;
      t = pos_XOR & neg_XOR;
      pos_AND = pos_P & pos_SUM;
      neg_AND = neg_P & neg_SUM;
      let result = Object.create(ctor.prototype);
      result.pos = neg_AND | (pos_XOR ^ t);
      result.neg = pos_AND | (neg_XOR ^ t);
      return result;
   };

   function addcarry(a, b, cin) {
      let t = addext(a, b);
      a = t[0];
      let cout = t[1];
      if (cin > 0) {
         b = inc(a);
         if (a.pos === -1) cout = Math.min(cout, 0) + 1;
      } else if (cin < 0) {
         b = dec(a);
         if (a.neg === -1) cout = Math.max(cout, 0) - 1;
      } else {
         b = a;
      }
      return [b, cout];
   };

   function addext(a, b) {
      let sum = add(a, b);
      let carry = sign(a);
      if (carry !== sign(b) || carry === sign(sum)) carry = 0;
      return [sum, carry];
   };

   function cast(value) {
      return value instanceof ctor ? value : ctor(value);
   };

   function cldiv(a, b) {
      return cldiv_i(a, b)[0];
   };

   function cldiv_i(a, b) {
      let sign_B = sign(b);
      if (sign_B < 0) {
         a = neg(a); b = neg(b);
      } else if (!sign_B) {
         return null;
      }
      let exp_A = 31 - Math.clz32(a.pos | a.neg);
      let exp_B = 31 - Math.clz32(b.pos | b.neg);
      let pos_Q = 0;
      let neg_Q = 0;
      while (exp_A >= exp_B) {
         let i = exp_A - exp_B;
         if ((a.pos >> exp_A) & 1) {
            a = tritsub(a, shift(b, i));
            pos_Q |= 1 << i;
         } else if ((a.neg >> exp_A) & 1) {
            a = tritadd(a, shift(b, i));
            neg_Q |= 1 << i;
         }
         exp_A--;
      }
      if (sign_B < 0) {
         a = neg(a);
      }
      let q = Object.create(ctor.prototype);
      q.pos = pos_Q;
      q.neg = neg_Q;
      return [q, a];
   };

   function clmul(a, b) {
      if (((a.pos | a.neg) >>> 0) < ((b.pos | b.neg) >>> 0)) {
         let t = a; a = b; b = t;
      }
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      let both_B = pos_B | neg_B;
      let result = ctor(0);
      for (let i = 0; both_B; i++) {
         let j = 1 << i;
         if (both_B & j) {
            both_B ^= j;
            result = ((pos_B & j) ? tritadd : tritsub)(result, shift(a, i));
         }
      }
      return result;
   };

   function clmulinv(a) {
      let sign = a.neg & 1;
      if (sign) {
         a = neg(a);
      } else if (!(a.pos & 1)) {
         return null;
      }
      let b = ctor(1);
      let pos_R = 0;
      let neg_R = 0;
      for (let i = 0; i < 32; i++) {
         if (b.pos & 1) {
            b = tritsub(b, a);
            pos_R |= 1 << i;
         } else if (b.neg & 1) {
            b = tritadd(b, a);
            neg_R |= 1 << i;
         }
         b = shift(b, -1);
      }
      if (sign) {
         let t = pos_R; pos_R = neg_R; neg_R = t;
      }
      let result = Object.create(ctor.prototype);
      result.pos = pos_R;
      result.neg = neg_R;
      return result;
   };

   function clpow(a, n) {
      if (!(n >= 0 && n <= Number.MAX_SAFE_INTEGER)) {
         return null;
      }
      let s = (a.pos & 1) - (a.neg & 1);
      if (!s && n > 31) return ctor(0);
      let b = [a, clmul(a, a)];
      let r = n % 3;
      let c = r ? b[r - 1] : ctor(1);
      for (let step = 3; n = (n - r) / 3, n > 0 && step < 32; step *= 3) {
         r = n % 3;
         if (r) {
            let d = b[r - 1];
            let pos_D = d.pos | 0;
            let neg_D = d.neg | 0;
            let both_D = pos_D | neg_D;
            let n = 32 / step;
            a = ctor(0);
            for (let i = 0; i < n && both_D; i++) {
               let j = 1 << i;
               if (both_D & j) {
                  both_D ^= j;
                  a = (pos_D & j ? tritadd : tritsub)(a, shift(c, i * step));
               }
            }
            c = a;
         }
      }
      if (s < 1 && n % 2) c = neg(c);
      return c;
   };

   function clrem(a, b) {
      return cldiv_i(a, b)[1];
   };

   function clz32(a) {
      return Math.clz32(a.pos | a.neg);
   };

   function cmp(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      a = ((pos_A & ~pos_B) | (neg_B & ~neg_A)) >>> 0;
      b = ((pos_B & ~pos_A) | (neg_A & ~neg_B)) >>> 0;
      return Math.sign(a - b);
   };

   function ctz32(a) {
      a = a.pos | a.neg;
      return a ? 31 - Math.clz32(a & -a) : 32;
   };

   function dec(a) {
      return neg(inc(neg(a)));
   };

   function div(a, b) {
      let t = divrem_i(a, b);
      return t && ctor(t[0]);
   };

   function divrem_i(a, b) {
      b = valueOf(b);
      if (!b) return null;
      a = valueOf(a);
      let r = a % b;
      return [(a - r) / b, r];
   };

   function inc(a) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let b = pos_A + 1;
      let c = b & -b;
      let result = Object.create(ctor.prototype);
      result.pos = b & ~(neg_A & c);
      result.neg = (neg_A & ~c) | (c - 1);
      return result;
   };

   function max(a, b) {
      return ctor(cmp(a, b) < 0 ? a : b);
   };

   function min(a, b) {
      return ctor(cmp(a, b) > 0 ? a : b);
   };

   function mul(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      let hi_A = valueOf({pos: pos_A >>> 16, neg: neg_A >>> 16});
      let lo_A = valueOf({pos: pos_A & 0xFFFF, neg: neg_A & 0xFFFF});
      let hi_B = valueOf({pos: pos_B >>> 16, neg: neg_B >>> 16});
      let lo_B = valueOf({pos: pos_B & 0xFFFF, neg: neg_B & 0xFFFF});
      return ctor((hi_A * lo_B + hi_B * lo_A) % 43046721 * 43046721 + lo_A * lo_B);
   };

   function mulext(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      let hi_A = valueOf({pos: pos_A >>> 16, neg: neg_A >>> 16});
      let lo_A = valueOf({pos: pos_A & 0xFFFF, neg: neg_A & 0xFFFF});
      let hi_B = valueOf({pos: pos_B >>> 16, neg: neg_B >>> 16});
      let lo_B = valueOf({pos: pos_B & 0xFFFF, neg: neg_B & 0xFFFF});
      let hi_C = hi_A * hi_B;
      let mi_C = hi_A * lo_B + hi_B * lo_A;
      let lo_C = lo_A * lo_B;
      let r = mi_C % 43046721;
      lo_C += r * 43046721;
      hi_C += (mi_C - r) / 43046721;
      if (lo_C > MAX_VALUE) {
         lo_C -= 1853020188851841;
         hi_C ++;
      } else if (lo_C < MIN_VALUE) {
         lo_C += 1853020188851841;
         hi_C --;
      }
      return [ctor(lo_C), ctor(hi_C)];
   };

   function mulinv(a) {
      a = valueOf(a);
      if (!(a % 3)) return null;
      let x = a % 43046721;
      let y = (1 - x * x) % 43046721;
      while (y) {
         x = x * (1 + y) % 43046721;
         y = y * y % 43046721;
      }
      let lo = a % 43046721;
      let hi = (a - lo) / 43046721;
      return ctor(x + ((1 - lo * x) / 43046721 - hi * x % 43046721) * x % 43046721 * 43046721);
   }

   function nabs(a) {
      return neg(abs(a));
   };

   function nadd(a, b) {
      return neg(add(a, b));
   };

   function neg(a) {
      let result = Object.create(ctor.prototype);
      result.pos = a.neg;
      result.neg = a.pos;
      return result;
   };

   function nmax(a, b) {
      return neg(max(a, b));
   };

   function nmin(a, b) {
      return neg(min(a, b));
   };

   function nmul(a, b) {
      return neg(mul(a, b));
   };

   function parity(a) {
      a = a.neg | a.pos;
      a ^= a >> 16;
      a ^= a >> 8;
      a ^= a >> 4;
      return (0x6996 >> (a & 15)) & 1;
   };

   function pow(a, n) {
      if (!(n >= 0 && n <= Number.MAX_SAFE_INTEGER)) {
         return null;
      }
      let result = ctor(1);
      while (n >= 1) {
         if (n % 2 >= 1) {
            result = mul(result, a);
         }
         a = mul(a, a);
         n /= 2;
      }
      return result;
   };

   function rem(a, b) {
      let t = divrem_i(a, b);
      return t && ctor(t[1]);
   };

   function shift(a, n) {
      let pos, neg;
      if (n < -31 || n > 31) {
         pos = neg = 0;
      } else if (n < 0) {
         pos = a.pos >>> (-n);
         neg = a.neg >>> (-n);
      } else {
         pos = a.pos << n;
         neg = a.neg << n;
      }
      let result = Object.create(ctor.prototype);
      result.pos = pos;
      result.neg = neg;
      return result;
   };

   function sign(a) {
      return Math.sign((a.pos >>> 0) - (a.neg >>> 0));
   };

   function sub(a, b) {
      return add(a, neg(b));
   };

   function tritabs(a) {
      let result = Object.create(ctor.prototype);
      result.pos = a.pos | a.neg;
      result.neg = 0;
      return result;
   };

   function tritadd(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = b.pos | 0;
      let neg_B = b.neg | 0;
      let pos_XOR = pos_A ^ pos_B;
      let neg_XOR = neg_A ^ neg_B;
      let t = pos_XOR & neg_XOR;
      let pos_AND = pos_A & pos_B;
      let neg_AND = neg_A & neg_B;
      let result = Object.create(ctor.prototype);
      result.pos = neg_AND | (pos_XOR ^ t);
      result.neg = pos_AND | (neg_XOR ^ t);
      return result;
   };

   function tritany(a, b) {
      let pos_OR = a.pos | b.pos;
      let neg_OR = a.neg | b.neg;
      let t = pos_OR & neg_OR;
      let result = Object.create(ctor.prototype);
      result.pos = pos_OR ^ t;
      result.neg = neg_OR ^ t;
      return result;
   };

   function tritcmp(a, b) {
      return tritany(a, neg(b));
   };

   function tritcons(a, b) {
      let result = Object.create(ctor.prototype);
      result.pos = a.pos & b.pos;
      result.neg = a.neg & b.neg;
      return result;
   };

   function tritdec(a) {
      return neg(tritinc(neg(a)));
   };

   function triteq(a, b) {
      let neg = (a.pos ^ b.pos) | (a.neg ^ b.neg);
      let result = Object.create(ctor.prototype);
      result.pos = ~neg;
      result.neg = neg;
      return result;
   };

   function tritgt(a, b) {
      return tritlt(b, a);
   };

   function tritgte(a, b) {
      return neg(tritlt(a, b));
   };

   function tritinc(a) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let result = Object.create(ctor.prototype);
      result.pos = ~(pos_A | neg_A);
      result.neg = pos_A;
      return result;
   };

   function tritlt(a, b) {
      let pos = (~a.pos & b.pos) | (a.neg & ~b.neg);
      let result = Object.create(ctor.prototype);
      result.pos = pos;
      result.neg = ~pos;
      return result;
   };

   function tritlte(a, b) {
      return neg(tritlt(b, a));
   };

   function tritmax(a, b) {
      let result = Object.create(ctor.prototype);
      result.pos = a.pos | b.pos;
      result.neg = a.neg & b.neg;
      return result;
   };

   function tritmin(a, b) {
      let result = Object.create(ctor.prototype);
      result.pos = a.pos & b.pos;
      result.neg = a.neg | b.neg;
      return result;
   };

   function tritmul(a, b) {
      let pos_A = a.pos | 0;
      let neg_A = a.neg | 0;
      let pos_B = a.pos | 0;
      let neg_B = a.neg | 0;
      let result = Object.create(ctor.prototype);
      result.pos = (pos_A & pos_B) | (neg_A & neg_B);
      result.neg = (pos_A & neg_B) | (neg_A & pos_B);
      return result;
   };

   function tritnabs(a) {
      return neg(tritabs(a));
   };

   function tritnadd(a, b) {
      return neg(tritadd(a, b));
   };

   function tritneg(a) {
      return tritpos(neg(a));
   };
   
   function tritneq(a, b) {
      return neg(tritneq(a, b));
   };

   function tritnmax(a, b) {
      return neg(tritmax(a, b));
   };

   function tritnmin(a, b) {
      return neg(tritmin(a, b));
   };

   function tritnmul(a, b) {
      return neg(tritmul(a, b));
   };

   function tritnneg(a) {
      return neg(tritneg(a));
   };

   function tritnpos(a) {
      return neg(tritpos(a));
   };

   function tritnzero(a) {
      return neg(tritzero(a));
   };

   function tritpos(a) {
      a = a.pos;
      let result = Object.create(ctor.prototype);
      result.pos = a;
      result.neg = ~a;
      return result;
   };

   function tritsub(a, b) {
      return tritadd(a, neg(b));
   };

   function tritzero(a) {
      a = a.pos | a.neg;
      let result = Object.create(ctor.prototype);
      result.pos = ~a;
      result.neg = a;
      return result;
   };

   function toBalanced(a, tab) {
      let pos_A = a.pos;
      let neg_A = a.neg;
      let result = "";
      for (let i = 1 << 31; i; i >>>= 1) {
         result += tab[(pos_A & i) ? 2 : +!(neg_A & i)];
      }
      return result;
   };

   function valueOf(a) {
      let pos = a.pos | 0;
      let neg = a.neg | 0;
      let result = 0;
      for (let i = 1; pos || neg; i *= 3) {
         result += i * ((pos & 1) - (neg & 1));
         pos >>>= 1;
         neg >>>= 1;
      }
      return result;
   };

   ctor.MAX_VALUE = Object.freeze(ctor(MAX_VALUE));
   ctor.MIN_VALUE = Object.freeze(ctor(MIN_VALUE));
   ctor.ZERO = Object.freeze(ctor(0));
   ctor.abs = function(a, b) { return abs(cast(a)); };
   ctor.add = function(a, b) { return add(cast(a), cast(b)); };
   ctor.addcarry = function(a, b, c) { return addcarry(cast(a), cast(b), +c); };
   ctor.addext = function(a, b) { return addext(cast(a), cast(b)); };
   ctor.cast = cast;
   ctor.cldiv = function(a, b) { return cldiv(cast(a), cast(b)); };
   ctor.clmul = function(a, b) { return clmul(cast(a), cast(b)); };
   ctor.clmulinv = function(a) { return clmulinv(cast(a)); };
   ctor.clpow = function(a, b) { return clpow(cast(a), Math.trunc(b)); };
   ctor.clrem = function(a, b) { return clrem(cast(a), cast(b)); };
   ctor.clz32 = function(a) { return clz32(cast(a)); };
   ctor.cmp = function(a, b) { return cmp(cast(a), cast(b)); };
   ctor.ctz32 = function(a) { return ctz32(cast(a)); };
   ctor.dec = function(a, b) { return dec(cast(a)); };
   ctor.div = function(a, b) { return div(cast(a), cast(b)); };
   ctor.eq = function(a, b) { return !cmp(cast(a), cast(b)); };
   ctor.gt = function(a, b) { return cmp(cast(a), cast(b)) > 0; };
   ctor.gte = function(a, b) { return cmp(cast(a), cast(b)) >= 0; };
   ctor.inc = function(a, b) { return inc(cast(a)); };
   ctor.iseven = function(a) { return !parity(cast(a)); };
   ctor.isneg = function(a) { return sign(cast(a)) < 0; };
   ctor.isodd = function(a) { return !!parity(cast(a)); };
   ctor.ispos = function(a) { return sign(cast(a)) > 0; };
   ctor.iszero = function(a) { return !sign(cast(a)); };
   ctor.lt = function(a, b) { return cmp(cast(a), cast(b)) < 0; };
   ctor.lte = function(a, b) { return cmp(cast(a), cast(b)) <= 0; };
   ctor.max = function(a) { return max(cast(a), cast(b)); };
   ctor.min = function(a) { return min(cast(a), cast(b)); };
   ctor.mul = function(a, b) { return mul(cast(a), cast(b)); };
   ctor.mulext = function(a, b) { return mulext(cast(a), cast(b)); };
   ctor.mulinv = function(a) { return mulinv(cast(a)); };
   ctor.nabs = function(a) { return nabs(cast(a)); };
   ctor.nadd = function(a, b) { return nadd(cast(a), cast(b)); };
   ctor.neg = function(a) { return neg(cast(a)); };
   ctor.neq = function(a, b) { return !!cmp(cast(a), cast(b)); };
   ctor.nmax = function(a, b) { return nmax(cast(a, b)); };
   ctor.nmin = function(a, b) { return nmin(cast(a, b)); };
   ctor.nmul = function(a, b) { return nmul(cast(a, b)); };
   ctor.pow = function(a, b) { return pow(cast(a), Math.trunc(b)); };
   ctor.rem = function(a, b) { return rem(cast(a), cast(b)); };
   ctor.shift = function(a, n) { return shift(cast(a), Math.trunc(n)); };
   ctor.sign = function(a) { return sign(cast(a)); };
   ctor.sub = function(a, b) { return sub(cast(a), cast(b)); };
   ctor.tritabs = function(a) { return tritabs(cast(a)); };
   ctor.tritadd = function(a, b) { return tritadd(cast(a), cast(b)); };
   ctor.tritany = function(a, b) { return tritany(cast(a), cast(b)); };
   ctor.tritcmp = function(a, b) { return tritcmp(cast(a), cast(b)); };
   ctor.tritcons = function(a, b) { return tritcons(cast(a), cast(b)); };
   ctor.tritdec = function(a) { return tritdec(cast(a)); };
   ctor.triteq = function(a, b) { return triteq(cast(a), cast(b)); };
   ctor.tritgt = function(a, b) { return tritgt(cast(a), cast(b)); };
   ctor.tritgte = function(a, b) { return tritgte(cast(a), cast(b)); };
   ctor.tritinc = function(a) { return tritinc(cast(a)); };
   ctor.tritlt = function(a, b) { return tritlt(cast(a), cast(b)); };
   ctor.tritlte = function(a, b) { return tritlte(cast(a), cast(b)); };
   ctor.tritmax = function(a, b) { return tritmax(cast(a), cast(b)); };
   ctor.tritmin = function(a, b) { return tritmin(cast(a), cast(b)); };
   ctor.tritmul = function(a, b) { return tritmul(cast(a), cast(b)); };
   ctor.tritnabs = function(a, b) { return tritnabs(cast(a), cast(b)); };
   ctor.tritnadd = function(a, b) { return tritnadd(cast(a), cast(b)); };
   ctor.tritneg = function(a) { return tritneg(cast(a)); };
   ctor.tritneq = function(a, b) { return tritneq(cast(a), cast(b)); };
   ctor.tritnmax = function(a, b) { return tritnmax(cast(a), cast(b)); };
   ctor.tritnmin = function(a, b) { return tritnmin(cast(a), cast(b)); };
   ctor.tritnmul = function(a, b) { return tritnmul(cast(a), cast(b)); };
   ctor.tritnneg = function(a) { return tritnneg(cast(a)); };
   ctor.tritnpos = function(a) { return tritnpos(cast(a)); };
   ctor.tritnzero = function(a) { return tritnzero(cast(a)); };
   ctor.tritpos = function(a) { return tritpos(cast(a)); };
   ctor.tritsub = function(a, b) { return tritsub(cast(a), cast(b)); };
   ctor.tritzero = function(a) { return tritzero(cast(a)); };
   ctor.prototype.toBalanced = function(tab) { return toBalanced(this, String(tab == null ? "T01" : tab).split("")); };
   ctor.prototype.toString = function(radix) { return valueOf(this).toString(radix); };
   ctor.prototype.valueOf = function() { return valueOf(this); };

   return ctor;
})();