Let's call an array a consisting of n positive (greater than 0) integers beautiful if the following condition is held for every i from 1 to n: either a_i = 1, or at least one of the numbers a_i - 1 and a_i - 2 exists in the array as well.

For example: 

  * the array [5, 3, 1] is beautiful: for a_1, the number a_1 - 2 = 3 exists in the array; for a_2, the number a_2 - 2 = 1 exists in the array; for a_3, the condition a_3 = 1 holds; 
  * the array [1, 2, 2, 2, 2] is beautiful: for a_1, the condition a_1 = 1 holds; for every other number a_i, the number a_i - 1 = 1 exists in the array; 
  * the array [1, 4] is not beautiful: for a_2, neither a_2 - 2 = 2 nor a_2 - 1 = 3 exists in the array, and a_2 ≠ 1; 
  * the array [2] is not beautiful: for a_1, neither a_1 - 1 = 1 nor a_1 - 2 = 0 exists in the array, and a_1 ≠ 1; 
  * the array [2, 1, 3] is beautiful: for a_1, the number a_1 - 1 = 1 exists in the array; for a_2, the condition a_2 = 1 holds; for a_3, the number a_3 - 2 = 1 exists in the array. 



You are given a positive integer s. Find the minimum possible size of a beautiful array with the sum of elements equal to s.

Input

The first line contains one integer t (1 ≤ t ≤ 5000) — the number of test cases.

Then t lines follow, the i-th line contains one integer s (1 ≤ s ≤ 5000) for the i-th test case.

Output

Print t integers, the i-th integer should be the answer for the i-th testcase: the minimum possible size of a beautiful array with the sum of elements equal to s.

Example

Input


4
1
8
7
42


Output


1
3
3
7

Note

Consider the example test:

  1. in the first test case, the array [1] meets all conditions; 
  2. in the second test case, the array [3, 4, 1] meets all conditions; 
  3. in the third test case, the array [1, 2, 4] meets all conditions; 
  4. in the fourth test case, the array [1, 4, 6, 8, 10, 2, 11] meets all conditions. 
//package codeforces;
import java.io.*;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Queue;

public class Solution1550A {
    InputStream is;
    FastWriter out;
    String INPUT = "";

    void solve() {
        for (int T = ni(); T > 0; T--) {
            go();
        }
    }

    void go() {
        int S = ni();
        int s = 0;
        for (int i = 1; ; i++) {
            s += i * 2 - 1;
            if (s >= S) {
                out.println(i);
                return;
            }
        }
    }

    void run() throws Exception {
        is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
        out = new FastWriter(System.out);

        long s = System.currentTimeMillis();
        solve();
        out.flush();
        tr(System.currentTimeMillis()-s+"ms");
    }

    public static void main(String[] args) throws Exception { new Solution1550A().run(); }

    private byte[] inbuf = new byte[1024];
    public int lenbuf = 0, ptrbuf = 0;

    private int readByte()
    {
        if(lenbuf == -1)throw new InputMismatchException();
        if(ptrbuf >= lenbuf){
            ptrbuf = 0;
            try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
            if(lenbuf <= 0)return -1;
        }
        return inbuf[ptrbuf++];
    }

    private boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
    private int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

    private double nd() { return Double.parseDouble(ns()); }
    private char nc() { return (char)skip(); }

