Bob is playing with $$$6$$$-sided dice. A net of such standard cube is shown below.He has an unlimited supply of these dice and wants to build a tower by stacking multiple dice on top of each other, while choosing the orientation of each dice. Then he counts the number of visible pips on the faces of the dice.For example, the number of visible pips on the tower below is $$$29$$$ — the number visible on the top is $$$1$$$, from the south $$$5$$$ and $$$3$$$, from the west $$$4$$$ and $$$2$$$, from the north $$$2$$$ and $$$4$$$ and from the east $$$3$$$ and $$$5$$$.The one at the bottom and the two sixes by which the dice are touching are not visible, so they are not counted towards total.Bob also has $$$t$$$ favourite integers $$$x_i$$$, and for every such integer his goal is to build such a tower that the number of visible pips is exactly $$$x_i$$$. For each of Bob's favourite integers determine whether it is possible to build a tower that has exactly that many visible pips.

The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 1000$$$) — the number of favourite integers of Bob.  The second line contains $$$t$$$ space-separated integers $$$x_i$$$ ($$$1 \leq x_i \leq 10^{18}$$$) — Bob's favourite integers.

For each of Bob's favourite integers, output "YES" if it is possible to build the tower, or "NO" otherwise (quotes for clarity).

NoteThe first example is mentioned in the problem statement.In the second example, one can build the tower by flipping the top dice from the previous tower.In the third example, one can use a single die that has $$$5$$$ on top.The fourth example is impossible.

// thanks https://github.com/peterolson/BigInteger.js/tree/master

