'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");
    }
  }
}

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

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");
    }
  }
}


//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 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();

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");
    }
}

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');
}

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')
    }
  }
}


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

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)
})