#include <iostream>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <tuple>
#include <climits>
#include <stdlib.h>
#include <queue>
#include <stack>

#define mp make_pair
#define pb push_back
#define forn(n) for(long long i=0;i<n;++i)
#define fast ios::sync_with_stdio(false), cin.tie(0)

#define ll long long
#define ull unsigned long long
#define mod 1000000007
typedef long double ld;
using namespace std;


bool isPrime(ll n)
{
    for(ll i=2;i*i<=n;i++)
    {
        if(n%i==0)
        return false;
    }
    return true;
}

vector<ll> sieve(ll n)
{
	vector<ll> a(n+1,0);
	for(ll i=3;i<=n;i+=2)
	a[i]=1;
	for(ll i=3;i<=n;i+=2)
	{
       if(a[i]==1)
	   {
		   for(ll j=i*2;j<=n;j+=i)
		   a[j]=0;
	   }
	}
	a[2]=1;
	a[1]=a[0]=0;
	return a;
}
ll reverse(ll n)
{
	ll s=0;
	while(n>0)
	{
       ll t=n%10;
	   s=s*10+t;
	   n/=10;
	}
	return s;
}
int count_setbits(int N)

{ int cnt=0;

while(N>0)

{

cnt+=(N&1);

N=N>>1;

}

return cnt;

}
ll power(ll x, ll y)  
{  
    int res = 1;     // Initialize result  
  
    x = x % mod; // Update x if it is more than or  
                // equal to p 
   
    if (x == 0) return 0; // In case x is divisible by p; 
  
    while (y > 0)  
    {  
        // If y is odd, multiply x with result  
        if (y & 1)  
            res = (res*x) % mod;  
  
        // y must be even now  
        y = y>>1; // y = y/2  
        x = (x*x) % mod;  
    }  
    return res;  
}  
void computeLPSArray(string pat,vector<ll> &lps,ll M)
{
   ll len=0;
   lps[0]=0;lps[1]=0;
   ll i=1;
   while(i<M)
   {
       if(pat[i]==pat[len])
       {
           len++;
           lps[i]=len;
           i++;
       }
       else
       {
           if(len==0)
           {
               lps[i]=0;
               i++;
           }
           else
           {
               len=lps[len-1];
           }
           
       }
       
   }
}
vector<ll> kmp(string &pat,string &txt)
{
    vector<ll> ret;
    ll M=pat.size();
    ll N=txt.size();
    //cout<<M<<" "<<N<<"\n";
    vector<ll> lps(M);

    computeLPSArray(pat,lps,M);
    
    cout<<"\n";
    ll i=0;// for txt
    ll j=0;// for pat
    while(i<N)
    {
        if(pat[j]==txt[i])
        {
            i++;j++;
        }
        if(j==M)
        {
            ret.push_back(i-j);
            j=lps[j-1];
        }

        else if(i<N && pat[j]!=txt[i])
        {
            if(j!=0)
            j=lps[j-1];
            else
            {
                i+=1;
            }
            
        }
    }
    return ret;


}


void BellmanFord(vector< vector<ll> > &graph, int V, int E, int src) 
{ 
    // Initialize distance of all vertices as infinite. 
    int dis[V]; 
    for (int i = 0; i < V; i++) 
        dis[i] = INT_MAX; 
  
    // initialize distance of source as 0 
    dis[src] = 0; 
  
    // Relax all edges |V| - 1 times. A simple 
    // shortest path from src to any other 
    // vertex can have at-most |V| - 1 edges 
    for (int i = 0; i < V - 1; i++) { 
  
        for (int j = 0; j < E; j++) { 
            if (dis[graph[j][0]] + graph[j][2] < 
                               dis[graph[j][1]]) 
                dis[graph[j][1]] =  
                  dis[graph[j][0]] + graph[j][2]; 
        } 
    } 
  
    // check for negative-weight cycles. 
    // The above step guarantees shortest 
    // distances if graph doesn't contain 
    // negative weight cycle.  If we get a 
    // shorter path, then there is a cycle. 
    for (int i = 0; i < E; i++) { 
        int x = graph[i][0]; 
        int y = graph[i][1]; 
        int weight = graph[i][2]; 
        if (dis[x] != INT_MAX && 
                   dis[x] + weight < dis[y]) 
            cout << "Graph contains negative"
                    " weight cycle"
                 << endl; 
    } 
  
    
} 