    private String ns()
    {
        int b = skip();
        StringBuilder sb = new StringBuilder();
        while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    private char[] ns(int n)
    {
        char[] buf = new char[n];
        int b = skip(), p = 0;
        while(p < n && !(isSpaceChar(b))){
            buf[p++] = (char)b;
            b = readByte();
        }
        return n == p ? buf : Arrays.copyOf(buf, p);
    }

    private int[] na(int n)
    {
        int[] a = new int[n];
        for(int i = 0;i < n;i++)a[i] = ni();
        return a;
    }

    private long[] nal(int n)
    {
        long[] a = new long[n];
        for(int i = 0;i < n;i++)a[i] = nl();
        return a;
    }

    private char[][] nm(int n, int m) {
        char[][] map = new char[n][];
        for(int i = 0;i < n;i++)map[i] = ns(m);
        return map;
    }

    private int[][] nmi(int n, int m) {
        int[][] map = new int[n][];
        for(int i = 0;i < n;i++)map[i] = na(m);
        return map;
    }

    private int ni() { return (int)nl(); }

    private long nl()
    {
        long num = 0;
        int b;
        boolean minus = false;
        while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if(b == '-'){
            minus = true;
            b = readByte();
        }

        while(true){
            if(b >= '0' && b <= '9'){
                num = num * 10 + (b - '0');
            }else{
                return minus ? -num : num;
            }
            b = readByte();
        }
    }

    public static class FastWriter
    {
        private static final int BUF_SIZE = 1<<13;
        private final byte[] buf = new byte[BUF_SIZE];
        private final OutputStream out;
        private int ptr = 0;

        private FastWriter(){out = null;}

        public FastWriter(OutputStream os)
        {
            this.out = os;
        }

        public FastWriter(String path)
        {
            try {
                this.out = new FileOutputStream(path);
            } catch (FileNotFoundException e) {
                throw new RuntimeException("FastWriter");
            }
        }

        public FastWriter write(byte b)
        {
            buf[ptr++] = b;
            if(ptr == BUF_SIZE)innerflush();
            return this;
        }

        public FastWriter write(char c)
        {
            return write((byte)c);
        }

        public FastWriter write(char[] s)
        {
            for(char c : s){
                buf[ptr++] = (byte)c;
                if(ptr == BUF_SIZE)innerflush();
            }
            return this;
        }

        public FastWriter write(String s)
        {
            s.chars().forEach(c -> {
                buf[ptr++] = (byte)c;
                if(ptr == BUF_SIZE)innerflush();
            });
            return this;
        }

        private static int countDigits(int l) {
            if (l >= 1000000000) return 10;
            if (l >= 100000000) return 9;
            if (l >= 10000000) return 8;
            if (l >= 1000000) return 7;
            if (l >= 100000) return 6;
            if (l >= 10000) return 5;
            if (l >= 1000) return 4;
            if (l >= 100) return 3;
            if (l >= 10) return 2;
            return 1;
        }

        public FastWriter write(int x)
        {
            if(x == Integer.MIN_VALUE){
                return write((long)x);
            }
            if(ptr + 12 >= BUF_SIZE)innerflush();
            if(x < 0){
                write((byte)'-');
                x = -x;
            }
            int d = countDigits(x);
            for(int i = ptr + d - 1;i >= ptr;i--){
                buf[i] = (byte)('0'+x%10);
                x /= 10;
            }
            ptr += d;
            return this;
        }

        private static int countDigits(long l) {
            if (l >= 1000000000000000000L) return 19;
            if (l >= 100000000000000000L) return 18;
            if (l >= 10000000000000000L) return 17;
            if (l >= 1000000000000000L) return 16;
            if (l >= 100000000000000L) return 15;
            if (l >= 10000000000000L) return 14;
            if (l >= 1000000000000L) return 13;
            if (l >= 100000000000L) return 12;
            if (l >= 10000000000L) return 11;
            if (l >= 1000000000L) return 10;
            if (l >= 100000000L) return 9;
            if (l >= 10000000L) return 8;
            if (l >= 1000000L) return 7;
            if (l >= 100000L) return 6;
            if (l >= 10000L) return 5;
            if (l >= 1000L) return 4;
            if (l >= 100L) return 3;
            if (l >= 10L) return 2;
            return 1;
        }

        public FastWriter write(long x)
        {
            if(x == Long.MIN_VALUE){
                return write("" + x);
            }
            if(ptr + 21 >= BUF_SIZE)innerflush();
            if(x < 0){
                write((byte)'-');
                x = -x;
            }
            int d = countDigits(x);
            for(int i = ptr + d - 1;i >= ptr;i--){
                buf[i] = (byte)('0'+x%10);
                x /= 10;
            }
            ptr += d;
            return this;
        }

        public FastWriter write(double x, int precision)
        {
            if(x < 0){
                write('-');
                x = -x;
            }
            x += Math.pow(10, -precision)/2;
            //		if(x < 0){ x = 0; }
            write((long)x).write(".");
            x -= (long)x;
            for(int i = 0;i < precision;i++){
                x *= 10;
                write((char)('0'+(int)x));
                x -= (int)x;
            }
            return this;
        }

        public FastWriter writeln(char c){
            return write(c).writeln();
        }

        public FastWriter writeln(int x){
            return write(x).writeln();
        }

        public FastWriter writeln(long x){
            return write(x).writeln();
        }

        public FastWriter writeln(double x, int precision){
            return write(x, precision).writeln();
        }

        public FastWriter write(int... xs)
        {
            boolean first = true;
            for(int x : xs) {
                if (!first) write(' ');
                first = false;
                write(x);
            }
            return this;
        }

        public FastWriter write(long... xs)
        {
            boolean first = true;
            for(long x : xs) {
                if (!first) write(' ');
                first = false;
                write(x);
            }
            return this;
        }

        public FastWriter writeln()
        {
            return write((byte)'\n');
        }

        public FastWriter writeln(int... xs)
        {
            return write(xs).writeln();
        }

        public FastWriter writeln(long... xs)
        {
            return write(xs).writeln();
        }

        public FastWriter writeln(char[] line)
        {
            return write(line).writeln();
        }

        public FastWriter writeln(char[]... map)
        {
            for(char[] line : map)write(line).writeln();
            return this;
        }

        public FastWriter writeln(String s)
        {
            return write(s).writeln();
        }

        private void innerflush()
        {
            try {
                out.write(buf, 0, ptr);
                ptr = 0;
            } catch (IOException e) {
                throw new RuntimeException("innerflush");
            }
        }

        public void flush()
        {
            innerflush();
            try {
                out.flush();
            } catch (IOException e) {
                throw new RuntimeException("flush");
            }
        }

        public FastWriter print(byte b) { return write(b); }
        public FastWriter print(char c) { return write(c); }
        public FastWriter print(char[] s) { return write(s); }
        public FastWriter print(String s) { return write(s); }
        public FastWriter print(int x) { return write(x); }
        public FastWriter print(long x) { return write(x); }
        public FastWriter print(double x, int precision) { return write(x, precision); }
        public FastWriter println(char c){ return writeln(c); }
        public FastWriter println(int x){ return writeln(x); }
        public FastWriter println(long x){ return writeln(x); }
        public FastWriter println(double x, int precision){ return writeln(x, precision); }
        public FastWriter print(int... xs) { return write(xs); }
        public FastWriter print(long... xs) { return write(xs); }
        public FastWriter println(int... xs) { return writeln(xs); }
        public FastWriter println(long... xs) { return writeln(xs); }
        public FastWriter println(char[] line) { return writeln(line); }
        public FastWriter println(char[]... map) { return writeln(map); }
        public FastWriter println(String s) { return writeln(s); }
        public FastWriter println() { return writeln(); }
    }

    public void trnz(int... o)
    {
        for(int i = 0;i < o.length;i++)if(o[i] != 0)System.out.print(i+":"+o[i]+" ");
        System.out.println();
    }

    // print ids which are 1
    public void trt(long... o)
    {
        Queue<Integer> stands = new ArrayDeque<>();
        for(int i = 0;i < o.length;i++){
            for(long x = o[i];x != 0;x &= x-1)stands.add(i<<6|Long.numberOfTrailingZeros(x));
        }
        System.out.println(stands);
    }

    public void tf(boolean... r)
    {
        for(boolean x : r)System.out.print(x?'#':'.');
        System.out.println();
    }

    public void tf(boolean[]... b)
    {
        for(boolean[] r : b) {
            for(boolean x : r)System.out.print(x?'#':'.');
            System.out.println();
        }
        System.out.println();
    }

    public void tf(long[]... b)
    {
        if(INPUT.length() != 0) {
            for (long[] r : b) {
                for (long x : r) {
                    for (int i = 0; i < 64; i++) {
                        System.out.print(x << ~i < 0 ? '#' : '.');
                    }
                }
                System.out.println();
            }
            System.out.println();
        }
    }

    public void tf(long... b)
    {
        if(INPUT.length() != 0) {
            for (long x : b) {
                for (int i = 0; i < 64; i++) {
                    System.out.print(x << ~i < 0 ? '#' : '.');
                }
            }
            System.out.println();
        }
    }

    private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
    private void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}