var bigInt = (function (undefined) {
    "use strict";

    var BASE = 1e7,
        LOG_BASE = 7,
        MAX_INT = 9007199254740992,
        MAX_INT_ARR = smallToArray(MAX_INT),
        DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";

    var supportsNativeBigInt = typeof BigInt === "function";

    function Integer(v, radix, alphabet, caseSensitive) {
        if (typeof v === "undefined") return Integer[0];
        if (typeof radix !== "undefined") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);
        return parseValue(v);
    }

    function BigInteger(value, sign) {
        this.value = value;
        this.sign = sign;
        this.isSmall = false;
    }
    BigInteger.prototype = Object.create(Integer.prototype);

    function SmallInteger(value) {
        this.value = value;
        this.sign = value < 0;
        this.isSmall = true;
    }
    SmallInteger.prototype = Object.create(Integer.prototype);

    function NativeBigInt(value) {
        this.value = value;
    }
    NativeBigInt.prototype = Object.create(Integer.prototype);

    function isPrecise(n) {
        return -MAX_INT < n && n < MAX_INT;
    }

    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes
        if (n < 1e7)
            return [n];
        if (n < 1e14)
            return [n % 1e7, Math.floor(n / 1e7)];
        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
    }

    function arrayToSmall(arr) { // If BASE changes this function may need to change
        trim(arr);
        var length = arr.length;
        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
            switch (length) {
                case 0: return 0;
                case 1: return arr[0];
                case 2: return arr[0] + arr[1] * BASE;
                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
            }
        }
        return arr;
    }

    function trim(v) {
        var i = v.length;
        while (v[--i] === 0);
        v.length = i + 1;
    }

    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger
        var x = new Array(length);
        var i = -1;
        while (++i < length) {
            x[i] = 0;
        }
        return x;
    }

    function truncate(n) {
        if (n > 0) return Math.floor(n);
        return Math.ceil(n);
    }

    function add(a, b) { // assumes a and b are arrays with a.length >= b.length
        var l_a = a.length,
            l_b = b.length,
            r = new Array(l_a),
            carry = 0,
            base = BASE,
            sum, i;
        for (i = 0; i < l_b; i++) {
            sum = a[i] + b[i] + carry;
            carry = sum >= base ? 1 : 0;
            r[i] = sum - carry * base;
        }
        while (i < l_a) {
            sum = a[i] + carry;
            carry = sum === base ? 1 : 0;
            r[i++] = sum - carry * base;
        }
        if (carry > 0) r.push(carry);
        return r;
    }

    function addAny(a, b) {
        if (a.length >= b.length) return add(a, b);
        return add(b, a);
    }

    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT
        var l = a.length,
            r = new Array(l),
            base = BASE,
            sum, i;
        for (i = 0; i < l; i++) {
            sum = a[i] - base + carry;
            carry = Math.floor(sum / base);
            r[i] = sum - carry * base;
            carry += 1;
        }
        while (carry > 0) {
            r[i++] = carry % base;
            carry = Math.floor(carry / base);
        }
        return r;
    }

    BigInteger.prototype.add = function (v) {
        var n = parseValue(v);
        if (this.sign !== n.sign) {
            return this.subtract(n.negate());
        }
        var a = this.value, b = n.value;
        if (n.isSmall) {
            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
        }
        return new BigInteger(addAny(a, b), this.sign);
    };
    BigInteger.prototype.plus = BigInteger.prototype.add;

    SmallInteger.prototype.add = function (v) {
        var n = parseValue(v);
        var a = this.value;
        if (a < 0 !== n.sign) {
            return this.subtract(n.negate());
        }
        var b = n.value;
        if (n.isSmall) {
            if (isPrecise(a + b)) return new SmallInteger(a + b);
            b = smallToArray(Math.abs(b));
        }
        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
    };
    SmallInteger.prototype.plus = SmallInteger.prototype.add;

    NativeBigInt.prototype.add = function (v) {
        return new NativeBigInt(this.value + parseValue(v).value);
    }
    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;

    function subtract(a, b) { // assumes a and b are arrays with a >= b
        var a_l = a.length,
            b_l = b.length,
            r = new Array(a_l),
            borrow = 0,
            base = BASE,
            i, difference;
        for (i = 0; i < b_l; i++) {
            difference = a[i] - borrow - b[i];
            if (difference < 0) {
                difference += base;
                borrow = 1;
            } else borrow = 0;
            r[i] = difference;
        }
        for (i = b_l; i < a_l; i++) {
            difference = a[i] - borrow;
            if (difference < 0) difference += base;
            else {
                r[i++] = difference;
                break;
            }
            r[i] = difference;
        }
        for (; i < a_l; i++) {
            r[i] = a[i];
        }
        trim(r);
        return r;
    }

    function subtractAny(a, b, sign) {
        var value;
        if (compareAbs(a, b) >= 0) {
            value = subtract(a, b);
        } else {
            value = subtract(b, a);
            sign = !sign;
        }
        value = arrayToSmall(value);
        if (typeof value === "number") {
            if (sign) value = -value;
            return new SmallInteger(value);
        }
        return new BigInteger(value, sign);
    }

    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT
        var l = a.length,
            r = new Array(l),
            carry = -b,
            base = BASE,
            i, difference;
        for (i = 0; i < l; i++) {
            difference = a[i] + carry;
            carry = Math.floor(difference / base);
            difference %= base;
            r[i] = difference < 0 ? difference + base : difference;
        }
        r = arrayToSmall(r);
        if (typeof r === "number") {
            if (sign) r = -r;
            return new SmallInteger(r);
        } return new BigInteger(r, sign);
    }

    BigInteger.prototype.subtract = function (v) {
        var n = parseValue(v);
        if (this.sign !== n.sign) {
            return this.add(n.negate());
        }
        var a = this.value, b = n.value;
        if (n.isSmall)
            return subtractSmall(a, Math.abs(b), this.sign);
        return subtractAny(a, b, this.sign);
    };
    BigInteger.prototype.minus = BigInteger.prototype.subtract;

    SmallInteger.prototype.subtract = function (v) {
        var n = parseValue(v);
        var a = this.value;
        if (a < 0 !== n.sign) {
            return this.add(n.negate());
        }
        var b = n.value;
        if (n.isSmall) {
            return new SmallInteger(a - b);
        }
        return subtractSmall(b, Math.abs(a), a >= 0);
    };
    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;

    NativeBigInt.prototype.subtract = function (v) {
        return new NativeBigInt(this.value - parseValue(v).value);
    }
    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;

    BigInteger.prototype.negate = function () {
        return new BigInteger(this.value, !this.sign);
    };
    SmallInteger.prototype.negate = function () {
        var sign = this.sign;
        var small = new SmallInteger(-this.value);
        small.sign = !sign;
        return small;
    };
    NativeBigInt.prototype.negate = function () {
        return new NativeBigInt(-this.value);
    }

    BigInteger.prototype.abs = function () {
        return new BigInteger(this.value, false);
    };
    SmallInteger.prototype.abs = function () {
        return new SmallInteger(Math.abs(this.value));
    };
    NativeBigInt.prototype.abs = function () {
        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
    }

    function multiplyLong(a, b) {
        var a_l = a.length,
            b_l = b.length,
            l = a_l + b_l,
            r = createArray(l),
            base = BASE,
            product, carry, i, a_i, b_j;
        for (i = 0; i < a_l; ++i) {
            a_i = a[i];
            for (var j = 0; j < b_l; ++j) {
                b_j = b[j];
                product = a_i * b_j + r[i + j];
                carry = Math.floor(product / base);
                r[i + j] = product - carry * base;
                r[i + j + 1] += carry;
            }
        }
        trim(r);
        return r;
    }

    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE
        var l = a.length,
            r = new Array(l),
            base = BASE,
            carry = 0,
            product, i;
        for (i = 0; i < l; i++) {
            product = a[i] * b + carry;
            carry = Math.floor(product / base);
            r[i] = product - carry * base;
        }
        while (carry > 0) {
            r[i++] = carry % base;
            carry = Math.floor(carry / base);
        }
        return r;
    }

    function shiftLeft(x, n) {
        var r = [];
        while (n-- > 0) r.push(0);
        return r.concat(x);
    }

    function multiplyKaratsuba(x, y) {
        var n = Math.max(x.length, y.length);

        if (n <= 30) return multiplyLong(x, y);
        n = Math.ceil(n / 2);

        var b = x.slice(n),
            a = x.slice(0, n),
            d = y.slice(n),
            c = y.slice(0, n);

        var ac = multiplyKaratsuba(a, c),
            bd = multiplyKaratsuba(b, d),
            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));

        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
        trim(product);
        return product;
    }

    // The following function is derived from a surface fit of a graph plotting the performance difference
    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.
    function useKaratsuba(l1, l2) {
        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;
    }

    BigInteger.prototype.multiply = function (v) {
        var n = parseValue(v),
            a = this.value, b = n.value,
            sign = this.sign !== n.sign,
            abs;
        if (n.isSmall) {
            if (b === 0) return Integer[0];
            if (b === 1) return this;
            if (b === -1) return this.negate();
            abs = Math.abs(b);
            if (abs < BASE) {
                return new BigInteger(multiplySmall(a, abs), sign);
            }
            b = smallToArray(abs);
        }
        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes
            return new BigInteger(multiplyKaratsuba(a, b), sign);
        return new BigInteger(multiplyLong(a, b), sign);
    };

    BigInteger.prototype.times = BigInteger.prototype.multiply;

    function multiplySmallAndArray(a, b, sign) { // a >= 0
        if (a < BASE) {
            return new BigInteger(multiplySmall(b, a), sign);
        }
        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
    }
    SmallInteger.prototype._multiplyBySmall = function (a) {
        if (isPrecise(a.value * this.value)) {
            return new SmallInteger(a.value * this.value);
        }
        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
    };
    BigInteger.prototype._multiplyBySmall = function (a) {
        if (a.value === 0) return Integer[0];
        if (a.value === 1) return this;
        if (a.value === -1) return this.negate();
        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
    };
    SmallInteger.prototype.multiply = function (v) {
        return parseValue(v)._multiplyBySmall(this);
    };
    SmallInteger.prototype.times = SmallInteger.prototype.multiply;

    NativeBigInt.prototype.multiply = function (v) {
        return new NativeBigInt(this.value * parseValue(v).value);
    }
    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;

    function square(a) {
        //console.assert(2 * BASE * BASE < MAX_INT);
        var l = a.length,
            r = createArray(l + l),
            base = BASE,
            product, carry, i, a_i, a_j;
        for (i = 0; i < l; i++) {
            a_i = a[i];
            carry = 0 - a_i * a_i;
            for (var j = i; j < l; j++) {
                a_j = a[j];
                product = 2 * (a_i * a_j) + r[i + j] + carry;
                carry = Math.floor(product / base);
                r[i + j] = product - carry * base;
            }
            r[i + l] = carry;
        }
        trim(r);
        return r;
    }

    BigInteger.prototype.square = function () {
        return new BigInteger(square(this.value), false);
    };

    SmallInteger.prototype.square = function () {
        var value = this.value * this.value;
        if (isPrecise(value)) return new SmallInteger(value);
        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
    };

    NativeBigInt.prototype.square = function (v) {
        return new NativeBigInt(this.value * this.value);
    }

    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.
        var a_l = a.length,
            b_l = b.length,
            base = BASE,
            result = createArray(b.length),
            divisorMostSignificantDigit = b[b_l - 1],
            // normalization
            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
            remainder = multiplySmall(a, lambda),
            divisor = multiplySmall(b, lambda),
            quotientDigit, shift, carry, borrow, i, l, q;
        if (remainder.length <= a_l) remainder.push(0);
        divisor.push(0);
        divisorMostSignificantDigit = divisor[b_l - 1];
        for (shift = a_l - b_l; shift >= 0; shift--) {
            quotientDigit = base - 1;
            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
            }
            // quotientDigit <= base - 1
            carry = 0;
            borrow = 0;
            l = divisor.length;
            for (i = 0; i < l; i++) {
                carry += quotientDigit * divisor[i];
                q = Math.floor(carry / base);
                borrow += remainder[shift + i] - (carry - q * base);
                carry = q;
                if (borrow < 0) {
                    remainder[shift + i] = borrow + base;
                    borrow = -1;
                } else {
                    remainder[shift + i] = borrow;
                    borrow = 0;
                }
            }
            while (borrow !== 0) {
                quotientDigit -= 1;
                carry = 0;
                for (i = 0; i < l; i++) {
                    carry += remainder[shift + i] - base + divisor[i];
                    if (carry < 0) {
                        remainder[shift + i] = carry + base;
                        carry = 0;
                    } else {
                        remainder[shift + i] = carry;
                        carry = 1;
                    }
                }
                borrow += carry;
            }
            result[shift] = quotientDigit;
        }
        // denormalization
        remainder = divModSmall(remainder, lambda)[0];
        return [arrayToSmall(result), arrayToSmall(remainder)];
    }

    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/
        // Performs faster than divMod1 on larger input sizes.
        var a_l = a.length,
            b_l = b.length,
            result = [],
            part = [],
            base = BASE,
            guess, xlen, highx, highy, check;
        while (a_l) {
            part.unshift(a[--a_l]);
            trim(part);
            if (compareAbs(part, b) < 0) {
                result.push(0);
                continue;
            }
            xlen = part.length;
            highx = part[xlen - 1] * base + part[xlen - 2];
            highy = b[b_l - 1] * base + b[b_l - 2];
            if (xlen > b_l) {
                highx = (highx + 1) * base;
            }
            guess = Math.ceil(highx / highy);
            do {
                check = multiplySmall(b, guess);
                if (compareAbs(check, part) <= 0) break;
                guess--;
            } while (guess);
            result.push(guess);
            part = subtract(part, check);
        }
        result.reverse();
        return [arrayToSmall(result), arrayToSmall(part)];
    }

    function divModSmall(value, lambda) {
        var length = value.length,
            quotient = createArray(length),
            base = BASE,
            i, q, remainder, divisor;
        remainder = 0;
        for (i = length - 1; i >= 0; --i) {
            divisor = remainder * base + value[i];
            q = truncate(divisor / lambda);
            remainder = divisor - q * lambda;
            quotient[i] = q | 0;
        }
        return [quotient, remainder | 0];
    }

    function divModAny(self, v) {
        var value, n = parseValue(v);
        if (supportsNativeBigInt) {
            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];
        }
        var a = self.value, b = n.value;
        var quotient;
        if (b === 0) throw new Error("Cannot divide by zero");
        if (self.isSmall) {
            if (n.isSmall) {
                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
            }
            return [Integer[0], self];
        }
        if (n.isSmall) {
            if (b === 1) return [self, Integer[0]];
            if (b == -1) return [self.negate(), Integer[0]];
            var abs = Math.abs(b);
            if (abs < BASE) {
                value = divModSmall(a, abs);
                quotient = arrayToSmall(value[0]);
                var remainder = value[1];
                if (self.sign) remainder = -remainder;
                if (typeof quotient === "number") {
                    if (self.sign !== n.sign) quotient = -quotient;
                    return [new SmallInteger(quotient), new SmallInteger(remainder)];
                }
                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];
            }
            b = smallToArray(abs);
        }
        var comparison = compareAbs(a, b);
        if (comparison === -1) return [Integer[0], self];
        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];

        // divMod1 is faster on smaller input sizes
        if (a.length + b.length <= 200)
            value = divMod1(a, b);
        else value = divMod2(a, b);

        quotient = value[0];
        var qSign = self.sign !== n.sign,
            mod = value[1],
            mSign = self.sign;
        if (typeof quotient === "number") {
            if (qSign) quotient = -quotient;
            quotient = new SmallInteger(quotient);
        } else quotient = new BigInteger(quotient, qSign);
        if (typeof mod === "number") {
            if (mSign) mod = -mod;
            mod = new SmallInteger(mod);
        } else mod = new BigInteger(mod, mSign);
        return [quotient, mod];
    }

    BigInteger.prototype.divmod = function (v) {
        var result = divModAny(this, v);
        return {
            quotient: result[0],
            remainder: result[1]
        };
    };
    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;

    BigInteger.prototype.divide = function (v) {
        return divModAny(this, v)[0];
    };
    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {
        return new NativeBigInt(this.value / parseValue(v).value);
    };
    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;

    BigInteger.prototype.mod = function (v) {
        return divModAny(this, v)[1];
    };
    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {
        return new NativeBigInt(this.value % parseValue(v).value);
    };
    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;

    BigInteger.prototype.pow = function (v) {
        var n = parseValue(v),
            a = this.value,
            b = n.value,
            value, x, y;
        if (b === 0) return Integer[1];
        if (a === 0) return Integer[0];
        if (a === 1) return Integer[1];
        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
        if (n.sign) {
            return Integer[0];
        }
        if (!n.isSmall) throw new Error("The exponent " + n.toString() + " is too large.");
        if (this.isSmall) {
            if (isPrecise(value = Math.pow(a, b)))
                return new SmallInteger(truncate(value));
        }
        x = this;
        y = Integer[1];
        while (true) {
            if (b & 1 === 1) {
                y = y.times(x);
                --b;
            }
            if (b === 0) break;
            b /= 2;
            x = x.square();
        }
        return y;
    };
    SmallInteger.prototype.pow = BigInteger.prototype.pow;

    NativeBigInt.prototype.pow = function (v) {
        var n = parseValue(v);
        var a = this.value, b = n.value;
        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);
        if (b === _0) return Integer[1];
        if (a === _0) return Integer[0];
        if (a === _1) return Integer[1];
        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];
        if (n.isNegative()) return new NativeBigInt(_0);
        var x = this;
        var y = Integer[1];
        while (true) {
            if ((b & _1) === _1) {
                y = y.times(x);
                --b;
            }
            if (b === _0) break;
            b /= _2;
            x = x.square();
        }
        return y;
    }

    BigInteger.prototype.modPow = function (exp, mod) {
        exp = parseValue(exp);
        mod = parseValue(mod);
        if (mod.isZero()) throw new Error("Cannot take modPow with modulus 0");
        var r = Integer[1],
            base = this.mod(mod);
        if (exp.isNegative()) {
            exp = exp.multiply(Integer[-1]);
            base = base.modInv(mod);
        }
        while (exp.isPositive()) {
            if (base.isZero()) return Integer[0];
            if (exp.isOdd()) r = r.multiply(base).mod(mod);
            exp = exp.divide(2);
            base = base.square().mod(mod);
        }
        return r;
    };
    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;

    function compareAbs(a, b) {
        if (a.length !== b.length) {
            return a.length > b.length ? 1 : -1;
        }
        for (var i = a.length - 1; i >= 0; i--) {
            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
        }
        return 0;
    }

    BigInteger.prototype.compareAbs = function (v) {
        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (n.isSmall) return 1;
        return compareAbs(a, b);
    };
    SmallInteger.prototype.compareAbs = function (v) {
        var n = parseValue(v),
            a = Math.abs(this.value),
            b = n.value;
        if (n.isSmall) {
            b = Math.abs(b);
            return a === b ? 0 : a > b ? 1 : -1;
        }
        return -1;
    };
    NativeBigInt.prototype.compareAbs = function (v) {
        var a = this.value;
        var b = parseValue(v).value;
        a = a >= 0 ? a : -a;
        b = b >= 0 ? b : -b;
        return a === b ? 0 : a > b ? 1 : -1;
    }

    BigInteger.prototype.compare = function (v) {
        // See discussion about comparison with Infinity:
        // https://github.com/peterolson/BigInteger.js/issues/61
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }

        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (this.sign !== n.sign) {
            return n.sign ? 1 : -1;
        }
        if (n.isSmall) {
            return this.sign ? -1 : 1;
        }
        return compareAbs(a, b) * (this.sign ? -1 : 1);
    };
    BigInteger.prototype.compareTo = BigInteger.prototype.compare;

    SmallInteger.prototype.compare = function (v) {
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }

        var n = parseValue(v),
            a = this.value,
            b = n.value;
        if (n.isSmall) {
            return a == b ? 0 : a > b ? 1 : -1;
        }
        if (a < 0 !== n.sign) {
            return a < 0 ? -1 : 1;
        }
        return a < 0 ? 1 : -1;
    };
    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;

    NativeBigInt.prototype.compare = function (v) {
        if (v === Infinity) {
            return -1;
        }
        if (v === -Infinity) {
            return 1;
        }
        var a = this.value;
        var b = parseValue(v).value;
        return a === b ? 0 : a > b ? 1 : -1;
    }
    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;

    BigInteger.prototype.equals = function (v) {
        return this.compare(v) === 0;
    };
    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;

    BigInteger.prototype.notEquals = function (v) {
        return this.compare(v) !== 0;
    };
    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;

    BigInteger.prototype.greater = function (v) {
        return this.compare(v) > 0;
    };
    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;

    BigInteger.prototype.lesser = function (v) {
        return this.compare(v) < 0;
    };
    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;

    BigInteger.prototype.greaterOrEquals = function (v) {
        return this.compare(v) >= 0;
    };
    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;

    BigInteger.prototype.lesserOrEquals = function (v) {
        return this.compare(v) <= 0;
    };
    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;

    BigInteger.prototype.isEven = function () {
        return (this.value[0] & 1) === 0;
    };
    SmallInteger.prototype.isEven = function () {
        return (this.value & 1) === 0;
    };
    NativeBigInt.prototype.isEven = function () {
        return (this.value & BigInt(1)) === BigInt(0);
    }

    BigInteger.prototype.isOdd = function () {
        return (this.value[0] & 1) === 1;
    };
    SmallInteger.prototype.isOdd = function () {
        return (this.value & 1) === 1;
    };
    NativeBigInt.prototype.isOdd = function () {
        return (this.value & BigInt(1)) === BigInt(1);
    }

    BigInteger.prototype.isPositive = function () {
        return !this.sign;
    };
    SmallInteger.prototype.isPositive = function () {
        return this.value > 0;
    };
    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;

    BigInteger.prototype.isNegative = function () {
        return this.sign;
    };
    SmallInteger.prototype.isNegative = function () {
        return this.value < 0;
    };
    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;

    BigInteger.prototype.isUnit = function () {
        return false;
    };
    SmallInteger.prototype.isUnit = function () {
        return Math.abs(this.value) === 1;
    };
    NativeBigInt.prototype.isUnit = function () {
        return this.abs().value === BigInt(1);
    }

    BigInteger.prototype.isZero = function () {
        return false;
    };
    SmallInteger.prototype.isZero = function () {
        return this.value === 0;
    };
    NativeBigInt.prototype.isZero = function () {
        return this.value === BigInt(0);
    }

    BigInteger.prototype.isDivisibleBy = function (v) {
        var n = parseValue(v);
        if (n.isZero()) return false;
        if (n.isUnit()) return true;
        if (n.compareAbs(2) === 0) return this.isEven();
        return this.mod(n).isZero();
    };
    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;

    function isBasicPrime(v) {
        var n = v.abs();
        if (n.isUnit()) return false;
        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
        if (n.lesser(49)) return true;
        // we don't know if it's prime: let the other functions figure it out
    }

    function millerRabinTest(n, a) {
        var nPrev = n.prev(),
            b = nPrev,
            r = 0,
            d, t, i, x;
        while (b.isEven()) b = b.divide(2), r++;
        next: for (i = 0; i < a.length; i++) {
            if (n.lesser(a[i])) continue;
            x = bigInt(a[i]).modPow(b, n);
            if (x.isUnit() || x.equals(nPrev)) continue;
            for (d = r - 1; d != 0; d--) {
                x = x.square().mod(n);
                if (x.isUnit()) return false;
                if (x.equals(nPrev)) continue next;
            }
            return false;
        }
        return true;
    }

    // Set "strict" to true to force GRH-supported lower bound of 2*log(N)^2
    BigInteger.prototype.isPrime = function (strict) {
        var isPrime = isBasicPrime(this);
        if (isPrime !== undefined) return isPrime;
        var n = this.abs();
        var bits = n.bitLength();
        if (bits <= 64)
            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
        var logN = Math.log(2) * bits.toJSNumber();
        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);
        for (var a = [], i = 0; i < t; i++) {
            a.push(bigInt(i + 2));
        }
        return millerRabinTest(n, a);
    };
    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;

    BigInteger.prototype.isProbablePrime = function (iterations, rng) {
        var isPrime = isBasicPrime(this);
        if (isPrime !== undefined) return isPrime;
        var n = this.abs();
        var t = iterations === undefined ? 5 : iterations;
        for (var a = [], i = 0; i < t; i++) {
            a.push(bigInt.randBetween(2, n.minus(2), rng));
        }
        return millerRabinTest(n, a);
    };
    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;

    BigInteger.prototype.modInv = function (n) {
        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
        while (!newR.isZero()) {
            q = r.divide(newR);
            lastT = t;
            lastR = r;
            t = newT;
            r = newR;
            newT = lastT.subtract(q.multiply(newT));
            newR = lastR.subtract(q.multiply(newR));
        }
        if (!r.isUnit()) throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
        if (t.compare(0) === -1) {
            t = t.add(n);
        }
        if (this.isNegative()) {
            return t.negate();
        }
        return t;
    };

    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;

    BigInteger.prototype.next = function () {
        var value = this.value;
        if (this.sign) {
            return subtractSmall(value, 1, this.sign);
        }
        return new BigInteger(addSmall(value, 1), this.sign);
    };
    SmallInteger.prototype.next = function () {
        var value = this.value;
        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
        return new BigInteger(MAX_INT_ARR, false);
    };
    NativeBigInt.prototype.next = function () {
        return new NativeBigInt(this.value + BigInt(1));
    }

    BigInteger.prototype.prev = function () {
        var value = this.value;
        if (this.sign) {
            return new BigInteger(addSmall(value, 1), true);
        }
        return subtractSmall(value, 1, this.sign);
    };
    SmallInteger.prototype.prev = function () {
        var value = this.value;
        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
        return new BigInteger(MAX_INT_ARR, true);
    };
    NativeBigInt.prototype.prev = function () {
        return new NativeBigInt(this.value - BigInt(1));
    }

    var powersOfTwo = [1];
    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];

    function shift_isSmall(n) {
        return Math.abs(n) <= BASE;
    }

    BigInteger.prototype.shiftLeft = function (v) {
        var n = parseValue(v).toJSNumber();
        if (!shift_isSmall(n)) {
            throw new Error(String(n) + " is too large for shifting.");
        }
        if (n < 0) return this.shiftRight(-n);
        var result = this;
        if (result.isZero()) return result;
        while (n >= powers2Length) {
            result = result.multiply(highestPower2);
            n -= powers2Length - 1;
        }
        return result.multiply(powersOfTwo[n]);
    };
    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;

    BigInteger.prototype.shiftRight = function (v) {
        var remQuo;
        var n = parseValue(v).toJSNumber();
        if (!shift_isSmall(n)) {
            throw new Error(String(n) + " is too large for shifting.");
        }
        if (n < 0) return this.shiftLeft(-n);
        var result = this;
        while (n >= powers2Length) {
            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;
            remQuo = divModAny(result, highestPower2);
            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
            n -= powers2Length - 1;
        }
        remQuo = divModAny(result, powersOfTwo[n]);
        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
    };
    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;

    function bitwise(x, y, fn) {
        y = parseValue(y);
        var xSign = x.isNegative(), ySign = y.isNegative();
        var xRem = xSign ? x.not() : x,
            yRem = ySign ? y.not() : y;
        var xDigit = 0, yDigit = 0;
        var xDivMod = null, yDivMod = null;
        var result = [];
        while (!xRem.isZero() || !yRem.isZero()) {
            xDivMod = divModAny(xRem, highestPower2);
            xDigit = xDivMod[1].toJSNumber();
            if (xSign) {
                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers
            }

            yDivMod = divModAny(yRem, highestPower2);
            yDigit = yDivMod[1].toJSNumber();
            if (ySign) {
                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers
            }

            xRem = xDivMod[0];
            yRem = yDivMod[0];
            result.push(fn(xDigit, yDigit));
        }
        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
        for (var i = result.length - 1; i >= 0; i -= 1) {
            sum = sum.multiply(highestPower2).add(bigInt(result[i]));
        }
        return sum;
    }

    BigInteger.prototype.not = function () {
        return this.negate().prev();
    };
    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;

    BigInteger.prototype.and = function (n) {
        return bitwise(this, n, function (a, b) { return a & b; });
    };
    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;

    BigInteger.prototype.or = function (n) {
        return bitwise(this, n, function (a, b) { return a | b; });
    };
    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;

    BigInteger.prototype.xor = function (n) {
        return bitwise(this, n, function (a, b) { return a ^ b; });
    };
    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;

    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
    function roughLOB(n) { // get lowestOneBit (rough)
        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)
        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]
        var v = n.value,
            x = typeof v === "number" ? v | LOBMASK_I :
                typeof v === "bigint" ? v | BigInt(LOBMASK_I) :
                    v[0] + v[1] * BASE | LOBMASK_BI;
        return x & -x;
    }

    function integerLogarithm(value, base) {
        if (base.compareTo(value) <= 0) {
            var tmp = integerLogarithm(value, base.square(base));
            var p = tmp.p;
            var e = tmp.e;
            var t = p.multiply(base);
            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };
        }
        return { p: bigInt(1), e: 0 };
    }

    BigInteger.prototype.bitLength = function () {
        var n = this;
        if (n.compareTo(bigInt(0)) < 0) {
            n = n.negate().subtract(bigInt(1));
        }
        if (n.compareTo(bigInt(0)) === 0) {
            return bigInt(0);
        }
        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
    }
    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;

    function max(a, b) {
        a = parseValue(a);
        b = parseValue(b);
        return a.greater(b) ? a : b;
    }
    function min(a, b) {
        a = parseValue(a);
        b = parseValue(b);
        return a.lesser(b) ? a : b;
    }
    function gcd(a, b) {
        a = parseValue(a).abs();
        b = parseValue(b).abs();
        if (a.equals(b)) return a;
        if (a.isZero()) return b;
        if (b.isZero()) return a;
        var c = Integer[1], d, t;
        while (a.isEven() && b.isEven()) {
            d = min(roughLOB(a), roughLOB(b));
            a = a.divide(d);
            b = b.divide(d);
            c = c.multiply(d);
        }
        while (a.isEven()) {
            a = a.divide(roughLOB(a));
        }
        do {
            while (b.isEven()) {
                b = b.divide(roughLOB(b));
            }
            if (a.greater(b)) {
                t = b; b = a; a = t;
            }
            b = b.subtract(a);
        } while (!b.isZero());
        return c.isUnit() ? a : a.multiply(c);
    }
    function lcm(a, b) {
        a = parseValue(a).abs();
        b = parseValue(b).abs();
        return a.divide(gcd(a, b)).multiply(b);
    }
    function randBetween(a, b, rng) {
        a = parseValue(a);
        b = parseValue(b);
        var usedRNG = rng || Math.random;
        var low = min(a, b), high = max(a, b);
        var range = high.subtract(low).add(1);
        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));
        var digits = toBase(range, BASE).value;
        var result = [], restricted = true;
        for (var i = 0; i < digits.length; i++) {
            var top = restricted ? digits[i] : BASE;
            var digit = truncate(usedRNG() * top);
            result.push(digit);
            if (digit < top) restricted = false;
        }
        return low.add(Integer.fromArray(result, BASE, false));
    }

    var parseBase = function (text, base, alphabet, caseSensitive) {
        alphabet = alphabet || DEFAULT_ALPHABET;
        text = String(text);
        if (!caseSensitive) {
            text = text.toLowerCase();
            alphabet = alphabet.toLowerCase();
        }
        var length = text.length;
        var i;
        var absBase = Math.abs(base);
        var alphabetValues = {};
        for (i = 0; i < alphabet.length; i++) {
            alphabetValues[alphabet[i]] = i;
        }
        for (i = 0; i < length; i++) {
            var c = text[i];
            if (c === "-") continue;
            if (c in alphabetValues) {
                if (alphabetValues[c] >= absBase) {
                    if (c === "1" && absBase === 1) continue;
                    throw new Error(c + " is not a valid digit in base " + base + ".");
                }
            }
        }
        base = parseValue(base);
        var digits = [];
        var isNegative = text[0] === "-";
        for (i = isNegative ? 1 : 0; i < text.length; i++) {
            var c = text[i];
            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));
            else if (c === "<") {
                var start = i;
                do { i++; } while (text[i] !== ">" && i < text.length);
                digits.push(parseValue(text.slice(start + 1, i)));
            }
            else throw new Error(c + " is not a valid character");
        }
        return parseBaseFromArray(digits, base, isNegative);
    };

    function parseBaseFromArray(digits, base, isNegative) {
        var val = Integer[0], pow = Integer[1], i;
        for (i = digits.length - 1; i >= 0; i--) {
            val = val.add(digits[i].times(pow));
            pow = pow.times(base);
        }
        return isNegative ? val.negate() : val;
    }

    function stringify(digit, alphabet) {
        alphabet = alphabet || DEFAULT_ALPHABET;
        if (digit < alphabet.length) {
            return alphabet[digit];
        }
        return "<" + digit + ">";
    }

    function toBase(n, base) {
        base = bigInt(base);
        if (base.isZero()) {
            if (n.isZero()) return { value: [0], isNegative: false };
            throw new Error("Cannot convert nonzero numbers to base 0.");
        }
        if (base.equals(-1)) {
            if (n.isZero()) return { value: [0], isNegative: false };
            if (n.isNegative())
                return {
                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))
                        .map(Array.prototype.valueOf, [1, 0])
                    ),
                    isNegative: false
                };

            var arr = Array.apply(null, Array(n.toJSNumber() - 1))
                .map(Array.prototype.valueOf, [0, 1]);
            arr.unshift([1]);
            return {
                value: [].concat.apply([], arr),
                isNegative: false
            };
        }

        var neg = false;
        if (n.isNegative() && base.isPositive()) {
            neg = true;
            n = n.abs();
        }
        if (base.isUnit()) {
            if (n.isZero()) return { value: [0], isNegative: false };

            return {
                value: Array.apply(null, Array(n.toJSNumber()))
                    .map(Number.prototype.valueOf, 1),
                isNegative: neg
            };
        }
        var out = [];
        var left = n, divmod;
        while (left.isNegative() || left.compareAbs(base) >= 0) {
            divmod = left.divmod(base);
            left = divmod.quotient;
            var digit = divmod.remainder;
            if (digit.isNegative()) {
                digit = base.minus(digit).abs();
                left = left.next();
            }
            out.push(digit.toJSNumber());
        }
        out.push(left.toJSNumber());
        return { value: out.reverse(), isNegative: neg };
    }

    function toBaseString(n, base, alphabet) {
        var arr = toBase(n, base);
        return (arr.isNegative ? "-" : "") + arr.value.map(function (x) {
            return stringify(x, alphabet);
        }).join('');
    }

    BigInteger.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    SmallInteger.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    NativeBigInt.prototype.toArray = function (radix) {
        return toBase(this, radix);
    };

    BigInteger.prototype.toString = function (radix, alphabet) {
        if (radix === undefined) radix = 10;
        if (radix !== 10) return toBaseString(this, radix, alphabet);
        var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
        while (--l >= 0) {
            digit = String(v[l]);
            str += zeros.slice(digit.length) + digit;
        }
        var sign = this.sign ? "-" : "";
        return sign + str;
    };

    SmallInteger.prototype.toString = function (radix, alphabet) {
        if (radix === undefined) radix = 10;
        if (radix != 10) return toBaseString(this, radix, alphabet);
        return String(this.value);
    };

    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;

    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }

    BigInteger.prototype.valueOf = function () {
        return parseInt(this.toString(), 10);
    };
    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;

    SmallInteger.prototype.valueOf = function () {
        return this.value;
    };
    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {
        return parseInt(this.toString(), 10);
    }

    function parseStringValue(v) {
        if (isPrecise(+v)) {
            var x = +v;
            if (x === truncate(x))
                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);
            throw new Error("Invalid integer: " + v);
        }
        var sign = v[0] === "-";
        if (sign) v = v.slice(1);
        var split = v.split(/e/i);
        if (split.length > 2) throw new Error("Invalid integer: " + split.join("e"));
        if (split.length === 2) {
            var exp = split[1];
            if (exp[0] === "+") exp = exp.slice(1);
            exp = +exp;
            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
            var text = split[0];
            var decimalPlace = text.indexOf(".");
            if (decimalPlace >= 0) {
                exp -= text.length - decimalPlace - 1;
                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
            }
            if (exp < 0) throw new Error("Cannot include negative exponent part for integers");
            text += (new Array(exp + 1)).join("0");
            v = text;
        }
        var isValid = /^([0-9][0-9]*)$/.test(v);
        if (!isValid) throw new Error("Invalid integer: " + v);
        if (supportsNativeBigInt) {
            return new NativeBigInt(BigInt(sign ? "-" + v : v));
        }
        var r = [], max = v.length, l = LOG_BASE, min = max - l;
        while (max > 0) {
            r.push(+v.slice(min, max));
            min -= l;
            if (min < 0) min = 0;
            max -= l;
        }
        trim(r);
        return new BigInteger(r, sign);
    }

    function parseNumberValue(v) {
        if (supportsNativeBigInt) {
            return new NativeBigInt(BigInt(v));
        }
        if (isPrecise(v)) {
            if (v !== truncate(v)) throw new Error(v + " is not an integer.");
            return new SmallInteger(v);
        }
        return parseStringValue(v.toString());
    }

    function parseValue(v) {
        if (typeof v === "number") {
            return parseNumberValue(v);
        }
        if (typeof v === "string") {
            return parseStringValue(v);
        }
        if (typeof v === "bigint") {
            return new NativeBigInt(v);
        }
        return v;
    }
    // Pre-define numbers in range [-999,999]
    for (var i = 0; i < 1000; i++) {
        Integer[i] = parseValue(i);
        if (i > 0) Integer[-i] = parseValue(-i);
    }
    // Backwards compatibility
    Integer.one = Integer[1];
    Integer.zero = Integer[0];
    Integer.minusOne = Integer[-1];
    Integer.max = max;
    Integer.min = min;
    Integer.gcd = gcd;
    Integer.lcm = lcm;
    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };
    Integer.randBetween = randBetween;

    Integer.fromArray = function (digits, base, isNegative) {
        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);
    };

    return Integer;
})();

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  arr = arr.map(e => bigInt(e));
  main();
});

