#include<bits/stdc++.h>
		using namespace std;
		#define sz(x) (int)(x).size()
		#define int long long int
		#define loop(i,a,b) for(int i=a;i<b;i++)
		#define scan(arr,n) for (int i = 0; i < n; ++i) cin >> arr[i]
		#define vi vector<int>
		#define si set<int>
		#define pii pair <int, int>
		#define sii set<pii>
		#define vii vector<pii>
		#define mii map <int, int>
		#define pb push_back
		#define all(aa) aa.begin(), aa.end()
		#define faster ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
		//Constants
		const int mod = 1000000007; /* 1e9 + 7*/
		const int MAXN = 1000005; /*1e6 +5 */
		
		int spf[1000009]; // stores the smallest prime factor of a number
		const int siz=100001;
		vi adj[siz];
			
			int depth[siz] ;
		int diameter=0;
		//	int n,a,b,da,db;
		void print(vi v)
		{
			for(auto x:v)
			cout<<x<<" ";
			cout<<endl;
		}
		 int power(int x, unsigned int y, int p)  
		{  
			int res = 1;     // Initialize result  
		  
			x = x % p; // Update x if it is more than or  
						// equal to p how to find distance between two nodes in a generic tree considering one of the two nodes as a root
		   
			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) % p;  
		  
				// y must be even now  
				y = y>>1; // y = y/2  
				x = (x*x) % p;  
			}  
			return res;  
		}  
		// to find diameter of a tree and distance between two nodes in a tree. 
		//dist between a and b is depth[b] , Initialise depth[a]=0 for each test case.
		int dfs(int u,int par) 
		{
			int len=0;
			for(auto x:adj[u])
			{
				if(x!=par)
				{
					depth[x]=depth[u]+1;
					int cur=1+ dfs(x,u);
					diameter=max(diameter,cur+len);
					len=max(len,cur);
				}
			}
			return len;
		}
		
		int gcdExtended(int a, int b, int *x, int *y) 
{ 
    // Base Case 
    if (a == 0) 
    { 
        *x = 0, *y = 1; 
        return b; 
    } 
  
    int x1, y1; // To store results of recursive call 
    int gcd = gcdExtended(b%a, a, &x1, &y1); 
  
    // Update x and y using results of recursive 
    // call 
    *x = y1 - (b/a) * x1; 
    *y = x1; 
  
    return gcd; 
} 


		int modInverse(int b, int m) 
{ 
    int x, y; // used in extended GCD algorithm 
    int g = gcdExtended(b, m, &x, &y); 
  
    // Return -1 if b and m are not co-prime 
    if (g != 1) 
        return -1; 
  
    // m is added to handle negative x 
    return (x%m + m) % m; 
} 

int modDivide(int a, int b, int m) 
{ 
    a = a % m; 
    int inv = modInverse(b, m); 
    return (inv * a) % m; 
} 

int fac[100001]={0};

		void fact()
		{
			fac[0]=1;
			for(int i=1;i<=100000;i++)
			fac[i]=(fac[i-1]%mod * i%mod)%mod;
		}
		int bino(int n , int r)
		{
			
			/*int num=1;
			for(int i=1;i<=n;i++)
				num=(num%mod * i%mod)%mod;
			int den1 =1 , den2=1;
			for(int i=1;i<=n-r;i++)
				den1=(den1%mod * i%mod)%mod;
			for(int i=1;i<=r;i++)
				den2=(den2%mod * i%mod)%mod;
				
				//num=numerator den=denominator
				 */
				 int num=1;
				 num=fac[n];
				 int den1=fac[n-r];
				 int den2=fac[r];
				 int den=(den1%mod * den2%mod)%mod;
			int val=modDivide(num, den, mod);
				 return val; 
		}
		
		void solve()
		{
			int x;cin>>x;
			cout<<(x^1)<<endl;
			
		}


		 
		int32_t main()
		{
			fact();
			faster;int t=1;
			//cin>>t;
			while(t--)
				solve();		 
			return 0;
		}


Measured memory_bytes: 6776