/***************************************** 
****       Solution by SlavicG        ****
*****************************************/
 
#include <bits/stdc++.h>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm> 
#include <set>
#include <utility>
#include <queue>
#include <map>
#include <assert.h>
#include <stack>
using namespace std;
#define ll long long
#define forn(i,n) for(int i=0;i<n;++i)
#define MX 10000000001
#define pow2(a) ((a)*(a))
#define pb push_back
#define vair <vector<pair<int,int>>
#define vi vector<int>
#define mp make_pair
#define pf push_front
#define all(v) v.begin(), v.end()
#define endl "\n"
#define FAST std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define PI   3.14159265
#define _Yes printf("YES\n");
#define _No printf("NO\n");
 int longestIncreasingSubsequenceLenghtDP(int a[],int n){
    int dp[n],ans=0;
    for(int k = 0;k<n;k++){
        dp[k] = 1;
        for(int i = 0;i<k;i++){
            if(a[i] <= a[k]){
                dp[k] = max(dp[k],dp[i] + 1);
                ans = max(dp[k],ans);
            }
        }
    }
    return ans;
 }
int result[1000] = {0};
int factDP(int n) 
{
   if (n >= 0) {
      result[0] = 1;
      for (int i = 1; i <= n; ++i) {
         result[i] = i * result[i - 1];
      }
      return result[n];
   }
}
bool isPrime(ll n)
{
    if(n<2) return false;
    for(ll x = 2;x*x <=n;x++)
    {
        if(n%x == 0)return false;
    }
    return true;
}
vector<int> primeFactors(int n){
    vector<int> f;
    for(int x = 2;x*x<=n;x++){
        while(n%x==0){
            f.push_back(x);
            n/=x;
        }
    }
    if(n>1)f.push_back(n);
    return f;
}
bool isPerfectSquare(long double x) 
{   
  long double sr = sqrt(x); 
  return ((sr - floor(sr)) == 0); 
} 
int countDistinctCharsString(string s) {
    unordered_map<char, int> m; 
    for (int i = 0; i <(int)s.length(); i++) { 
        m[s[i]]++; 
    }
    return m.size(); 
}
class BST
{
private:

	struct node
	{
		int key;
		node* left;
		node* right;
	};
	node* root;
	void addLeafPrivate(int key,node* Ptr);
public:

	BST();
	node* createLeaf(int key);
	void addLeaf(int key);
};
BST::BST()
{
	root = NULL;
}
	BST::node* BST::createLeaf(int key)
	{
		node* neww = new node;
		neww->key = key;
		neww->left = NULL;
		neww->right = NULL;
		return neww;
	}
	void BST::addLeaf(int key)
	{
		addLeafPrivate(key,root);
	}
	void BST::addLeafPrivate(int key,node* Ptr)
	{
		if(root == NULL)
		{
			root = createLeaf(key);
		}else if(key < Ptr->key)
		{
			if(Ptr->left!=NULL)
			{
				addLeafPrivate(key,Ptr->left);
			}else{
				Ptr->left = createLeaf(key);
			}
		}
		else if(key > Ptr->key)
		{
			if(Ptr->right != NULL)
			{
				addLeafPrivate(key,Ptr->right);
			}else{
				Ptr->right = createLeaf(key);
			}
		}else 
		{
			//already been added
		}
	}
void sortStringByLenght(string s[], int n) 
{ 
    for (int i=1 ;i<n; i++) 
    { 
        string temp = s[i]; 
        int j = i - 1; 
        while (j >= 0 && temp.length() < s[j].length()) 
        { 
            s[j+1] = s[j]; 
            j--; 
        } 
        s[j+1] = temp; 
    } 
}
int isSubstring(string s1, string s2) 
{ 
    int M = s1.length(); 
    int N = s2.length(); 
    for (int i = 0; i <= N - M; i++) { 
        int j; 
        for (j = 0; j < M; j++) 
            if (s2[i + j] != s1[j]) 
                break; 
        if (j == M) 
            return true; 
    } 
    return false; 
} 
vector<int> primes;
void SieveOfEratosthenes(int n) 
{ 
    bool prime[n+1]; 
    memset(prime, true, sizeof(prime)); 
    for (int p=2; p*p<=n; p++) 
    {  
        if (prime[p] == true) 
        { 
            for (int i=p*p; i<=n; i += p) 
                prime[i] = false; 
        } 
    } 
    for (int p=2; p<=n; p++) 
       if (prime[p]) 
          primes.pb(p);
}
int main()
{
	int l,r,n;
	cin >> l >> r >> n;
	vector<int> v;
	for(int i = 1;i<=100;i++)
	{
		v.pb(n*i);
	}
	int cnt = 0;
	for(auto x : v)
	{
		if(x >= l && x <= r)
		{
			cnt++;
		}
	}
	cout << cnt << endl;
}

Measured memory_bytes: 3676