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.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.InputMismatchException;

/**
 * @author ethan55
 */
public class Solution {
  public static void main(String[] args) {
    TestRunner.run();
  }

  public static class TestCase {
    static final boolean MULTIPLE = true;

    public void solve(InputReader in, OutputWriter out) {
      int n = in.nextInt();
      if (n == 9) {
        out.println(1);
      } else {
        out.println(n / 10);
      }
    }
  }

  public static class TestRunner {

    public static void run() {
      InputReader in = new InputReader(System.in);
      try (OutputWriter out = new OutputWriter(System.out)) {
        int testCases = TestCase.MULTIPLE ? in.nextInt() : 1;
        for (int i = 1; i <= testCases; i++) {
          new TestCase().solve(in, out);
        }
      }
    }

  }

  public static class OutputWriter implements AutoCloseable {
    private static final int BUFFER_SIZE = 1 << 13;
    private final byte[] outputBuffer = new byte[BUFFER_SIZE];
    private final OutputStream outputStream;
    private int outputBufferIndex = 0;

    public OutputWriter(OutputStream os) {
      this.outputStream = os;
    }

    public OutputWriter println(int x) {
      return writeln(x);
    }

    public void flush() {
      innerFlush();
      try {
        outputStream.flush();
      } catch (IOException e) {
        throw new IllegalStateException("Failed to flush");
      }
    }

    private OutputWriter write(byte b) {
      outputBuffer[outputBufferIndex++] = b;
      if (outputBufferIndex == BUFFER_SIZE) {
        innerFlush();
      }
      return this;
    }

    private OutputWriter write(String s) {
      s.chars()
          .forEach(
              c -> {
                outputBuffer[outputBufferIndex++] = (byte) c;
                if (outputBufferIndex == BUFFER_SIZE) {
                  innerFlush();
                }
              });
      return this;
    }

    private OutputWriter write(int x) {
      if (x == Integer.MIN_VALUE) {
        return write((long) x);
      }
      if (outputBufferIndex + 12 >= BUFFER_SIZE) {
        innerFlush();
      }
      if (x < 0) {
        write((byte) '-');
        x = -x;
      }
      int d = countDigits(x);
      for (int i = outputBufferIndex + d - 1; i >= outputBufferIndex; i--) {
        outputBuffer[i] = (byte) ('0' + x % 10);
        x /= 10;
      }
      outputBufferIndex += 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;
    }

    private OutputWriter write(long x) {
      if (x == Long.MIN_VALUE) {
        return write("" + x);
      }
      if (outputBufferIndex + 21 >= BUFFER_SIZE) {
        innerFlush();
      }
      if (x < 0) {
        write((byte) '-');
        x = -x;
      }
      int d = countDigits(x);
      for (int i = outputBufferIndex + d - 1; i >= outputBufferIndex; i--) {
        outputBuffer[i] = (byte) ('0' + x % 10);
        x /= 10;
      }
      outputBufferIndex += d;
      return this;
    }

    private OutputWriter writeln(int x) {
      return write(x).writeln();
    }

    private OutputWriter writeln() {
      return write((byte) '\n');
    }

    private void innerFlush() {
      try {
        outputStream.write(outputBuffer, 0, outputBufferIndex);
        outputBufferIndex = 0;
      } catch (IOException e) {
        throw new IllegalStateException("Failed to inner flush");
      }
    }

    @Override
    public void close() {
      flush();
    }
  }

  public static class InputReader {
    private final InputStream inputStream;
    private final byte[] inputBuffer = new byte[1024];
    private int bytesRead = 0;
    private int inputBufferIndex = 0;

    public InputReader(InputStream inputStream) {
      this.inputStream = inputStream;
    }

    private int readByte() {
      if (bytesRead == -1) {
        throw new InputMismatchException();
      }
      if (inputBufferIndex >= bytesRead) {
        inputBufferIndex = 0;
        try {
          bytesRead = inputStream.read(inputBuffer);
        } catch (IOException e) {
          throw new InputMismatchException();
        }
        if (bytesRead <= 0) {
          return -1;
        }
      }
      return inputBuffer[inputBufferIndex++];
    }

    public int nextInt() {
      return (int) nextLong();
    }

    public long nextLong() {
      long num = 0;
      int b;
      boolean minus = false;
      do {
        b = readByte();
      } while (b != -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();
      }
    }

  }
}