const main = () => {
  arr.forEach(e => {
    const r = e.divmod(14).remainder;
    console.log(e.greater(14) && r.greater(0) && r.lesser(7) ? "YES" : "NO");
  });
};

function wr(x) {
  console.log(x)
}

process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))

  const n = parseInt(arr[0])

  let num = arr[1].split(' ')

  for(let i = 0; i < n; i++) {
    if(num[i] <= 14) {
      wr('NO')
    }
    else{
      let mod = modulo(num[i], 14)
      if(mod >= 1 && mod <= 6) {
        wr('YES')
      }
      else {
        wr('NO')
      }
    }
  }
})

function modulo(dividend, divisor) {
  var partLength = 10;

  while (dividend.length > partLength) {
      var part = dividend.substring(0, partLength);
      dividend = (part % divisor) +  dividend.substring(partLength);
  }

  return dividend % divisor;
}

'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
  inputString += inputStdin;
});

process.stdin.on('end', _ => {
  inputString = inputString.trim().split('\n').map(string => {
    return string.trim();
  });

  main();
});

function readline() {
  return inputString[currentLine++];
}

function main() {
  const t = parseInt(readline());
  const nums = readline().split(" ").map(x => BigInt(x));
  for (var i=0; i<t; i++) {
    const top = nums[i] % 14n;
    if (nums[i]>14 && top>0 && top<7) {
      console.log("YES");
    } else {
      console.log("NO");
    }
  }
}

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  arr = arr.map(e => parseInt(e));
  main();
});

