You are given two integers $a$ and $b$.

In one move, you can choose some integer $k$ from $1$ to $10$ and add it to $a$ or subtract it from $a$. In other words, you choose an integer $k \in [1; 10]$ and perform $a := a + k$ or $a := a - k$. You may use different values of $k$ in different moves.

Your task is to find the minimum number of moves required to obtain $b$ from $a$.

You have to answer $t$ independent test cases.


-----Input-----

The first line of the input contains one integer $t$ ($1 \le t \le 2 \cdot 10^4$) — the number of test cases. Then $t$ test cases follow.

The only line of the test case contains two integers $a$ and $b$ ($1 \le a, b \le 10^9$).


-----Output-----

For each test case, print the answer: the minimum number of moves required to obtain $b$ from $a$.


-----Example-----
Input
6
5 5
13 42
18 4
1337 420
123456789 1000000000
100500 9000

Output
0
3
2
92
87654322
9150



-----Note-----

In the first test case of the example, you don't need to do anything.

In the second test case of the example, the following sequence of moves can be applied: $13 \rightarrow 23 \rightarrow 32 \rightarrow 42$ (add $10$, add $9$, add $10$).

In the third test case of the example, the following sequence of moves can be applied: $18 \rightarrow 10 \rightarrow 4$ (subtract $8$, subtract $6$).

Difficulty: introductory

Starter code:

Solutions:
for _ in range(int(input())):
    a,b=map(int,input().split())
    print((abs(a-b)+9)//10)

for _ in range(int(input())):
    a,b = map(int,input().split())
    print((abs(b - a) + 9) // 10)

import sys
import math
def II():
	return int(sys.stdin.readline())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def MI():
	return map(int, sys.stdin.readline().split())

def SI():
	return sys.stdin.readline().strip()
t = II()
for q in range(t):
	a,b = MI()
	print(math.ceil(abs(a-b)/10))

from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline

from itertools import accumulate
from functools import lru_cache

M = mod = 10000
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
 
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]


for _ in range(val()):
    a, b = sorted(li())
    print(math.ceil((b - a)/10))

for _ in range(int(input())):
    a, b = list(map(int, input().split()))
    print(-(-abs(a - b) // 10))


#Bhargey Mehta (Senior)
#DA-IICT, Gandhinagar
import sys, math
mod = 10**9 + 7

def solve(test_index):
    a, b = list(map(int, input().split()))
    ans = math.ceil(abs(a-b) / 10)
    print(ans)
    return

if 'PyPy' not in sys.version:
    sys.stdin = open('input.txt', 'r')

sys.setrecursionlimit(100000)
num_tests = 1
num_tests = int(input())
for test in range(1, num_tests+1):
    #print("Case #{}: ".format(test), end="")
    solve(test)


#!/usr/bin/env pypy3

import math

T = int(input())
for t in range(T):
	A, B = input().split()
	A = int(A)
	B = int(B)
	print(math.ceil(abs(B-A)/10))

t = int(input())
for _ in range(t):
    a,b = list(map(int, input().split()))
    ans = (abs(a-b)+9)//10
    print(ans)


t=int(input())
for you in range(t):
    l=input().split()
    a=int(l[0])
    b=int(l[1])
    z=abs(a-b)
    print((z+9)//10)


import sys
# from collections import deque
# from collections import Counter
# from math import sqrt
# from math import log
from math import ceil
# from bisect import bisect_left, bisect_right

# alpha=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# mod=10**9+7
# mod=998244353

# def BinarySearch(a,x): 
# 	i=bisect_left(a,x) 
# 	if(i!=len(a) and a[i]==x): 
# 		return i 
# 	else: 
# 		return -1

# def sieve(n): 
# 	prime=[True for i in range(n+1)]
# 	p=2
# 	while(p*p<=n): 
# 		if (prime[p]==True): 
# 			for i in range(p*p,n+1,p): 
# 				prime[i]=False
# 		p+=1
# 	prime[0]=False
# 	prime[1]=False
# 	s=set()
# 	for i in range(len(prime)):
# 		if(prime[i]):
# 		s.add(i)
# 	return s

# def gcd(a, b):
# 	if(a==0):
# 		return b 
# 	return gcd(b%a,a)

fast_reader=sys.stdin.readline
fast_writer=sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i)) for i in argv))
	fast_writer('\n')

#____________________________________________________________________________________________________________________________________

for _ in range(int(input())):
	a,b=map(int, input().split())
	print(ceil(abs(a-b)/10))

import math
from collections import deque
from sys import stdin, stdout
from string import ascii_letters
import sys
letters = ascii_letters
input = stdin.readline
#print = stdout.write

for i in range(int(input())):
#for i in range(1):
    a, b = list(map(int, input().split()))
    print(abs(a - b) // 10 + (1 if abs(a - b) % 10 != 0 else 0))


# map(int, input().split())
rw = int(input())
for wewq in range(rw):
   a, b = list(map(int, input().split()))
   d = abs(a - b)
   print((d + 9) // 10)