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):
a,b,x=map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
def f(n,d):
    if n==-1:
        return 0
    return n//d+1

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

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

Solution (Python):
a = list(map(int,input().split()))
print((a[1]//a[2]-(a[0]-1)//a[2]))

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

if a%x==0:
    nl=a
else:
    nl=a-a%x+x
if b%x==0:
    nr=b
else:
    nr=b-b%x

print((nr-nl)//x+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())
print(b//x-(a-1)//x)

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

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

i = b//x

j = (a - 1) // x 

print(i - j)

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

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

    
    

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())
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())
ta=(a-1)//x+1 if a>=0 else 0
tb=b//x+1 if b>=0 else 0
print(tb-ta)

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

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

Solution (Python):
def f(n,deno):
	if n == -1:
		return 0
	else:
		return n // deno + 1

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

Solution (Python):
import math
def f(n,deno):
	if n == -1:
		return 0
	else:
		return n // deno + 1

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

Solution (Python):
import bisect
import heapq
import itertools
import math
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18

A, B, X = list(map(Decimal, sys.stdin.readline().split()))

ans = math.floor(B / X) - math.ceil(A / X) + 1
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())

b_div = b // x
a_div = a // x + (-1 if a % x == 0 else 0)

print(b_div - a_div)

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

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())
print(b//x-(a-1)//x)

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

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

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

print(ans)

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

def resolve():
    A, B, X = map(int, input().split())
    print(f(X, B) - f(X, A - 1))
    
resolve()

Solution (Python):
p=input().rstrip().split(' ')
a=int(p[0])
b=int(p[1])
x=int(p[2])
d=(b//x) - (a//x)
if a%x==0:
    d+=1;
print(d)

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

a, b, x = nl()

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-1)//x)

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

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

print(B-preA)

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 = -((-1 * a)//x)
d = b // x
print(d - c + 1)

Solution (Python):


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

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

print(ans)

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

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

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-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())
m = (a-1)//x + 1
n = b//x
print(n-m+1)

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())
count = b//x - a//x
if a % x == 0:
    print(count+1)
else:
    print(count)

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//x
if a%x == 0:
    ans += 1
print(ans)