const main = () => {
  arr.forEach(e => {
    const r = e % 14;
    console.log(e > 14 && r > 0 && r < 7 ? "YES" : "NO");
  });
};

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  arr = arr.map(e => parseInt(e));
  main();
});

const main = () => {
  arr.forEach(e => {
    const nrDie = Math.floor(e / 21) + 1;
    const nrDots = nrDie * 21;
    const hidden = nrDots - e;
    const upAndBottom = 7 * nrDie;
    const diff = hidden - upAndBottom;
    console.log(diff <= -1 && diff >= -6 ? "YES" : "NO");
  });
};

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  main();
});

const main = () => {
  arr.forEach(e => {
    const nrDie = Math.floor(e / 21) + 1;
    const nrDots = nrDie * 21;
    const hidden = nrDots - e;
    const upAndBottom = 7 * (nrDie - 1);
    const diff = hidden - upAndBottom;
    console.log(diff >= 1 && diff <= 6 ? "YES" : "NO");
  });
};

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  arr = arr.map(e => parseInt(e));
  main();
});

const main = () => {
  arr.forEach(e => {
    const nrDie = Math.floor(e / 21) + 1;
    const nrDots = nrDie * 21;
    const hidden = nrDots - e;
    const upAndBottom = 7 * nrDie;
    const diff = Math.abs(hidden - upAndBottom);
    console.log(diff > 0 && diff < 7 ? "YES" : "NO");
  });
};

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  main();
});