/* 

to find the farthest node from root using dfs and its distance from root, we have to just 
change the dfs function a bit

void dfs(ll node,ll dis)
{
    vis[node]=true;
    // for any processing of the node, like printing it, please do it here
    if(dis>maxd)
    {
        maxd=dis;maxnode=node;
    }


    for(ll i=0;i<adj[node].size();i++)
    {
        ll child=adj[node][i];
        if(!vis[child])
        dfs(child,dis+1);

    }
}

*/
void radix_sort(vector< pair< pair<ll,ll>,ll> > &a)
{
    {
   ll n=a.size();
   vector<ll> cnt(n);
   for(auto x:a)
   {
       cnt[x.first.second]++;
   }
   vector< pair< pair<ll,ll>,ll> > a_new(n);
   vector<ll> pos(n);
   pos[0]=0;
   for(ll i=1;i<n;i++)
   pos[i]=pos[i-1]+cnt[i-1];
   for(auto x:a)
   {
       ll i=x.first.second;
       a_new[pos[i]]=x;
       pos[i]++;
   }
   a=a_new;
    }
    {
   ll n=a.size();
   vector<ll> cnt(n);
   for(auto x:a)
   {
       cnt[x.first.first]++;
   }
   vector< pair< pair<ll,ll>,ll> > a_new(n);
   vector<ll> pos(n);
   pos[0]=0;
   for(ll i=1;i<n;i++)
   pos[i]=pos[i-1]+cnt[i-1];
   for(auto x:a)
   {
       ll i=x.first.first;
       a_new[pos[i]]=x;
       pos[i]++;
   }
    
   a=a_new;
    }



}
vector<ll> suffix_array(string s)
{
   s+="$";
   ll n=s.size();
   vector<ll> p(n),c(n); // p is position array, c is equivalence array

   // if k==0
   vector< pair<char,ll> > a(n);
   for(ll i=0;i<n;i++)
   a[i]=make_pair(s[i],i);
   sort(a.begin(),a.end());
   for(ll i=0;i<n;i++)
   {
       p[i]=a[i].second;
   }
   c[p[0]]=0;
   for(ll i=1;i<n;i++)
   {
       if(a[i].first==a[i-1].first)
       c[p[i]]=c[p[i-1]];
       else
       {
           c[p[i]]=c[p[i-1]]+1;
       }
       
   }

   ll k=0;
   while((1<<k)<n)
   {
      vector< pair< pair<ll,ll>,ll> > a(n); // first pair will be equivalence class, second number of pair is index
      for(ll i=0; i<n;i++)
      {
          a[i]=make_pair(make_pair(c[i],c[(i+(1<<k))%n]),i);
      }
      radix_sort(a);
      for(ll i=0;i<n;i++)
   {
       p[i]=a[i].second;
   }
   c[p[0]]=0;
   for(ll i=1;i<n;i++)
   {
       if(a[i].first==a[i-1].first)
       c[p[i]]=c[p[i-1]];
       else
       {
           c[p[i]]=c[p[i-1]]+1;
       }
       
   }
k++;
   }
   return p;



}

bool vis[1000001];
ll dist[1000001];
int color[1000001];


vector<ll> adj[1000001];
vector<ll> edges;
ll maxd,maxnode;


void dfs(ll node)
{
    stack<ll> s;
    vis[node]=true;
    s.push(node);
    // for any processing of the node, like printing it, please do it here
    dist[node]=0;
   while(!s.empty())
   {
      ll curr=s.top();
      s.pop();
      for(ll i:adj[curr])
      {
          if(!vis[i])
        {
            s.push(i);
            vis[i]=1;
            dist[i]=dist[curr]+1;
        }
      }
     
   }  
}
void bfs(ll node)
{
    queue<ll> q;
    q.push(node);
    vis[node]=1;
    dist[node]=0;

    while(!q.empty())
    {
        ll curr=q.front();
        q.pop();

        for(ll i:adj[curr])
        {
            if(vis[i]==0)
            {
                q.push(i);
                dist[i]=dist[curr]+1;
                vis[i]=1;
            }
        }
    }
}

bool dfs_bipartite_check(ll node,int c)
{
    vis[node]=1;
    color[node]=c;
    for(ll i:adj[node])
    {
        if(vis[i]==0)
        {
           if(dfs_bipartite_check(i,c^1)==false) // if not visited, dfs call
           return false;
        }
        else
        {
            if(color[node]==color[i]) // if visited then check equality of colors
            return false;
        }
        
    }
    return true;
}

ll subsize[1000001];
ll subtree_size(ll node)
{
    vis[node]=1;
    ll curr_size=1;
    for(ll i=0;i<adj[node].size();i++)
    {
        ll child=adj[node][i];
        if(vis[child]==0)
        {
            curr_size+=subtree_size(child); // dfs call when child is not visited
        }

    }
    subsize[node]=curr_size;    // update size of subtree of the current node
    return curr_size;  // return size of subtree of the current node
    
}



bool cycle_detect(ll node,ll parent)
{
    vis[node]=1;
    for(ll child:adj[node])
    {
        if(vis[child]==0) {          // if not visited, make dfs call, and return true if dfs returns true
        if(cycle_detect(child,node))
        return true;
        }
        else
        {
            if(child!=parent)         // check if visited child is parent of current node or ancestor of current node
            return true; // returns true if child is ancestor and not parent of current node
        }
        
    }
    return false;
}

// for graph questions having multiple test cases, dont forget to clear adjacency list and clear visited array 
/* Just add these lines in each testcases

       for(ll i=1;i<=nodes;i++)
       adj[i].clear(),vis[i]=0;

*/

ull countBits(ull number) 
{       
      // log function in base 2  
      // take only integer part 
      return (ull)log2(number)+1; 
} 



int main()
{
  fast;
 ll n;cin>>n;if(n%1000==0)cout<<0<<"\n";
 else
 {
     cout<<((n/1000+1)*1000)-n<<"\n";
 }
  
  
  

     

     

  






  



}


Measured memory_bytes: 26656