Let's define S(x) to be the sum of digits of number x written in decimal system. For example, S(5) = 5, S(10) = 1, S(322) = 7.

We will call an integer x interesting if S(x + 1) < S(x). In each test you will be given one integer n. Your task is to calculate the number of integers x such that 1 ≤ x ≤ n and x is interesting.

Input

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

Then t lines follow, the i-th line contains one integer n (1 ≤ n ≤ 10^9) for the i-th test case.

Output

Print t integers, the i-th should be the answer for the i-th test case.

Example

Input


5
1
9
10
34
880055535


Output


0
1
1
3
88005553

Note

The first interesting number is equal to 9.

import java.io.*;
import java.util.*;

public class Main {
    private static final fast sc = new fast();
    private static final BufferedWriter sout = new BufferedWriter(new OutputStreamWriter(System.out));
    private static final int OO = 1000000007;
    private static final double PI = Math.acos(-1);
    //right,down,left,up
    private static final int[] dx4 = {0, 1, 0, -1}, dx = {0, 0, 1, -1, 1, -1, 1, -1};
    private static final int[] dy4 = {1, 0, -1, 0}, dy = {1, -1, 0, 0, 1, -1, -1, 1};
    //static void print6P{ System.out.printf("%8.6f\n"); }

    public static void main(String[] args) throws IOException {
        //Start from here.
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            String s = String.valueOf(n);
            int res = (n / 10);
            if (s.charAt(s.length() - 1) == '9') {
                res += 1;
            }
            sout.write(res + "\n");

        }
        //end here
        sout.close();
    }

    static class fast {
        BufferedReader br;
        StringTokenizer st;

        fast() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        boolean hasNext() {
            if (st != null && st.hasMoreTokens()) {
                return true;
            }
            String tmp;
            try {
                br.mark(1000);
                tmp = br.readLine();
                if (tmp == null) {
                    return false;
                }
                br.reset();
            } catch (IOException e) {
                return false;
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        double nextFloat() {
            return Float.parseFloat(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    static class Pair implements Comparable<Pair> {
        Integer first;
        Integer second;

        Pair(Integer first, Integer second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public int compareTo(Pair o) {
            if (first.equals(o.first)) {
                return Double.compare(second, o.second);
            }
            return Double.compare(first, o.first);
        }

        @Override
        public boolean equals(Object o) {
            if (o instanceof Pair) {
                Pair p = (Pair) o;
                return p.first.equals(first) && p.second.equals(second);
            }
            return false;
        }

        @Override
        public int hashCode() {
            return first.hashCode() * 31 + second.hashCode();
        }
    }

    static class Triple implements Comparable<Triple> {
        Integer f;
        Integer s;
        Integer t;


        Triple(Integer first, Integer second, Integer third) {
            this.f = first;
            this.s = second;
            this.t = third;
        }

        @Override
        public int compareTo(Triple o) {
            return Long.compare(o.f, f);
        }
    }

}