Solution (Python):
a, b, x = map(int, input().split())
print(int(b//x)-int((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())

ans = b//x - a//x

if a%x == 0:
    ans += 1

print(ans)

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())

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

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

b = b-(b%x)
a = a if a%x == 0 else a+(x-(a%x))

ans = max(0,(b//x)+1 -(a//x))

print(ans)

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

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

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

Solution (Python):
a, b, x = [int(s) for s in input().split()]
mod = a % x
if mod > 0:
    c = a + x - mod
else:
    c = a
if c <= b:
    print((b - c) // x + 1)
else:
    print(0)

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

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

if a % x == 0:
  ans += 1

print(ans)

Solution (Python):
import math
def main(a, b, x):
    b_floor = b // x

    if(a % x > 0):
        a_ceil = a // x + 1
    else:
        a_ceil = a // x

    print(b_floor - a_ceil + 1)

if __name__ == "__main__":
    a, b, x = [int(x) for x in input().split()]
    main(a, b, x)

def test1(capsys):
    inputs = [4, 8, 2]
    out = 3
    main(*inputs)
    captured = capsys.readouterr()    
    assert captured.out == str(out) + '\n'

def test3(capsys):
    inputs = [0, 5, 1]
    out = 6
    main(*inputs)
    captured = capsys.readouterr()    
    assert captured.out == str(out) + '\n'

def test4(capsys):
    inputs = [9, 9, 2]
    out = 0
    main(*inputs)
    captured = capsys.readouterr()    
    assert captured.out == str(out) + '\n'

def test5(capsys):
    inputs = [1, 1000000000000000000, 3]
    out = 333333333333333333
    main(*inputs)
    captured = capsys.readouterr()    
    assert captured.out == str(out) + '\n'

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())

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())


def func(n):
    if n < 0:
        return 0
    else:
        return n // x + 1


print(func(b) - func(a - 1))

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

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 inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [A, B, X] = list(map(lambda x: int(x), inputs[0].split()))
    num = (B // X) - ((A - 1) // X)
    return num


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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())
print(b//x-(a-1)//x)

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

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)

print(ans)

Solution (Python):
a,b,x = map(int,input().split())
a_ans = (a-1) // x
b_ans = b // x
print("{}".format(b_ans-a_ans))

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

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

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

Solution (Python):

import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 

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


print(ans)

Solution (Python):
a, b, x = map(int,input().split())
ans = max((b//x)-((a-1)//x), 0)
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 - 1) // x)

Solution (Python):


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

upper = b // x
lower = a // x

if(a % x == 0):
    lower -= 1

ans = int(upper - lower)

print(ans)

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

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

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def get(a,x):
    if a<0:
        return 0
    return a//x + 1

def solve():
    a,b,x = f()

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



solve()

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

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 = (a-1) // x
d = b // x

print(d-c)

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())
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())

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

Solution (Python):

"""
B - Between a and b ...
https://atcoder.jp/contests/abc048/tasks/abc048_b

"""
import sys


def solve(a, b, x):
    q, r = divmod(b, x)
    b -= r
    a = ((a + x - 1)//x) * x
    if a > b:
        return 0
    return (b - a)//x + 1


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


if __name__ == '__main__':
    main(sys.argv[1:])

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

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())
n=-(-a//x)*x
m=(b//x)*x
print((m-n)//x+1)

Solution (Python):
a, b, x = [int(i) for i in input().split()]
def f(n):
    return 0 if n < 0 else 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())
if a%x==0:
    k = 1
else:
    k = 0
print(b//x-a//x+k)

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

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

print(ans)

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

Solution (Python):
def numd(n,x):
    return (n+x) // x

a,b,x = map(int,input().split())
print(numd(b,x) - numd(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())
B = b//x + 1
if a >= 1:
    A = (a-1)//x + 1
else:
    A = 0
print(B-A)

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=0
if a==0:
    a+=1
    ans+=1
ans+=(b//x)-(a-1)//x
print(ans)

Solution (Python):


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

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

print(ans)

Solution (Python):
A, B, X = list(map(int, input().split()))
result = B // X - A // X if A % X != 0 else B // X - A // X + 1
print(result)

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

m=b//x
n=a//x
k=a%x

if k==0:
  print(m-n+1)
else:
  print(m-n)

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):
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())
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())
if a%x==0:
    k=1
else:
    k=0
print(b//x - a//x + k)

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

Solution (Python):
a,b,x = [int(x) for x in input().split()]
cnt = 0
if(a%x==0): cnt += 1
cnt += b//x - a//x
print(cnt)

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,c = list(map(int, input().split()))

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

Solution (Python):



a,b,c = list(map(int, input().split()))

print((b//c)+(a-1)//c*-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())
ans = b//x - (a-1)//x

print(ans)

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

Solution (Python):
A,B,X = map(int,input().split())
print(B // X - A // X + (1 if A % X == 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())

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

Solution (Python):
a, b, x = [int(i) for i in 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())
if a%x == 0 and b%x == 0:
  ans = b//x -a//x +1
elif a%x != 0 and b%x == 0:
  ans = b//x -a//x
elif a%x == 0 and b%x != 0:
  ans = b//x -a//x +1
else:
  ans = b//x -a//x
print(ans)

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

if a % x == 0:
    na = (a // x) - 1
else:
    na = (a // 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())
a=(a-1)//x
b//=x
print(b-a)

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

def calc(n):
    if n >= 0:
        num = n // x + 1
    else:
        num = 0
    return num

ans = calc(b) - calc(a-1)
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-1)//x  )

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

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

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

    print(result)

if __name__ == "__main__":
    main()

Solution (Python):
v = input().split(" ")

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

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

print(max(fb-fa, 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())
A=a//x
B=b//x
if a%x!=0:
    print(B-A)
else:
    print(B-A+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))

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

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

lower = (a+x-1) // x
upper = b // x

if lower < upper:
    ans = upper - lower + 1

elif lower == upper:
    ans = 1

else:
    ans = 0

print(ans)

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

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

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

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

print(cnt)

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

Solution (Python):

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

Solution (Python):
a, b, c = (int(_) for _ in input().split())  
print(b//c-(a-1)//c)

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())

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())
if a != 0:
    print(b//x - (a-1)//x)
elif a == 0:
    print(b//x + 1)

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

Solution (Python):
from decimal import Decimal

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


a_deci = Decimal(a)
b_deci = Decimal(b)
x_deci = Decimal(x)

count = int(b_deci/x_deci)
count = count -int(a_deci/x_deci)
if a_deci%x_deci==0:
    count = count+1


print(count)

Solution (Python):


def solve(a, b, x):
    print(b//x - (a-1)//x) 

if __name__ == '__main__':
    a, b, x = map(int, input().split())
    
    solve(a, b, x)

Solution (Python):
def solve():
    a,b,x = [int(_) for _ in raw_input().split()]
    count = b/x - (a-1)/x
    print str(count)

if __name__ == '__main__':
    solve()

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())
print(b//x - (a-1)//x)

Solution (Python):


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

def submit():
    
    def divide_ceil(n, m):
        if n % m == 0:
            return n // m
        return n // m + 1

    
    def divide_floor(n, m):
        return n // m

    a, b, x = read_input()

    a_coef = divide_ceil(a, x)
    b_coef = divide_floor(b, x)

    print(b_coef - a_coef + 1)


if __name__ == '__main__':
    submit()

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

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

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

Solution (Python):

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

def f(n):
    if n < 0:
        return 0;
    return n // x + 1


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

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

big = b // x + 1
small = (a - 1) // x + 1

ans = big - small
if ans < 0:
    ans = 0

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())
print(b//x - (a-1)//x)

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

rema=a%x
remb=b%x

y=(a-rema)//x
z=(b-remb)//x

if a%x==0:
    print(z-y+1)
else:
    print(z-y)

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())


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

Solution (Python):


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

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

print(j-i)

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

Solution (Python):
a, b, x = [int(item) for item in input().split()]
upper = b//x
if a == 0:
    lower = 0
    upper += 1
else:
    lower = (a-1)//x
print(upper - lower)

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

Solution (Python):
def main():
    input = sys.stdin.readline
    try:
        a, b, x = map(int, input().split())
        def fn(n):
            if n == -1:
                return 0
            else:
                return n // x + 1
        print(fn(b) - fn(a-1))

    finally:
        input = None

import sys; sys.setrecursionlimit(50000)
if __name__ == "__main__":
    main()

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

Solution (Python):
import sys

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

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


if __name__ == '__main__':
    print(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())
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())
print(b//x-(a-1)//x)

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

Solution (Python):
import math
a,b,x=map(int,input().split())
if a%x>0 and b//x-a//x==0:
    print(0)
else:
    print((b//x)-math.ceil(a/x)+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())
c = b//x - (a-1)//x
print(c)

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

check_a = (a-1) // x

ans = check_b - check_a
print(ans)

Solution (Python):

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

all_count = 0
dev = 0
if b > 0:
    all_count = b // x

if a > 0:
    dev = (a-1) // x
else:
    dev = -1
print(all_count - dev)

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

c = a//x if a % x != 0 else a//x-1
ans = b//x-c

print(ans)

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

a, b, x = MAP()

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

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(' '))
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() )

cnt = 0

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

print(end - start)

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

count = 0

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

if b >= a + (x - a % x):
  p = b - a - (x - a % x)
  count += p // x + 1

print(count)

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())
def f(a,x):
    if a == -1:
        return 0
    else:
        return a//x + 1
print(f(b,x) - f(a-1,x))

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

fb = b//x
fa1 = (a-1)//x
f = fb - fa1
print(f)

Solution (Python):
a, b, c = map(int, input().split())
print(b//c - (a-1)//c if a !=0 else b//c+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())
ans = max((b//x) - ((a-1)//x), 0)
print(ans)

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

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

Solution (Python):
def between_a_and_b(a: int, b: int, x: int) -> int:
    return b // x - (a-1) // x


if __name__ == "__main__":
    a, b, x = map(int, input().split())
    ans = between_a_and_b(a, b, 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//x
if a%x == 0:
    ans += 1

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-a) // x
if a!= 0:
  ans = (b // x + 1) - ((a-1) // x + 1)
else:
  ans = (b // x + 1)
  
print(ans)

Solution (Python):
from functools import reduce

def main():
    
    
    
    
    
    
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    
    a, b, x = (int(_) for _ in input().split())
    a_d = a//x
    b_d = b//x
    ans = b_d - a_d
    if(a%x == 0):
        ans += 1
    print(ans)
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())
print(b//x-(a-1)//x)

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

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

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

print(ans)

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

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())
print(b//x - (a-1)//x)

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

Solution (Python):

from collections import defaultdict
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


"""
s = LS()[1]
print("A"+s[0]+"C")
"""

a,b,x = LI()
print(b//x-(a-1)//x)

"""
n,x = LI()
a = LI()
ans = 0
for i in range(n-1):
    if a[i]+a[i+1] > x:
        ans += a[i+1]+a[i]-x
        if x > a[i]:
            a[i+1] = x-a[i]
        else:
            a[i+1] = 0
            a[i] = x
print(ans)
"""


"""
s = S()
l = len(s)
k = (s[0] == s[-1])
if (l%2)^k:
    print("First")
else:
    print("Second")
"""

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

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

bn = b//x+1
an = (a-1)//x+1 if a > 0 else 0
print(bn - an)

Solution (Python):
def func(n):
    if n >= 0:
        return n // x + 1
    else:
        return 0

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

print(func(b)-func(a-1))

Solution (Python):
def count_multiple(n, x):
    return n // x


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

Solution (Python):

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

if a % x != 0:
    A = (a // x + 1)
else:
    A = a // x

B = b // x

if B - A >= 0:
    print(B - A + 1)
else:
    print(0)

Solution (Python):
a,b,x = [int(i) for i in input().split(" ")]
answer = 0
if (b-a)<x:
    answer+=(a%x==0)or(b%x==0)
elif a==0:
    answer+=b//x+1
else:
    answer+=b//x-a//x+(a%x==0)

print(int(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 = map(int,input().split())
print(b//x-(a-1)//x)

Solution (Python):
from sys import stdin
a, b, x = [int(x) for x in stdin.readline().rstrip().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())

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

print(res)

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


if __name__ == "__main__":
    main()

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


def func(n, x):
    if n == -1:
        return 0
    return n//x + 1


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

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

Solution (Python):
a, b, x = map(int, input().split())
def f(n, x):
    if n == -1:
        return 0
    return n//x + 1
print(f(b, x) - f(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=[int(i) for i in input().split()]
print(b//x-a//x+(a%x==0))