const main = () => {
  arr.forEach(e => {
    const nrDie = Math.floor(e / 21) + 1;
    const nrDots = nrDie * 21;
    const hidden = nrDots - e;
    const upAndBottom = 7 * nrDie;
    const diff = hidden - upAndBottom;
    console.log(diff <= -1 && diff >= -6 ? "YES" : "NO");
  });
};

const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout
});

let arr = [];

readline.on("line", line => {
  arr.push(line);
});

readline.on("close", _ => {
  arr.shift();
  arr = arr[0].split(" ");
  main();
});

const main = () => {
  arr.forEach(e => {
    const nrDie = Math.floor(e / 21) + 1;
    const nrDots = nrDie * 21;
    const hidden = nrDots - e;
    const upAndBottom = 7 * (nrDie - 1);
    const diff = hidden - upAndBottom;
    console.log(diff >= 0 && diff <= 6 ? "YES" : "NO");
  });
};

function wr(x) {
  console.log(x)
}

process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))

  const n = parseInt(arr[0])

  let num = arr[1].split(' ').map(a => parseInt(a))

  for(let i = 0; i < n; i++) {
    if(num[i] <= 14) {
      wr('NO')
    }
    else{
      let mod = num[i] % 14
      if(mod >= 1 && mod <= 6) {
        wr('YES')
      }
      else {
        wr('NO')
      }
    }
  }
})

'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
  inputString += inputStdin;
});

process.stdin.on('end', _ => {
  inputString = inputString.trim().split('\n').map(string => {
    return string.trim();
  });

  main();
});

function readline() {
  return inputString[currentLine++];
}

function print(s) {
  console.log(s);
}

function main() {
  const t = parseInt(readline());
  const nums = readline().split(" ").map(x => parseInt(x));
  for (var i=0; i<t; i++) {
    const top = nums[i] % 14;
    if (top > 0 && top < 7) {
      print("YES"+top);
    } else {
      print("NO"+top);
    }
  }
}

'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
  inputString += inputStdin;
});

process.stdin.on('end', _ => {
  inputString = inputString.trim().split('\n').map(string => {
    return string.trim();
  });

  main();
});

function readline() {
  return inputString[currentLine++];
}

function main() {
  const t = parseInt(readline());
  const nums = readline().split(" ").map(x => parseInt(x));
  for (var i=0; i<t; i++) {
    const top = nums[i] % 14;
    if (nums[i]>14 && top>0 && top<7) {
      console.log("YES");
    } else {
      console.log("NO");
    }
  }
}

'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
  inputString += inputStdin;
});

process.stdin.on('end', _ => {
  inputString = inputString.trim().split('\n').map(string => {
    return string.trim();
  });

  main();
});

function readline() {
  return inputString[currentLine++];
}

function print(s) {
  console.log(s);
}

function main() {
  const t = parseInt(readline());
  const nums = readline().split(" ").map(x => parseInt(x));
  for (var i=0; i<t; i++) {
    const top = nums[i] % 14;
    if (top > 0 && top < 7) {
      print("YES");
    } else {
      print("NO");
    }
  }
}


A string is called diverse if it contains consecutive (adjacent) letters of the Latin alphabet and each letter occurs exactly once. For example, the following strings are diverse: "fced", "xyz", "r" and "dabcef". The following string are not diverse: "az", "aa", "bad" and "babc". Note that the letters 'a' and 'z' are not adjacent.Formally, consider positions of all letters in the string in the alphabet. These positions should form contiguous segment, i.e. they should come one by one without any gaps. And all letters in the string should be distinct (duplicates are not allowed).You are given a sequence of strings. For each string, if it is diverse, print "Yes". Otherwise, print "No".

The first line contains integer $$$n$$$ ($$$1 \le n \le 100$$$), denoting the number of strings to process. The following $$$n$$$ lines contains strings, one string per line. Each string contains only lowercase Latin letters, its length is between $$$1$$$ and $$$100$$$, inclusive.

Print $$$n$$$ lines, one line per a string in the input. The line should contain "Yes" if the corresponding string is diverse and "No" if the corresponding string is not diverse. You can print each letter in any case (upper or lower). For example, "YeS", "no" and "yES" are all acceptable.

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', function() {
    inputString = inputString.trim()
        .split('\n')
        .map(str => str.trim())
    main();
});

function readLine() {
    return inputString[currentLine++];
}

function checkString(str){
	let n = str.length
	let prev = str.charCodeAt(0)
	for(let i=1; i<n; i++){
		if(str.charCodeAt(i) !== ++prev)
		return 'No'
	}
	return 'Yes'
}

function main() {
    let t = parseInt(readLine(), 10);
    while(t > 0){
    	let string = readLine().trim()
    	string = string.split('').sort().join('')
	    process.stdout.write(checkString(string) + '\n')
	    //console.log(string)
    	t--
    }

    process.exit();
}

const readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

function readLines(number, cb) {
    const lines = [];
    rl.on('line', function(line) {
        lines.push(line);
        if (lines.length === number) {
            rl.close();
            cb(lines);
        }
    });
};

function readLines(cb) {
    const lines = [];
    let read;

    rl.on('line', function(line) {
        if (!read) {
            read = parseInt(line);
        } else {
            lines.push(line);
        }
        if (lines.length === read) {
            rl.close();
            cb(lines);
        }
    });
};
readLines(doIt);

function doIt(lines) {
    lines.forEach(line => {
        isDiverse(line);
    });

    function isDiverse(line) {
        if (line.length ==1) {
            console.log('Yes');
            return;
        }
        let chars = line.split('').sort().join('');
        let hasConsective = true;
        let repeat = false;
        for (let i=1; i<chars.length && !repeat; i++) {
            if (chars.charCodeAt(i-1) ===chars.charCodeAt(i))
                repeat = true;
            if (chars.charCodeAt(i)-chars.charCodeAt(i-1) !== 1)
                hasConsective = false;
        }
        if (!repeat && hasConsective)
            console.log('Yes');
        else
            console.log("No");
    }
}

//Don't have to see. start------------------------------------------
var read = require('readline').createInterface({
	input: process.stdin, output: process.stdout
});
var obj; var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
	obj = init(inLine);
	console.error('\n↑入力 ↓出力');
	Main();
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : JSON.parse(JSON.stringify(obj));}
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){
	return {
		list : input, index : 0, max : input.length,
		hasNext : function(){return (this.index < this.max);},
		next : function(){if(this.hasNext()){return this.list[this.index++];}else{throw 'ArrayIndexOutOfBoundsException ‚There is no more input';}}
	};
}
function myout(s){console.log(s);}
function myerr(s){console.error('debug:' + require('util').inspect(s,false,null));}
//param "no" is
//unknown or outlier : return i. 1: parseInt.
//2: split space. 4: split space and parseInt.
//6: split 1 character. 7: split 1 character and parseInt.
//8: join space. 9: join nextline. 0: join no character.
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(' ');case 4:return i.split(' ').map(Number);case 6:return i.split('');case 7:return i.split('').map(Number);case 8:return i.join(' ');case 9:return i.join('\n');case 0:return i.join('');default:return i;}}catch(e){return i;}}

//Don't have to see. end------------------------------------------
function Main(){
	var t = nextInt();
	var output = new Array(t);
	var list = "abcdefghijklmnopqrstuvwxyz";
	for(var i = 0; i < t; i++){
		var s = nextCharArray();
		s.sort();
		var used = new Array(26).fill(0);
		var isOK = true;
		for(var j = 0; j < s.length; j++){
			if(used[list.indexOf(s[j])] == 1){
				isOK = false;
				break;
			}else{
				used[list.indexOf(s[j])] = 1;
			}
		}
		var first = false;
		var second = false;
		for(var j = 0; j < list.length; j++){
			if(!first && used[j] == 1){
				first = true;
				continue;
			}
			if(first && used[j] == 0){
				second = true;
				continue;
			}
			if(second && used[j] == 1){
				isOK = false;
			}
		}
		output[i] = (isOK) ? "Yes" : "No";
	}
	myout(myconv(output, 9));
}

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
let c = 0;

rl.on('line', (str) => {
  if (c === 0) {
    c++;
    return;
  }

  if (new Set(str).size !== str.length) {
    console.log('NO');
    return;
  }

  let ans = 'NO';
  const arr = [...str].sort();
  const first = arr[0].charCodeAt(0) + arr.length - 1;
  const last  = arr[arr.length - 1].charCodeAt(0)

  if (first === last) {
    ans = 'YES';
  }

  console.log(ans);
  c++;
});

const readline = require('readline');
const rl = readline.createInterface({input: process.stdin});
let stdin = [];
rl.on('line', function (line) {stdin.push(line);});
rl.on('close', main);

// let stdin = [
//   "44",
//   "ops",
//   "test",
//   "yes",
//   "no",
//   "ac",
//   "bc",
//   "cb",
//   "z",
//   "a",
//   "q",
//   "r",
//   "u",
//   "qq",
//   "op",
//   "po",
//   "xu",
//   "ux",
//   "xy",
//   "yx",
//   "a",
//   "ab",
//   "abc",
//   "abcd",
//   "abcde",
//   "abcdef",
//   "abcdefg",
//   "bcdefg",
//   "cdefg",
//   "defg",
//   "efgd",
//   "efef",
//   "abacaba",
//   "abz",
//   "aoi",
//   "ioi",
//   "codeforces",
//   "klmn",
//   "nmlk",
//   "kln",
//   "klmnl",
//   "kmn",
//   "kklmn",
//   "klmnn",
//   "aklkmn",
// ]
// main();

function main() {
  // 97 122
  let n = stdin[0];
  for (let i = 1; i <= Number(n); i++) {
    let s = stdin[i].split('').sort();
    let flag = true;

    let left = s[0].charCodeAt();
    for (let j = 1; j < s.length; j++) {
      if (s[j].charCodeAt() - left !== 1) {
        console.log('NO');
        flag = false;
        break;
      }
      left = s[j].charCodeAt();
    }
    if (flag) {
      console.log('YES')
    }
  }
}

const readline = require('readline')

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
})

rl.question('', ans => {
  const n = Number(ans)
  let counter = 1
  const arr = []

  rl.on('line', l => {
    counter++

    arr.push(l)

    if (counter > n) {
      rl.close()
      arr.forEach(item => {
        console.log(diverse(item))
      })
    }
  })
})

const diverse = (str) => {
  const arr = str.split('').map(i => i.charCodeAt(0)).sort((a,b) => a - b)
  // console.log(str, arr)
  for (let i = 1; i < arr.length; i++) {
    if ((arr[i] - arr[i-1]) !== 1)
      return "No"
  }

  return "Yes"
}

function run() {
    const readline = require('readline');

    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    let total;
    let current = 0
    let strings = [];

    rl.on('line', input => {
        if (!total) {
            total = input
        } else if (current < total) {
            current++;
            strings.push(input);
            if (current == total) {
                rl.close();
                strings.forEach(string => {
                    const result = stringIsVaried(string);
                    console.log(result);
                })
                process.exit();
            }
        }
    });
}

function stringIsVaried(string) {
    if (string.length == 1) return "Yes";

    let current = 0;
    let charCodes = [];
    let minCode = 123;
    let maxCode = 96;

    while (current < string.length) {
        let charCode = string[current].charCodeAt();
        if (charCodes[charCode]) {
            return "No"
        } else {
            charCodes[charCode] = true;
            if (minCode > charCode) {
                minCode = charCode
            }
            if (maxCode < charCode) {
                maxCode = charCode
            }
        }

        current++;
    }

    if ( (maxCode - minCode).length > string.length ) return "No"
    let prevCode;
    let isNotVaried = charCodes.some((_, code) => {
        if (prevCode && (prevCode + 1 != code)) {
            return true
        } else {
            prevCode = code
        }
    })

    return isNotVaried ? "No" : "Yes"
}

run();

module.exports.stringIsVaried = stringIsVaried;

var stdin = "";
process.stdin.resume();
process.stdin.setEncoding('ascii');
process.stdin.on('data', function (data) { stdin += data; });
process.stdin.on('end', function () { main(stdin); });

var stdin_row = 0, stdin_rows;
function readLine() { if (!stdin_rows) stdin_rows = stdin.split("\n"); return stdin_rows[stdin_row++]; }
function readLineVals() { return readLine().split(/\s+/); }

const debug = 0
var log = console.log;
var dbg = debug ? console.log : _ => {};

/////////////// ignore above this line ////////////////////

function main(stdin) {
	var nbq = readLine() * 1;
	dbg("nbq", nbq)

	for (var iq=0; iq<nbq; iq++) {
		var txt = readLine().trim();
		txt = Array.from(txt).map(x => x.charCodeAt(0)).sort((a, b) => a-b )
		var tst = true;
		for (var i =1; i<txt.length; i++)
			if (txt[i]-txt[i-1]!=1) {
				tst = false;
				break;
				}
		if (tst)
			log("Yes")
		else
			log("No")

		dbg("->", JSON.stringify(txt))

	}
}

var j=readline();
for(var k=0; k<j; k++){
	var str=readline();
	var codes=str.split('').map(i=>i.charCodeAt(0)).sort((a,b)=>a-b);
	var diffs=codes.map((i,k,a) => i- a[k+1]).slice(0,-1);
	print( diffs.every(i=>i==-1)?'Yes':'No');
}

var solve = function(inp){

     var str = inp.split("").sort();

    for(var i = 0 ; i < str.length-1 ; i++) {
        if (str[i].charCodeAt(0) + 1 != str[i+1].charCodeAt(0))
            return false;
    }
    return true;

};

var sol = function (){
    var input,cases = readline(),result;
    for ( var i  = 0 ; i < cases ; i++){
       input = readline();
       result = solve(input);
       if(result)
        print("Yes");
       else print("No");
    }
}
sol();

const readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

function readLines(number, cb) {
    const lines = [];
    rl.on('line', function(line) {
        lines.push(line);
        if (lines.length === number) {
            rl.close();
            cb(lines);
        }
    });
};

function readLines(cb) {
    const lines = [];
    let read;

    rl.on('line', function(line) {
        if (!read) {
            read = parseInt(line);
        } else {
            lines.push(line);
        }
        if (lines.length === read) {
            rl.close();
            cb(lines);
        }
    });
};
readLines(doIt);

