description: 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.
solution: # Enter your code here. Read input from STDIN. Print output to STDOUT# ===============================================================================================
  # importing some useful libraries
  from __future__ import division, print_function
  from fractions import Fraction
  import sys
  import os
  from io import BytesIO, IOBase
  from itertools import *
  import bisect
  from heapq import *
  from math import ceil, floor
  from copy import *
  from collections import deque, defaultdict
  from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
  from itertools import combinations  # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
  from itertools import permutations as permutate
  from bisect import bisect_left as bl
  from operator import *
  # If the element is already present in the list,
  
  # the left most position where element has to be inserted is returned.
  from bisect import bisect_right as br
  from bisect import bisect
  
  # If the element is already present in the list,
  # the right most position where element has to be inserted is returned
  
  # ==============================================================================================
  # fast I/O region
  
  BUFSIZE = 8192
  from sys import stderr
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "A" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  def print(*args, **kwargs):
      """Prints the values to a stream, or to sys.stdout by default."""
      sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
      at_start = True
      for A in args:
          if not at_start:
              file.write(sep)
          file.write(str(A))
          at_start = False
      file.write(kwargs.pop("end", "\n"))
      if kwargs.pop("flush", False):
          file.flush()
  
  
  if sys.version_info[0] < 3:
      sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
  else:
      sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  # inp = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # ===============================================================================================
  ### START ITERATE RECURSION ###
  from types import GeneratorType
  
  
  def iterative(f, stack=[]):
      def wrapped_func(*args, **kwargs):
          if stack: return f(*args, **kwargs)
          to = f(*args, **kwargs)
          while True:
              if type(to) is GeneratorType:
                  stack.append(to)
                  to = next(to)
                  continue
              stack.pop()
              if not stack: break
              to = stack[-1].send(to)
          return to
  
      return wrapped_func
  
  
  #### END ITERATE RECURSION ####
  ###########################
  # Sorted list
  class SortedList:
      def __init__(self, iterable=[], _load=200):
          """Initialize sorted list instance."""
          values = sorted(iterable)
          self._len = _len = len(values)
          self._load = _load
          self._lists = _lists = [values[start:start + _load] for start in range(0, _len, _load)]
          self._list_lens = [len(_list) for _list in _lists]
          self._mins = [_list[0] for _list in _lists]
          self._fen_tree = []
          self._rebuild = True
  
      def _fen_build(self):
          """Build a fenwick tree instance."""
          self._fen_tree[:] = self._list_lens
          _fen_tree = self._fen_tree
          for start in range(len(_fen_tree)):
              if start | start + 1 < len(_fen_tree):
                  _fen_tree[start | start + 1] += _fen_tree[start]
          self._rebuild = False
  
      def _fen_update(self, index, value):
          """Update `fen_tree[index] += value`."""
          if not self._rebuild:
              _fen_tree = self._fen_tree
              while index < len(_fen_tree):
                  _fen_tree[index] += value
                  index |= index + 1
  
      def _fen_query(self, end):
          """Return `sum(_fen_tree[:end])`."""
          if self._rebuild:
              self._fen_build()
  
          _fen_tree = self._fen_tree
          A = 0
          while end:
              A += _fen_tree[end - 1]
              end &= end - 1
          return A
  
      def _fen_findkth(self, k):
          """Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
          _list_lens = self._list_lens
          if k < _list_lens[0]:
              return 0, k
          if k >= self._len - _list_lens[-1]:
              return len(_list_lens) - 1, k + _list_lens[-1] - self._len
          if self._rebuild:
              self._fen_build()
  
          _fen_tree = self._fen_tree
          idx = -1
          for d in reversed(range(len(_fen_tree).bit_length())):
              right_idx = idx + (1 << d)
              if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
                  idx = right_idx
                  k -= _fen_tree[idx]
          return idx + 1, k
  
      def _delete(self, pos, idx):
          """Delete value at the given `(pos, idx)`."""
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
  
          self._len -= 1
          self._fen_update(pos, -1)
          del _lists[pos][idx]
          _list_lens[pos] -= 1
  
          if _list_lens[pos]:
              _mins[pos] = _lists[pos][0]
          else:
              del _lists[pos]
              del _list_lens[pos]
              del _mins[pos]
              self._rebuild = True
  
      def _loc_left(self, value):
          """Return an index pair that corresponds to the first position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
  
          _lists = self._lists
          _mins = self._mins
  
          lo, pos = -1, len(_lists) - 1
          while lo + 1 < pos:
              mi = (lo + pos) >> 1
              if value <= _mins[mi]:
                  pos = mi
              else:
                  lo = mi
  
          if pos and value <= _lists[pos - 1][-1]:
              pos -= 1
  
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value <= _list[mi]:
                  idx = mi
              else:
                  lo = mi
  
          return pos, idx
  
      def _loc_right(self, value):
          """Return an index pair that corresponds to the last position of `value` in the sorted list."""
          if not self._len:
              return 0, 0
  
          _lists = self._lists
          _mins = self._mins
  
          pos, hi = 0, len(_lists)
          while pos + 1 < hi:
              mi = (pos + hi) >> 1
              if value < _mins[mi]:
                  hi = mi
              else:
                  pos = mi
  
          _list = _lists[pos]
          lo, idx = -1, len(_list)
          while lo + 1 < idx:
              mi = (lo + idx) >> 1
              if value < _list[mi]:
                  idx = mi
              else:
                  lo = mi
  
          return pos, idx
  
      def add(self, value):
          """Add `value` to sorted list."""
          _load = self._load
          _lists = self._lists
          _mins = self._mins
          _list_lens = self._list_lens
  
          self._len += 1
          if _lists:
              pos, idx = self._loc_right(value)
              self._fen_update(pos, 1)
              _list = _lists[pos]
              _list.insert(idx, value)
              _list_lens[pos] += 1
              _mins[pos] = _list[0]
              if _load + _load < len(_list):
                  _lists.insert(pos + 1, _list[_load:])
                  _list_lens.insert(pos + 1, len(_list) - _load)
                  _mins.insert(pos + 1, _list[_load])
                  _list_lens[pos] = _load
                  del _list[_load:]
                  self._rebuild = True
          else:
              _lists.append([value])
              _mins.append(value)
              _list_lens.append(1)
              self._rebuild = True
  
      def discard(self, value):
          """Remove `value` from sorted list if it is a member."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_right(value)
              if idx and _lists[pos][idx - 1] == value:
                  self._delete(pos, idx - 1)
  
      def remove(self, value):
          """Remove `value` from sorted list; `value` must be a member."""
          _len = self._len
          self.discard(value)
          if _len == self._len:
              raise ValueError('{0!r} not in list'.format(value))
  
      def pop(self, index=-1):
          """Remove and return value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          value = self._lists[pos][idx]
          self._delete(pos, idx)
          return value
  
      def bisect_left(self, value):
          """Return the first index to insert `value` in the sorted list."""
          pos, idx = self._loc_left(value)
          return self._fen_query(pos) + idx
  
      def bisect_right(self, value):
          """Return the last index to insert `value` in the sorted list."""
          pos, idx = self._loc_right(value)
          return self._fen_query(pos) + idx
  
      def count(self, value):
          """Return number of ofinansurrences of `value` in the sorted list."""
          return self.bisect_right(value) - self.bisect_left(value)
  
      def __len__(self):
          """Return the size of the sorted list."""
          return self._len
  
      def __getitem__(self, index):
          """Lookup value at `index` in sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          return self._lists[pos][idx]
  
      def __delitem__(self, index):
          """Remove value at `index` from sorted list."""
          pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
          self._delete(pos, idx)
  
      def __contains__(self, value):
          """Return true if `value` is an element of the sorted list."""
          _lists = self._lists
          if _lists:
              pos, idx = self._loc_left(value)
              return idx < len(_lists[pos]) and _lists[pos][idx] == value
          return False
  
      def __iter__(self):
          """Return an iterator over the sorted list."""
          return (value for _list in self._lists for value in _list)
  
      def __reversed__(self):
          """Return a reverse iterator over the sorted list."""
          return (value for _list in reversed(self._lists) for value in reversed(_list))
  
      def __repr__(self):
          """Return string representation of sorted list."""
          return 'SortedList({0})'.format(list(self))
  
  
  # ===============================================================================================
  # some shortcuts
  
  mod = 1000000007
  
  
  def YES():
      print("YES")
  
  
  def NO():
      print("NO")
  
  
  def Yes():
      print("Yes")
  
  
  def No():
      print("No")
  
  
  def pow(A, B, p):
      res = 1  # Initialize result
      A = A % p  # Update A if it is more , than or equal to p
      if (A == 0):
          return 0
      while (B > 0):
          if ((B & 1) == 1):  # If B is odd, multiply, A with result
              res = (res * A) % p
  
          B = B >> 1  # B = B/2
          A = (A * A) % p
      return res
  
  
  from functools import reduce
  
  
  def numberOfSetBits(n):
      n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)
      n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)
      n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)
      n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)
      n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)
      n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32)  # This last & isn't strictly necessary.
      return n
  
  
  def factors(n):
      return set(reduce(list.__add__,
                        ([start, n // start] for start in range(1, int(n ** 0.5) + 1) if n % start == 0)))
  
  
  class MergeFind:
      def __init__(self, n):
          self.parent = list(range(n))
          self.size = [1] * n
          self.num_sets = n
          # self.lista = [[_] for _ in range(n)]
  
      def find(self, a):
          to_update = []
          while a != self.parent[a]:
              to_update.append(a)
              a = self.parent[a]
          for b in to_update:
              self.parent[b] = a
          return self.parent[a]
  
      def merge(self, a, b):
          a = self.find(a)
          b = self.find(b)
          if a == b:
              return
          if self.size[a] < self.size[b]:
              a, b = b, a
          self.num_sets -= 1
          self.parent[b] = a
          self.size[a] += self.size[b]
          # self.lista[a] += self.lista[b]
          # self.lista[b] = []
  
      def set_size(self, a):
          return self.size[self.find(a)]
  
      def __len__(self):
          return self.num_sets
  
  
  def gcd(a, b):
      if a == b: return a
      while b > 0: a, b = b, a % b
      return a
  
  
  def lcm(a, b):
      return abs((a // gcd(a, b)) * b)
  
  
  inf = float("inf")
  
  ##############Find sum of product of subsets of size k in a array
  
  
  # ar=[0,1,2,3]
  # k=3
  # n=len(ar)-1
  # dp=[0]*(n+1)
  # dp[0]=1
  # for pos in range(1,n+1):
  #     dp[pos]=0
  #     l=max(1,k+pos-n-1)
  #     for j in range(min(pos,k),l-1,-1):
  #         dp[j]=dp[j]+ar[pos]*dp[j-1]
  # print(dp[k])
  
  
  ##two pointer method
  
  
  # l=0
  # for r in range(n):
  #     add(r)
  #     while(not ok(l,r)):#l,r included
  #         remove(l)
  #         l+=1
  #     #[l,r] is valid
  #     if(ok()):
  #         do()
  
  
  # #==========================
  
  
  # r=-1
  # for l in range(n):
  #     while (r + 1 < l):
  #         r=l-1
  #         reset state
  #
  #
  #
  #     while(r+1<n and  ok_to_include_r+1()):
  #         add(r)
  #         r+=1
  #     #[l,r) is valid
  #     if(ok()):
  #         do()
  #     remove(l)
  
  
  # #############################
  
  
  # discrete binary search
  # minimise:
  # def search(l,r):
  #     ans=inf
  #     while(l<=r):
  #         mid=(r-l)//2 + l
  #         if(check(mid)):
  #             ans=min(ans,mid)
  #             r=mid-1
  #         else:
  #             l=mid+1
  #
  #     return ans
  
  # maximise:
  # def search(l,r):
  #
  #     ans=-1
  #     while(l<=r):
  #         mid=l+(r-l)//2
  #         if(check(mid)):
  #             ans=max(ans,mid)
  #             l=mid+1
  #         else:
  #             r=mid-1
  #
  #     return ans
  
  
  # =========================================================================================
  from collections import defaultdict
  
  
  # #
  # large=1000000000000000035000061
  # to find factorial and ncr
  # tot = 2005
  # mod = 998244353
  
  # fac = [1, 1]
  # finv = [1, 1]
  # inv = [0, 1]
  #
  # for start in range(2, tot + 1):
  #     fac.append((fac[-1] * start) % mod)
  #     inv.append(mod - (inv[mod % start] * (mod // start) % mod))
  #     finv.append(finv[-1] * inv[-1] % mod)
  
  
  def comb(n, r):
      if (r == 0 or r == n): return 1
      if n < r:
          return 0
      else:
          return fac[n] * (finv[r] * finv[n - r] % mod) % mod
  
  
  #
  # from functools import lru_cache
  # p=3
  # def ncr_small_mod_p(n,r):
  #     ans=1
  #     while(n>0):
  #         x=n%p
  #         y=r%p
  #         n//=p
  #         r//=p
  #         ans*=comb(x,y)
  #         ans%=p
  #     return ans
  
  
  #
  
  def inp(): return sys.stdin.readline().rstrip("\r\n")  # for fast input
  
  
  def N():
      return int(inp())
  
  
  def out(var): sys.stdout.write(str(var))  # for fast output, always take string
  
  
  def lis(): return list(map(int, inp().split()))
  
  
  def stringlis(): return list(map(str, inp().split()))
  
  
  def sep(): return map(int, inp().split())
  
  
  def strsep(): return map(str, inp().split())
  
  
  def fsep(): return map(float, inp().split())
  
  
  def nextline(): out("\n")  # as stdout.write always print sring.
  
  
  def arr1d(n, v):
      return [v] * n
  
  
  def arr2d(n, m, v):
      return [[v] * m for _ in range(n)]
  
  
  def arr3d(n, m, p, v):
      return [[[v] * p for _ in range(m)] for sta in range(n)]
  
  
  def ceil(a, b):
      return (a + b - 1) // b
  
  
  # co-ordinate compression
  # ma={s:idx for idx,s in enumerate(sorted(set(l+r)))}
  
  # mxn=100005
  # lrg=[0]*mxn
  # for start in range(2,mxn-3):
  #     if (lrg[start]==0):
  #         for j in range(start,mxn-3,start):
  #             lrg[j]=start
  
  test_count = 1
  
  
  def testcase(t):
      global test_count
      for p in range(t):
          global test_count
          # print("Case #{}:".format(test_count), end=" ")
          solve()
          test_count += 1
  
  
  def solve():
      n=N()
      n+=1
      print(n//10)
  
  
  #solve()
  testcase(N())
  
  
  
  