Problem:
 Score : 200 points    Problem Statement You are given nonnegative integers a and b ( a ≤ b ), and a positive integer x .
Among the integers between a and b , inclusive, how many are divisible by x ?      Constraints  0 ≤ a ≤ b ≤ 10^{18}  1 ≤ x ≤ 10^{18}         Input The input is given from Standard Input in the following format:  a  b  x       Output Print the number of the integers between a and b , inclusive, that are divisible by x .        Sample Input 1 4 8 2      Sample Output 1 3  There are three integers between 4 and 8 , inclusive, that are divisible by 2 : 4 , 6 and 8 .       Sample Input 2 0 5 1      Sample Output 2 6  There are six integers between 0 and 5 , inclusive, that are divisible by 1 : 0 , 1 , 2 , 3 , 4 and 5 .       Sample Input 3 9 9 2      Sample Output 3 0  There are no integer between 9 and 9 , inclusive, that is divisible by 2 .       Sample Input 4 1 1000000000000000000 3      Sample Output 4 333333333333333333  Watch out for integer overflows.

Solution (Python):




import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """4 8 2"""
        output = """3"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """0 5 1"""
        output = """6"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """9 9 2"""
        output = """0"""
        self.assertIO(input, output)

    def test_入力例_4(self):
        input = """1 1000000000000000000 3"""
        output = """333333333333333333"""
        self.assertIO(input, output)


def resolve():
    a, b, x = map(int, input().split())

    if a % x == 0:
        print(b//x - a//x+1)
    else:
        print(b//x - a//x)


if __name__ == "__main__":
    
    resolve()

Solution (Python):
a, b, x = map(int,input().split())
print(b//x - (a-1)//x)

Solution (Python):
a,b,x = map(int,input().split())
b1 = b//x
a1 = (a-1)//x
print(b1-a1)

Solution (Python):
import sys
input = sys.stdin.readline



def main():
    a, b, x = [int(i) for i in input().strip().split()]
    b_x = b // x
    if a > 0:
        a_x = (a - 1) // x
    else:
        a_x = -1
    ans = b_x - a_x
    print(ans)
    return


if __name__ == "__main__":
    main()

Solution (Python):
from sys  import stdin,stdout
 
import bisect
 
import math
 
from collections import deque
 
mod=10**9 +7 
 
def st():
    return list(stdin.readline().strip())
 
def inp():
    return int(stdin.readline())
 
def li():
    return list(map(int,stdin.readline().split()))
 
def mp():
    return map(int,stdin.readline().split())
 
def pr(n):
    stdout.write(str(n)+"\n")
    
def DFS(dictionary,vertex,visited):
    visited[vertex]=True
    stack=[vertex]
    print(vertex)
    while stack:
        a=stack.pop()
        for i in dictionary[a]:
            if not visited[i]:
                print(i)
                visited[i]=True
                stack.append(i)
 
 
def BFS(dictionary, vertex,visited):
    visited[vertex]=True
    q=deque()
    q.append(vertex)
    while q:
        a=q.popleft()
        for i in dictionary[a]:
            if not visited[i]:
                visited[i]=True
                q.append(i)
                print(i)
 
                
 
 
def soe(limit):
    l=[1]*(limit+1)
    l[0]=0
    l[1]=0
    prime=[]
    for i in range(2,limit+1):
        if l[i]:
            for j in range(i*i,limit+1,i):
                l[j]=0
    
    for i in range(2,limit+1):
        if l[i]:
            prime.append(i)
    return prime
 
def segsoe(low,high):
    limit=int(high**0.5)+1
    prime=soe(limit)
    n=high-low+1
    l=[0]*(n+1)
    for i in range(len(prime)):
        lowlimit=(low//prime[i])*prime[i]
        if lowlimit<low:
            lowlimit+=prime[i]
        if lowlimit==prime[i]:
            lowlimit+=prime[i]
        for j in range(lowlimit,high+1,prime[i]):
            l[j-low]=1
    for i in range(low,high+1):
        if not l[i-low]:
            if i!=1:
                print(i)
                
def gcd(a,b):
    while b:
        a=a%b
        b,a=a,b
    return a
 
def power(a,n):
    r=1
    while n:
        if n&1:
            r=(r*a)
        a*=a
        n=n>>1
    return r

x=soe(10**6)
 
def prime(n):
    d={}
    i=0
    while x[i]*x[i]<=n:
        if n%x[i]==0:
            d[x[i]]=0
            while n%x[i]==0:
                n=n//x[i]
                d[x[i]]+=1
        i+=1
    if n>1:
        d[n]=1
        
    mi=-10
    ans=float('inf')
    
    for i in d:
        if d[i]>mi:
            ans=i
            mi=d[i]
        elif d[i]==mi:
            ans=min(ans,i)
    return ans
    
def solve():
    a,b,x=mp()
    z=b//x
    c=a//x
    if a%x==0:
        pr(z-c+1)
    else:
        pr(z-c)
 
 
 
for _ in range(1):
    solve()

Solution (Python):
def resolve():
  a, b, x = map(int, input().split(" "))

  diff = b - a
  result = diff // x
  if not x - a%x + b%x >= x or a%x == 0 or b%x == 0:
    result += 1

  print(result)

if __name__ == "__main__":
  resolve()

Solution (Python):
a, b, x = map(int, input().split())
print(b//x - (a-1)//x)

Solution (Python):
a,b,x=map(int,input().split())
c=(b//x-a//x)
if a%x==0:
  print(c+1)
else:
  print(c)

Solution (Python):
a,b,x = map(int, input().split())
c = (b // x) - ((a - 1) // x)
print(c)

Solution (Python):







def solve(a,b,x):
  def countDivisible(k,d):
    return k // d
  return countDivisible(b,x) - countDivisible(a-1,x)



def main():
  a,b,x = map(int,input().split())
  
  print(solve(a,b,x))
  return

if __name__ == '__main__':
  main()

Solution (Python):
def count_muls(num, x):
    if num < 0:
        return 0
    return num // x + 1

def resolve():
    a, b, x = map(int, input().split())
    print(count_muls(b, x) - count_muls(a-1, x))

resolve()

Solution (Python):
a,b,x = map(int, input().split())
if a%x == 0:
  print (b//x- a//x+ 1)
else:
  print (b//x- a//x)

Solution (Python):

def main():
    a, b, x = map(int, input().split())

    if a == 0:
        print(b//x+1)
    else:
        print(b//x-((a-1)//x))
            

if __name__ ==  "__main__":
    main()

Solution (Python):
a, b, x = map(int,input().split())
 
if a % x == 0:
    print(b//x - a//x + 1)
    
else:
    print(b//x - a//x)

Solution (Python):
a,b,x = map(int, input().split())

c = (b // x) - ((a - 1) // x)
d = c

print(d)

Solution (Python):
a, b, x = map(int, input().split())

def count(n, x):
    if n < 0:
        return 0
    else:
        return n//x+1
ans = count(b, x)-count(a-1, x)
print(ans)

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
a,b,x = map(int,input().split())
ans = b//x -(a-1)//x
print(ans)

Solution (Python):
a,b,x=map(int,input().split())








def between(a,b,x):
    if a==0:
        na=0
    else:
        na=(a-1)//x+1
    nb=b//x+1
    print(nb-na)
between(a,b,x)

Solution (Python):
a,b,x = map(int,input().split())
if a != 0:
    dum1 = ((a-1) // x) + 1
else:
    dum1 = 0
dum2 = (b//x)+1
print(dum2-dum1)

Solution (Python):
a,b,x = map(int,input().split())
dum1 = (a-1)//x
dum2 = b//x
print(dum2-dum1)

Solution (Python):
a, b, x = map(int, input().split())
if a % x == 0:
  b -= b % x
  print((b - a)//x + 1)
else:
  a -= a % x
  b -= b % x
  print((b - a)//x)

Solution (Python):
a, b, x = map(int, input().split())
ans = b // x - a // x
if a % x == 0:
    ans += 1
print(ans)

Solution (Python):
a, b, x = map(int, input().split())
a += (x - a % x) if a % x != 0 else 0
answ = (b - a) // x if a % x != 0 else (b - a) // x + 1
print(answ)

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,x = I()
ca = (a-1)//x
cb = b//x
ans += cb-ca
print(ans)

Solution (Python):
a,b,x=map(int,input().split())

s=(b//x-(a-1)//x)
print(s)

Solution (Python):
import math
import sys
import numpy as np
from decimal import *
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, x = map(int, readline().split())

ans = Decimal(b // x) - Decimal(a // x)
if (a % x == 0):
    ans += 1

print(int(ans))

Solution (Python):





import math
import fractions
import sys
import bisect
import heapq  
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append([i, cnt])

    if temp != 1:
        arr.append([temp, 1])

    if arr == []:
        arr.append([n, 1])

    return arr



def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod



def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors


inf = 10 ** 18
mod = 10 ** 9 + 7

a,b,x = lr()
inda = a//x
if a%x==0:
    inda-=1
indb = b//x
if a!=b:
    print(indb-inda)
else:
    if a%x==0:
        print(1)
    else:
        print(0)

Solution (Python):
a,b,x = map(int,input().split())
mx = b//x
mn = (a-1)//x
print(mx-mn)

Solution (Python):
a,b,x = map(int,input().split())
fb = b//x+1
if a!= 0 :
    fa = (a-1)//x+1
else :
    fa = 0
print(fb-fa)

Solution (Python):
a,b,x=map(int,input().split())

if a%x==0:
    p=1
else:
    p=0

print(p+b//x-a//x)

Solution (Python):
import decimal
decimal.getcontext().prec=50
a,b,x=map(int,input().split())
a=decimal.Decimal(a)
b=decimal.Decimal(b)
print(int(b/x)-int((a+x-1)/x)+1)

Solution (Python):
def resolve():
    a, b, x = map(int, input().split())
    if a != 0:
        print(b//x-(a-1)//x)
    elif b != 0:
        print(b//x+1)
    else:
        print("1")
resolve()

Solution (Python):
a, b, x = map(int, input().split())
ans = b//x - (a-1)//x
print(ans)

Solution (Python):
a,b,x=map(int,input().split())

q1,r1=divmod(a,x)
q2,_=divmod(b,x)

print(q2-q1+(r1==0))

Solution (Python):
a,b,x=map(int,input().split())
n=a//x
m=b//x
ans=m-n
if a%x==0:
    ans+=1
print(ans)

Solution (Python):
a,b,x=map(int,input().split())
if a%x==0:
  print(b//x-a//x+1)
else:
  print(b//x-a//x)

Solution (Python):
a, b, x = map(int, input().split())
ans = b // x - a // x
if a % x == 0:
  ans += 1
print(ans)

Solution (Python):
from decimal import *
a, b, x = map(int, input().split())
ax = int(Decimal(a) / Decimal(x))
bx = int(Decimal(b) / Decimal(x))
am = a % x
bm = b % x
if ax == bx and am != 0 and bm != 0:
  print(0)
elif am == 0:
  print(bx - ax + 1)
else:
  print(bx - ax)

Solution (Python):
a,b,x =map(int,input().split())
print((b//x)-((a-1)//x))

Solution (Python):
A,B,X=map(int,input().split())
print(abs((A-1)//X-B//X))

Solution (Python):
a,b,x = (int(T) for T in input().split())
print((b//x)-(a//x)+(a%x==0))

Solution (Python):
import math
a, b, x = map(int, input().split())
bwaru = b//x
awaru = (a-1)//x
ans = bwaru-awaru
print(ans)

Solution (Python):
a, b, x = [int(x) for x in input().split()]

first = (a // x) * x

if a % x != 0:
    first += x

result = len(range(first, b+1, x))
print(result)

Solution (Python):
a,b,x = map(int, open(0).read().split())
if a == 0:
    print((b//x)+1)
else:
    print((b//x)-((a-1)//x))

Solution (Python):
a, b, x = map(int, input().split())

na = (a - 1) // x
nb = b // x
print(nb - na)

Solution (Python):
a,b,x = map(int,input().split())
print(b//x - (a-1)//x)

Solution (Python):
A,B,X=map(int,input().split())
print(B//X-(A-1)//X)

Solution (Python):
a, b, x = [int(s) for s in input().split()]
q, m = divmod(a, x)
print(b // x - q + (1 if m == 0 else 0))

Solution (Python):
A, B, X = map(int, input().split())
print(B//X-(A-1)//X)

Solution (Python):
a, b, x = map(int, input().split())
print(b//x - (a-1)//x)

Solution (Python):







a,b,x = map(int, input().split())


def function(n,x):
    if (n>=0):
        return n//x+1
    else:
        return 0

ans = function(b,x) - function(a-1,x)

print(ans)

Solution (Python):
a, b, x = map(int, input().split())
print(b//x - (a-1)//x)

Solution (Python):
a, b, x = map(int, input().split())
if a % x == 0:
    print(b // x - a // x + 1)
else:
    print(b // x - a // x)

Solution (Python):

import collections as cl
import sys


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


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


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


def main():
    a, b, x = MI()
    print(b // x - (a - 1) // x)


main()

Solution (Python):
a,b,x=map(int,input().split())
k=a//x
l=a%x
p=b//x
q=b%x
if l==0:
    print(p-k+1)
else:
    print(p-k)

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    a, b, x = LI()

    ans = b // x - (a - 1) // x
    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
a,b,x = map(int,input().split())

if a%x == 0:
    ans = b//x - a//x + 1

else:
    ans = b//x - (a + x - a%x)//x + 1

print(ans)

Solution (Python):
a, b, x = map(int, input().split())
res = int(b//x - (a-1)//x)
print(res)

Solution (Python):
a,b,x = map(int,input().split())
t = b//x
if a == 0:
    print(t+1)
else:
    print(t-(a-1)//x)

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):

a, b, x = map(int, input().split())
print(b//x - (a-1)//x)

Solution (Python):


a, b, x = map(int, input().split())

def f(n):
    global x
    if n == -1: 
        return 0
    return n//x + 1 

ans = f(b)-f(a-1)
print(ans)

Solution (Python):


a, b, x = map(int, input().split())

if a == b:
    if a%x == 0:
        print(1)
    else:
        print(0)
    exit()
if a%x == 0 and b%x == 0:
    ans = b//x - a//x + 1 
    print(ans)
    exit()
if a%x != 0 and b%x != 0:
    ans = b//x - a//x
    print(ans)
    exit()
if a%x == 0 and b%x != 0:
    ans = b//x - a//x + 1 
    print(ans)
    exit()
ans = b//x - a//x 
print(ans)

Solution (Python):
a,b,x=list(map(int,input().split()))
print(b//x - (a-1)//x)

Solution (Python):
a, b, x = map(int, input().split())
res = int(b//x - (a-1)//x)
print(res)

Solution (Python):
a,b,c = list(map(int,input().split()))
x = a//c 
y = b//c
if a%c:
    print(y-x)
else:
    print((y-x)+1)

Solution (Python):
a,b,x = list(map(int,input().split()))
a1 = a//x if a%x else a//x-1
a2 = b//x
print(a2-a1)

Solution (Python):
a, b, x = map(int, input().split())

result = b//x-a//x
if a % x == 0:
    result +=1

print(result)

Solution (Python):
a, b, x = map(int, input().split())

result = b//x-a//x
if a % x == 0:
    result +=1

print(result)

Solution (Python):
a,b,x = map(int, input().split())

print(b//x - (a-1)//x)

Solution (Python):
def getDivCount( a, b, x ):
    count=0
    if a!=0 :
        count+=b//x-(a-1)//x
    else:
        count+=b//x+1
    return count

a,b,x = map(int, input().split())
print( getDivCount(a,b,x) )

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
a, b, x = map(int, input().split())
print(b // x - (a - 1) // x)

Solution (Python):
a,b,x = map(int, input().split())

count=0
if a==0 :
    count+=1

if a<=x :
    ai = x
else:
    ai = (a//x)*x
    if ai<a :
        ai +=x
if ai<=b :
    count+=1
    count+=(b-ai)//x

print(count)

Solution (Python):
a,b,x = map(int, input().split())

s = b//x
t = (a-1)//x
print(s-t)

Solution (Python):
A,B,X = list(map(int,input().split()))
print(B//X-(A-1)//X)

Solution (Python):
a,b,x=map(int,input().split())
if a%x!=0:
  a+=x-a%x

if a==b and a==0:
  print(1)
elif a==b and a==x:
  print(1)
elif a>=b:
  print(0)
else:
  print(b//x-a//x+1)

Solution (Python):
import numpy as np
a, b, x = map(int, input().split())
print(b // x - (a-1) // x)

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    a, b, x = map(int, readline().split())

    print(b // x - (a - 1) // x)


if __name__ == '__main__':
    main()

Solution (Python):
a, b, x = map(int, input().split())

r = b // x - a // x
if a % x == 0:
    r += 1

print(r)

Solution (Python):
def main():
    a, b, x = map(int, input().split())
    if a == 0:
        left = 0
    else:
        left = (a-1)//x + 1

    if b == 0:
        right = 1
    else:
        right = b//x + 1 

    print(right - left)
if __name__ == "__main__":
    main()

Solution (Python):
a,b,x=map(int, input().split())
print(b//x-(a-1)//x)

Solution (Python):
a,b,x = map(int,input().split())
def f(n,x):
    if n == -1:
        return 0
    else:
        return n // x + 1
print(int(f(b,x)-f(a-1,x)))

Solution (Python):
a,b,x=list(map(int, input().split()))
if a==0:
    print(b//x+1)
else:
    print(b//x-(a-1)//x)

Solution (Python):
a,b,x = map(int, input().split())

print(b//x + -a//x + 1)

Solution (Python):
a, b, x = map(int, input().split())
print(b // x - ~-a // x)

Solution (Python):
a,b,x = map(int, input().split())
print(b//x-(a-1)//x if a!=0 else b//x+1)

Solution (Python):
a, b, x = list(map(int, input().split()))
print(b // x - (a - 1) // x)

Solution (Python):
a, b, x = map(int, input().split())


def n_div(a):
    
    return a // x


answer = n_div(b) - n_div(a - 1)
print(answer)

Solution (Python):
a, b, x = map(int, input().split())
print(b // x - (a - 1) // x)

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
a,b,x=[int(i) for i in input().split()]

def get_mod_num(limit,x):
    if limit==-1:
        return 0
    return limit//x+1

print(get_mod_num(b,x)-get_mod_num(a-1,x))

Solution (Python):
a,b,c=map(int,input().split())
n=a//c
m=b//c
o=0
if a%c==0:
    o=1
print(m-n+o)

Solution (Python):


def main():

    a, b, x = map(int, input().split())
    ans = 0

    ans = (b // x) - ((a-1) // x)

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
a,b,x=map(int,input().split())
a_p=a//x
b_p=b//x

if a%x==0:
    print(b_p-a_p+1)
else:
    print(b_p-a_p)

Solution (Python):
a,b,x=map(int,input().split())
num_a=a//x
num_b=b//x
ans=num_b-num_a
if a%x==0:
    ans+=1
print(ans)

Solution (Python):
def resolve():
    a, b, x = list(map(int, input().split()))
    result = b // x - (a - 1) // x
    print(result)

resolve()

Solution (Python):
a, b, x = map(int, input().split())
a_div = (a - 1) // x + 1
b_div = b // x + 1

print(b_div - a_div)

Solution (Python):
a, b, x = map(int,input().split())
ans =0
if a%x==0:
	ans = (b//x)-(a//x)+1
else:
	ans = (b//x)-(a//x)
print(ans)

Solution (Python):
a,b,x=map(int,input().split())
if a==0:
    
    if b%x==0:
        ans_b = b//x +1
    else:
        ans_b = b//x +1
    
    if a%x==0:
        ans_a = a//x
    else:
        ans_a = a//x + 1
else:
    ans_b = b//x
    if a%x==0:
        ans_a = a//x -1
    else:
        ans_a = a//x

print(ans_b-ans_a)

Solution (Python):
a,b,x = map(int,input().split())

def f(n,x):
    return n//x

print(f(b,x)-f(a-1,x))

Solution (Python):
def main():
    
    end, start, divisor = [int(i) for i in input().split()]
    a = start//divisor - (end-1)//divisor

    print(a)

main()

Solution (Python):
def main():
    
    end, start, divisor = [int(i) for i in input().split()]
    '''
    end = 1
    start = 1000 000 000 000 000 000
    divisor = 3
    '''

    if end % divisor == 0:
        a = start//divisor - end//divisor + 1
    else:
        a = start//divisor - end//divisor

    print(a)

main()

Solution (Python):
import math
a,b,c=[int(i) for i in input().split()]
print(b//c - (a-1)//c)

Solution (Python):
import math
from decimal import Decimal
a,b,x=map(int,input().split())
print(math.floor(Decimal(b)/Decimal(x))-math.ceil(Decimal(a)/Decimal(x))+1)

Solution (Python):
a,b,x=map(int,input().split())
print(b//x - (a-1)//x)

Solution (Python):
a,b,c=map(int,input().split())
mini = 0
m = a % c
if m == 0:
  mini = a/c
else:
  mini = (c-m + a)/c
maxi = 0
M = b % c
if M == 0:
  maxi = b//c
else:
  maxi = (b-M)//c
res = int(maxi) - int(mini) + 1
print(res)

Solution (Python):
a,b,x = map(int,input().split())

if a % x == 0:
  print((b//x)-(a//x)+1)
else:
  print((b//x)-(a//x))

Solution (Python):
def main():
    a,b,x=map(int,input().split())
    print(b//x - (a-1)//x)
    
if __name__ == "__main__":
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    a, b, x = map(int, readline().split())

    if a == 0:
        ans = b // x + 1
    else:
        ans = b // x - (a - 1) // x

    print(ans)
    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    a, b, x = map(int, readline().split())

    if b == 0:
        ans = 1
    elif a == 0:
        ans = b // x + 1
    else:
        ans = b // x - (a - 1) // x

    print(ans)
    return


if __name__ == '__main__':
    main()

Solution (Python):
a,b,x = list(map(int,input().split()))

ans=0
if a!=b:
    A = (a-1)//x
    B = b//x

    ans = B - A
elif a==0 and b==0:
    ans=1
    
elif a==x and b==x:
    ans=1

print(ans)

Solution (Python):
a,b,c = map(int,input().split())

if a%c == 0:
    print(b//c-a//c+1)
else:
    print(b//c-a//c)

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
    a, b, x = map(int, input().split())
    r = (b // x) + 1
    if b > 0:
        r -= ((a - 1) // x) + 1
    print(r)

if __name__ == '__main__':
    main()

Solution (Python):
a, b, x = map(int, input().split(" "))

ad = a // x
bd = b // x
ans = bd - ad
if a % x == 0:
    ans += 1
print(ans)

Solution (Python):
a,b,x=map(int, input().split())
def f(n,x):
    if n>=0:
        return int(n//x)+1
    else:
        return 0

print(f(b,x)-f(a-1,x))

Solution (Python):
a, b, x = map(int, input().split())


temp1 = b // x + 1



if a == 0:
    temp2 = 0
else:
    temp2 = (a - 1) // x + 1

print(temp1 - temp2)

Solution (Python):

a, b, x = map(int, input().split())

print((b // x) - ((a - 1) // x))

Solution (Python):
a,b,x = map(int, input().split())
work1 = b // x
work2 = (a - 1) // x
print(work1 - work2)

Solution (Python):
a,b,x = map(int, input().split())
print((b//x) - ((a-1)//x))

Solution (Python):
a,b,x = map(int, input().split())

ans = (b//x) - ((a-1)//x)
print(ans)

Solution (Python):
a, b, x = 4, 8, 3
a, b, x = 0, 5, 1
a, b, x = 9, 9, 2
a, b, x = 1, 1000000000000000000, 3

a, b, x = map(int,input().split())


def calculate(a, b, x):
    s1 = (a - 1) // x

    if s1 < 0:
        s1 = 0
    else:
        s1 += 1
    s2 = b // x + 1

    print(s2 - s1)


calculate(a, b, x)

Solution (Python):
a,b,x = map(int,input().split())
ans = b//x-(a+x-1)//x+1
print(ans)

Solution (Python):
a,b,x = map(int,input().split())

a = (a-1)//x
b = b//x

print(b-a)

Solution (Python):
import sys
from collections import defaultdict, deque, Counter
import math


from bisect import bisect_left, bisect_right
import heapq




input = sys.stdin.readline

getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n-k])) % MOD


def kaijyo(n):
    ret = [1]
    for i in range(1, n + 1):
        ret.append((ret[-1] * i)% MOD)
    return ret

def solve():
    a,b,x = getList()
    fb = b // x
    fa = (a-1) // x
    print(fb - fa)

def main():
    n = getN()
    for _ in range(n):
        solve()


if __name__ == "__main__":
    
    solve()

Solution (Python):
a,b,x = map(int, input().split())

bcnt = b // x
acnt = (a-1) // x
print(bcnt-acnt)

Solution (Python):
A, B, X = [int(x) for x in input().split()]

print((B // X) - ((A - 1) // X))

Solution (Python):
a,b,x = map(int,input().split())
def f(n):
    return n//x
print(f(b) - f(a-1))

Solution (Python):
def main():
    a, b, x = map( int, input().split())
    print(b//x - (a-1)//x)
if __name__ == '__main__':
    main()

Solution (Python):
import sys,math,collections,itertools
input = sys.stdin.readline

A,B,X=list(map(int,input().split()))
print(B//X - (A-1)//X)

Solution (Python):
a, b, x = map(int, input().split())
ans = b//x - (a-1)//x
print(ans)

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
a,b,x = map(int,input().split())
print((b//x)-(a//x)+(a%x == 0))

Solution (Python):
x,y,d=map(int,input().split())
ans=y//d-(x-1)//d
print(ans)

Solution (Python):
a,b,x = map(int, input().split())
print(b//x-(a-1)//x)

Solution (Python):
import sys
def LI():
    return list(map(int,sys.stdin.readline().rstrip().split()))  

a,b,x = LI()

print(max(b//x-(a-1)//x,0))

Solution (Python):
a, b, x = map(int, input().split())
print(b // x - max(0, a - 1) // x +
      (1 if a == 0 else 0))

Solution (Python):
import math
a,b,x = map(int,input().split())
b_ans = b//x
a_ans = a//x
a_amari = a%x
print(b_ans-(a_ans+(a_amari>0))+1)

Solution (Python):
a, b, x = map(int, input().split())


p = a // x
r = a % x
q = b // x
s = b % x

res = q - p

if r == 0:
  res += 1

print(res)

Solution (Python):


a, b, x = map(int, input().split(" "))


def f(n):
    if n == -1:
        return 0
    else:
        return n // x + 1

print(f(b) - f(a-1))

Solution (Python):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
a, b, x = map(int, input().split())

print(b//x - (a-1)//x)

Solution (Python):

a,b,x = map(int, input().split())

res = 0
d_min = a // x
d = (b- d_min * x) // x
res = d + (1 if d_min * x == a else 0)

print(res)

Solution (Python):
a, b, x = map(int, input().split())
print(b // x - (a - 1) // x)

Solution (Python):
s = input().split()

a = int(s[0])
b = int(s[1])
x = int(s[2])

def bet_ween(p, q):
    if p < 0:
        return 0
    else:
        return (p // q) + 1


fa = bet_ween(a-1, x)
fb = bet_ween(b, x)
answer = fb - fa
print(int(answer))

Solution (Python):
a, b, x = map(int, input().split())

A = -((-a) // x)
B = b // x
print(B - A + 1)

Solution (Python):
a, b, x = map(int, input().split())
print(b//x - (a-1) // x)

Solution (Python):
a,b,x=map(int,input().split())

print(b//x-a//x+(a%x==0))

Solution (Python):
import sys
input = sys.stdin.buffer.readline




def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))


def main():
	a,b,x=MI()
	ans=(b-a)//x

	c=a+x*ans

	if b//x*x==-(-c//x)*x:
		ans+=1

	print(ans)






if __name__ == "__main__":
	main()

Solution (Python):
a, b, x = map(int, input().split())

if a == 0:
    pa = 0
else:
    pa = (a - 1) // x + 1

if b == 0:
    pb = 1
else:
    pb = b // x + 1

print(pb - pa)

Solution (Python):
a,b,x=map(int,input().split())
a1=a//x
b1=b//x
print(b1-a1 if a%x!=0 else b1-a1+1)

Solution (Python):
a,b,x = map(int,input().split())
mi = a//x
ma = b//x
if (a%x == 0):
    print(ma-mi+1)
else:
    print(ma-mi)

Solution (Python):
import sys

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

in_n = lambda: int(readline())
in_nn = lambda: map(int, readline().split())
in_nl = lambda: list(map(int, readline().split()))
in_na = lambda: map(int, read().split())
in_s = lambda: readline().rstrip().decode('utf-8')


def main():
    a, b, x = in_nn()
    ans = b // x
    if a == 0:
        ans += 1
    else:
        ans -= (a - 1) // x
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):

import sys

sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


sys.setrecursionlimit(10**7)








def run():
    a,b,x = map(int, input().split())
    ans = 0
    if a == 0:
        a += 1
        ans = 1
    ans += b // x - (a-1) // x
    print(ans)

if __name__ == "__main__":
    run()

Solution (Python):
import math

import queue
import bisect
from collections import deque,defaultdict
import heapq as hpq
from sys import stdin,setrecursionlimit


ipt = stdin.readline
setrecursionlimit(10**7)

def main():
    a,b,x = map(int,ipt().split())
    print(b//x-(a-1)//x)

    return None

if __name__ == '__main__':
    main()

Solution (Python):
a,b,x=map(int,input().split())

a-=1
p=a//x
p*=x

q=b//x
q+=1
q*=x

print((q-p)//x -1)

Solution (Python):
a,b,x = map(int,input().split())
b = b // x + 1
a = (a - 1) // x + 1
print(b - a)

Solution (Python):
a,b,x=map(int,input().split())
ans=(b//x)-(a//x)
if a%x==0:
    ans+=1
print(ans)

Solution (Python):
l = list(map(int,input().split()))
a = l[0]
b = l[1]
x = l[2]
if a%x == 0:
	print(b//x-a//x +1)
else:
	print(b//x-a//x)

Solution (Python):





a, b, x = map(int, input().split(' '))


_a = a // x + 1
_b = b // x + 1

if a % x == 0:
    _c = 1
else:
    _c = 0

ans = _b - _a + _c


print(ans)