function doIt(lines) {
    lines.forEach(line => {
        isDiverse(line);
    });

    function isDiverse(line) {
        if (line.length ==1) {
            console.log('Yes');
            return;
        }
        let chars = line.split('').sort().join('');
        let hasConsective = false;
        let repeat = false;
        let prev = chars.charCodeAt(0);
        for (let i=1; i<chars.length && !repeat; i++) {
            if (prev ===chars.charCodeAt(i))
                repeat = true;
            if (!hasConsective && chars.charCodeAt(i)-prev == 1)
                hasConsective = true;
            prev = chars.charCodeAt(i);
        }
        if (!repeat && hasConsective)
            console.log('Yes');
        else
            console.log("No");
    }
}

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
let c = 0;

rl.on('line', (str) => {
  if (c === 0) {
    c++;
    return;
  }

  if (new Set(str).size !== str.length) {
    console.log('NO');
    return;
  }

  if (str.length === 1) {
    console.log('YES');
    return;
  }

  let ans = 'NO';

  for (let i = 1; i < str.length - 1; i++) {
    if (str.charCodeAt(i - 1) + 1 === str.charCodeAt(i) || str.charCodeAt(i + 1) + 1 === str.charCodeAt(i)) {
      ans = 'YES';
    }
  }

  console.log(ans);
  c++;
});

const readline = require('readline');
const rl = readline.createInterface({input: process.stdin});
let stdin = [];
rl.on('line', function (line) {stdin.push(line);});
rl.on('close', main);

// let stdin = [
//   "8",
//   "fced",
//   "xyz",
//   "r",
//   "dabcef",
//   "az",
//   "aa",
//   "bad",
//   "babc",
// ]
// main();

function main() {
  let [n] = stdin[0];
  for (let i = 1; i <= n; i++) {
    let s = stdin[i].split('').sort();
    let left = s[0].charCodeAt();
    let flag = true;
    for (let j = 1; j < s.length; j++) {
      if (s[j].charCodeAt() - left !== 1) {
        console.log('NO');
        flag = false;
        break;
      }
      left = s[j].charCodeAt();
    }
    if (flag) {
      console.log('YES')
    }
  }
}

const readline = require('readline');
const rl = readline.createInterface({input: process.stdin});
let stdin = [];
rl.on('line', function (line) {stdin.push(line);});
rl.on('close', main);

// let stdin = [
//   "8",
//   "Fced",
//   "xyz",
//   "r",
//   "dabcef",
//   "az",
//   "aa",
//   "bad",
//   "babc",
// ]
// main();

function main() {
  // 97 122
  let [n] = stdin[0];
  for (let i = 1; i <= n; i++) {
    let s = stdin[i].toLowerCase().split('').sort();
    let flag = true;

    for (const val of s) {
      if (val.charCodeAt() < 97 || val.charCodeAt() > 122) {
        console.log('NO');
        flag = false;
        break;
      }
    }

    if (!flag) continue;
    let left = s[0].charCodeAt();

    for (let j = 1; j < s.length; j++) {
      if (s[j].charCodeAt() - left !== 1) {
        console.log('NO');
        flag = false;
        break;
      }
      left = s[j].charCodeAt();
    }
    if (flag) {
      console.log('YES')
    }
  }
}

const readline = require('readline');
const rl = readline.createInterface({input: process.stdin});
let stdin = [];
rl.on('line', function (line) {stdin.push(line);});
rl.on('close', main);

// let stdin = [
//   "8",
//   "fced",
//   "xyz",
//   "r",
//   "dabcef",
//   "az",
//   "aa",
//   "bad",
//   "babc",
// ]
// main();

function main() {
  // 97 122
  let [n] = stdin[0];
  for (let i = 1; i <= n; i++) {
    let s = stdin[i].split('').sort();
    let left = s[0].charCodeAt();
    let flag = true;

    for (const val of s) {
      if (val.toLowerCase().charCodeAt() < 97 || val.toLowerCase().charCodeAt() > 122) {
        console.log('NO');
        flag = false;
        break;
      }
    }

    if (!flag) continue;

    for (let j = 1; j < s.length; j++) {
      if (s[j].charCodeAt() - left !== 1) {
        console.log('NO');
        flag = false;
        break;
      }
      left = s[j].charCodeAt();
    }
    if (flag) {
      console.log('YES')
    }
  }
}


Dark is going to attend Motarack's birthday. Dark decided that the gift he is going to give to Motarack is an array $$$a$$$ of $$$n$$$ non-negative integers.Dark created that array $$$1000$$$ years ago, so some elements in that array disappeared. Dark knows that Motarack hates to see an array that has two adjacent elements with a high absolute difference between them. He doesn't have much time so he wants to choose an integer $$$k$$$ ($$$0 \leq k \leq 10^{9}$$$) and replaces all missing elements in the array $$$a$$$ with $$$k$$$.Let $$$m$$$ be the maximum absolute difference between all adjacent elements (i.e. the maximum value of $$$|a_i - a_{i+1}|$$$ for all $$$1 \leq i \leq n - 1$$$) in the array $$$a$$$ after Dark replaces all missing elements with $$$k$$$.Dark should choose an integer $$$k$$$ so that $$$m$$$ is minimized. Can you help him?

The input consists of multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$)  — the number of test cases. The description of the test cases follows. The first line of each test case contains one integer $$$n$$$ ($$$2 \leq n \leq 10^{5}$$$) — the size of the array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$-1 \leq a_i \leq 10 ^ {9}$$$). If $$$a_i = -1$$$, then the $$$i$$$-th integer is missing. It is guaranteed that at least one integer is missing in every test case. It is guaranteed, that the sum of $$$n$$$ for all test cases does not exceed $$$4 \cdot 10 ^ {5}$$$.

Print the answers for each test case in the following format: You should print two integers, the minimum possible value of $$$m$$$ and an integer $$$k$$$ ($$$0 \leq k \leq 10^{9}$$$) that makes the maximum absolute difference between adjacent elements in the array $$$a$$$ equal to $$$m$$$. Make sure that after replacing all the missing elements with $$$k$$$, the maximum absolute difference between adjacent elements becomes $$$m$$$. If there is more than one possible $$$k$$$, you can print any of them.

NoteIn the first test case after replacing all missing elements with $$$11$$$ the array becomes $$$[11, 10, 11, 12, 11]$$$. The absolute difference between any adjacent elements is $$$1$$$. It is impossible to choose a value of $$$k$$$, such that the absolute difference between any adjacent element will be $$$\leq 0$$$. So, the answer is $$$1$$$.In the third test case after replacing all missing elements with $$$6$$$ the array becomes $$$[6, 6, 9, 6, 3, 6]$$$.  $$$|a_1 - a_2| = |6 - 6| = 0$$$;  $$$|a_2 - a_3| = |6 - 9| = 3$$$;  $$$|a_3 - a_4| = |9 - 6| = 3$$$;  $$$|a_4 - a_5| = |6 - 3| = 3$$$;  $$$|a_5 - a_6| = |3 - 6| = 3$$$. So, the maximum difference between any adjacent elements is $$$3$$$.

process.stdin.resume()
process.stdin.setEncoding('utf-8')

let input = ''
let ptr = 0
process.stdin.on('data', (i) => {
  input += i
})

process.stdin.on('end', () => {
  input = input.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main()
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if (inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt() {
  return parseInt(input[ptr++])
}

function readString() {
  return input[ptr++]
}

function readStrings() {
  return input[ptr++].split(' ')
}

function readInts() {
  return input[ptr++].split(' ').map(a => parseInt(a))
}

function main() {
  let t = readInt()
  while (t--) {
    const n = readInt()
    const a = readInts()
    let min = Infinity
    let max = -Infinity
    for (let i = 0; i < n; i++) {
      if (a[i] === -1) {
        if (i > 0 && a[i - 1] !== -1) {
          // wr(min, a[i - 1])
          min = Math.min(min, a[i - 1])
          max = Math.max(max, a[i - 1])
        }
        if (i < n - 1 && a[i + 1] !== -1) {
          min = Math.min(min, a[i + 1])
          max = Math.max(max, a[i + 1])
        }
      }
    }
    // wr('imi', min, max)
    if (min === Infinity) {
      // wr(a)
      wr(0, 0)
      continue
    }
    // wr(min, max)
    let k = Math.round((min + max) / 2)
    let m = -1
    for (let i = 0; i < n; i++) if (a[i] === -1) a[i] = k
    for (let i = 1; i < n; i++) {
      m = Math.max(m, Math.abs(a[i - 1] - a[i]))
    }
    wr(m, k)
  }
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const exist = arr.filter((value, index, array) => value !== -1 && (array[index + 1] === -1 || array[index - 1] === -1));
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        const m = Math.ceil((max - min)/2);
        const k = max - m;
        const filledArr = arr.map(v => v === -1 ? k : v);
        const maxSibl = filledArr.reduce((acc, value, index, array) => {
            if (index === array.length - 1) return acc;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);

        return `${Math.max(maxSibl, m)} ${k}`;
    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

const processData = (lines) => {
  const num = +lines[0]

  for (let j=0; j<num; j++){
    const nums = lines[j*2+2].split(' ').map(x => +x)

    const neighbourghoods = new Set()
    for (let j = 0; j<nums.length; j++) {
      if (nums[j] === -1) {
        if (j > 0 && nums[j - 1] !== -1) {
          neighbourghoods.add(nums[j - 1])
        }
        if (j < nums.length - 1 && nums[j + 1] !== -1) {
          neighbourghoods.add(nums[j + 1])
        }
      }
    }

    const arr = Array.from(neighbourghoods)
    if (arr.length > 0) {
      const max = Math.max.apply(Math, arr)
      const min = Math.min.apply(Math, arr)
      const answer = Math.round((max + min)/ 2)
      const resNums = nums.map(x => x === -1 ? answer : x)

      let maxDiff = 0

      for (let i=1; i<resNums.length; i++) {
        const diff = Math.abs(resNums[i] - resNums[i-1])
        if (diff > maxDiff) {
          maxDiff = diff
        }
      }
      console.log(`${maxDiff} ${answer}`)
    } else {
      console.log('0 0')
    }
  }
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
  const {EOL} = require('os')
  const lines = i.split(EOL) /*your input text, split by lines*/
  processData(lines)
})

process.stdin.resume()
process.stdin.setEncoding('utf-8')

let input = ''
let ptr = 0
process.stdin.on('data', (i) => {
  input += i
})

process.stdin.on('end', () => {
  input = input.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main()
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt() {
  return parseInt(input[ptr++])
}

function readString() {
  return input[ptr++]
}

function readStrings() {
  return input[ptr++].split(' ')
}

function readInts() {
  return input[ptr++].split(' ').map(a => parseInt(a))
}

function main() {
  let t = readInt()
  while(t--) {
    const n = readInt()
    const a = readInts()
    let sum = 0
    let c = 0
    if(a[1] === -1 && a[0] !== -1){
      sum += a[0]
      c++
    }
    for(let i = 1; i < n; i++) {
      if(a[i - 1] === -1 && a[i] !== -1) {
        sum += a[i]
        c++
      }
    }
    if(sum === 0) {
      // wr(a)
      wr(0, 0)
      continue
    }
    // wr('sum', sum, 'c', c)
    let k = Math.round(sum / c)
    let m = -1
    for(let i = 0; i < n; i++) if(a[i] === -1) a[i] = k
    for(let i = 1; i < n; i++) {
      m = Math.max(m, Math.abs(a[i - 1] - a[i]))
    }
    wr(m, k)
  }
}

process.stdin.resume()
process.stdin.setEncoding('utf-8')

let input = ''
let ptr = 0
process.stdin.on('data', (i) => {
  input += i
})

process.stdin.on('end', () => {
  input = input.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main()
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt() {
  return parseInt(input[ptr++])
}

function readString() {
  return input[ptr++]
}

function readStrings() {
  return input[ptr++].split(' ')
}

function readInts() {
  return input[ptr++].split(' ').map(a => parseInt(a))
}

function main() {
  let t = readInt()
  while(t--) {
    const n = readInt()
    const a = readInts()
    let sum = 0
    let c = 0
    let map = {}
    for(let i = 0; i < n; i++) {
      if(a[i] === -1) {
        if(i > 0 && !map[i - 1]) {
          map[i - 1] = true
          sum += a[i - 1]
          c++
        }
        if(i < n - 1 && !map[i + 1]) {
          map[i + 1] = true
          sum += a[i + 1]
          c++
        }
      }
    }
    if(sum === 0) {
      // wr(a)
      wr(0, 0)
      continue
    }
    // wr('sum', sum, 'c', c)
    let k = Math.round(sum / c)
    let m = -1
    for(let i = 0; i < n; i++) if(a[i] === -1) a[i] = k
    for(let i = 1; i < n; i++) {
      m = Math.max(m, Math.abs(a[i - 1] - a[i]))
    }
    wr(m, k)
  }
}

process.stdin.resume()
process.stdin.setEncoding('utf-8')

let input = ''
let ptr = 0
process.stdin.on('data', (i) => {
  input += i
})

process.stdin.on('end', () => {
  input = input.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main()
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt() {
  return parseInt(input[ptr++])
}

function readString() {
  return input[ptr++]
}

function readStrings() {
  return input[ptr++].split(' ')
}

function readInts() {
  return input[ptr++].split(' ').map(a => parseInt(a))
}

function main() {
  let t = readInt()
  while(t--) {
    const n = readInt()
    const a = readInts()
    let sum = 0
    let c = 0
    let map = {}
    for(let i = 0; i < n; i++) {
      if(a[i] === -1) {
        if(i > 0 && !map[i - 1] && a[i - 1] !== -1) {
          map[i - 1] = true
          sum += a[i - 1]
          c++
        }
        if(i < n - 1 && !map[i + 1] && a[i + 1] !== -1) {
          map[i + 1] = true
          sum += a[i + 1]
          c++
        }
      }
    }
    if(sum === 0) {
      // wr(a)
      wr(0, 0)
      continue
    }
    // wr('sum', sum, 'c', c)
    let k = Math.round(sum / c)
    let m = -1
    for(let i = 0; i < n; i++) if(a[i] === -1) a[i] = k
    for(let i = 1; i < n; i++) {
      m = Math.max(m, Math.abs(a[i - 1] - a[i]))
    }
    wr(m, k)
  }
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const maxSibl = arr.reduce((acc, value, index, array) => {
            if (value === -1 || array[index+1] === -1 || array[index+1] === undefined) return acc;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);
        const exist = arr.filter(value => value !== -1);
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        let m = Math.ceil((max - min)/2);
        const k = min + m;

        if (maxSibl > m) {
            return `${maxSibl} ${min}`
        }

        return `${m} ${k}`;
    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const maxSibl = arr.reduce((acc, value, index, array) => {
            if (value === -1 || array[index+1] === -1 || array[index+1] === undefined) return acc;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);
        const exist = arr.filter(value => value !== -1);
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        let m = Math.ceil((max - min)/2);
        const k = min + m;

        if (maxSibl >= m) {
            return `${maxSibl} ${min}`
        }

        return `${m} ${k}`;

    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const exist = arr.filter(value => value !== -1);
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        let m = Math.ceil((max - min)/2);
        const k = max - m;
        const maxSibl = arr.reduce((acc, value, index, array) => {
            if (array[index+1] === -1 || array[index+1] === undefined) return acc;
            if (value === -1) value = k;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);

        return `${Math.max(maxSibl, m)} ${k}`;
    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const maxSibl = arr.reduce((acc, value, index, array) => {
            if (value === -1 || array[index+1] === -1 || array[index+1] === undefined) return acc;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);
        const exist = arr.filter(value => value !== -1);
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        let m = Math.ceil((max - min)/2);
        const k = max - m;

        if (maxSibl > m) {
            return `${maxSibl} ${min}`
        }

        return `${m} ${k}`;
    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL);

    function foo (arr) {
        const exist = arr.filter(value => value !== -1);
        if (!exist.length) return '0 0';
        const min = Math.min(...exist);
        const max = Math.max(...exist);
        const m = Math.ceil((max - min)/2);
        const k = max - m;
        const filledArr = arr.map(v => v === -1 ? k : v);
        const maxSibl = filledArr.reduce((acc, value, index, array) => {
            if (index === array.length - 1) return acc;
            return Math.max(acc, Math.abs(value - array[index+1]));
        }, 0);

        return `${Math.max(maxSibl, m)} ${k}`;
    }

    let testCount = 1;
    let answer = '';
    while(testCount <= +lines[0]) {
        let b = lines[testCount * 2].split(' ').map(Number);

        let result = foo(b);
        answer += result +"\n";
        testCount++;
    }
    console.log(answer);
})

const processData = (lines) => {
  const num = +lines[0]

  for (let j=0; j<num; j++){
    const nums = lines[j*2+2].split(' ').map(x => +x)

    const neighbourghoods = new Set()
    for (let j = 0; j<nums.length; j++) {
      if (nums[j] === -1) {
        if (j > 0 && nums[j - 1] !== -1) {
          neighbourghoods.add(nums[j - 1])
        }
        if (j < nums.length - 1 && nums[j + 1] !== -1) {
          neighbourghoods.add(nums[j + 1])
        }
      }
    }

    const arr = new Array(...neighbourghoods)
    if (arr.length) {
      const sum = arr.reduce((r, x) => r + x, 0)
      const answer = Math.round(sum / arr.length)
      const resNums = nums.map(x => x === -1 ? answer : x)

      let maxDiff = 0

      for (let i=1; i<resNums.length; i++) {
        const diff = Math.abs(resNums[i] - resNums[i-1])
        if (diff > maxDiff) {
          maxDiff = diff
        }
      }
      console.log(`${maxDiff} ${answer}`)
    } else {
      console.log('0 0')
    }
  }
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
  const {EOL} = require('os')
  const lines = i.split(EOL) /*your input text, split by lines*/
  processData(lines)
})

const processData = (lines) => {
  const num = +lines[0]

  for (let j=0; j<num; j++){
    const nums = lines[j*2+2].split(' ').map(x => +x)

    const neighbourghoods = new Set()
    for (let j = 0; j<nums.length; j++) {
      if (nums[j] === -1) {
        if (j > 0 && nums[j - 1] !== -1) {
          neighbourghoods.add(nums[j - 1])
        }
        if (j < nums.length - 1 && nums[j + 1] !== -1) {
          neighbourghoods.add(nums[j + 1])
        }
      }
    }

    const arr = new Array(...neighbourghoods)
    if (arr.length) {
      const max = Math.max.apply(Math, arr)
      const min = Math.min.apply(Math, arr)
      const answer = Math.round((max + min)/ 2)
      const resNums = nums.map(x => x === -1 ? answer : x)

      let maxDiff = 0

      for (let i=1; i<resNums.length; i++) {
        const diff = Math.abs(resNums[i] - resNums[i-1])
        if (diff > maxDiff) {
          maxDiff = diff
        }
      }
      console.log(`${maxDiff} ${answer}`)
    } else {
      console.log('0 0')
    }
  }
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
  const {EOL} = require('os')
  const lines = i.split(EOL) /*your input text, split by lines*/
  processData(lines)
})