import java.util.*;
import java.io.*;
public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); 
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st; 
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;
	
	static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } 
	
	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } 

	static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } 

	static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } 

	static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }
	
	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }
	
	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	}
	
	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];
	  public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	}
	static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	}

	  public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
}
	  }

 import java.util.*; util.* java import java.io.*; io.* java public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); 
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st; 
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;
	
	static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } 
	
	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } 

	static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } 

	static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } 

	static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }
	
	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }
	
	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	}
	
	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];
	  public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	}
	static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	}

	  public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
}
	  } Main ///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); br new BufferedReader(new
            InputStreamReader(System.in)) static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); bw new BufferedWriter(new OutputStreamWriter(System.out)) static StringTokenizer st; st static byte[] buffer =new byte[10*1024]; buffer new byte[10*1024] 10*1024 10 1024 static int index; index static InputStream input_stream= System.in; input_stream System.in System System.in static int total; total static boolean al[]=new boolean[1100000]; al new boolean[1100000] 1100000 public static int count=0; count 0 static boolean com[]=new boolean[120000]; com new boolean[120000] 120000 static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } ns { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } StringBuilder sb = new StringBuilder(); sb new StringBuilder() int n = read(); n read() read while (isWhiteSpace(n))
             n = read(); isWhiteSpace(n) isWhiteSpace n n = read() n read() read while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         } !isWhiteSpace(n) isWhiteSpace(n) isWhiteSpace n {
             sb.append((char)n);
             n = read();
         } sb.append((char)n) sb.append sb (char)n n = read() n read() read return sb.toString(); sb.toString() sb.toString sb static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	} read {
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	} if(total<0)
            throw new InputMismatchException(); total<0 total 0 throw new InputMismatchException(); new InputMismatchException() if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        } index>=total index total {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        } index=0 index 0 total= input_stream.read(buffer) total input_stream.read(buffer) input_stream.read input_stream buffer if(total<=0)
                return -1; total<=0 total 0 return -1; -1 1 return buffer[index++]; buffer[index++] buffer index++ index static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } ni { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } int integer=0; integer 0 int n= read(); n read() read while(isWhiteSpace(n))
            n= read(); isWhiteSpace(n) isWhiteSpace n n= read() n read() read int neg=1; neg 1 if(n=='-') {
            neg=-1;
            n= read();
        } n=='-' n '-' {
            neg=-1;
            n= read();
        } neg=-1 neg -1 1 n= read() n read() read while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        } !isWhiteSpace(n) isWhiteSpace(n) isWhiteSpace n {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        } if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException(); n>='0'&&n<='9' n>='0' n '0' n<='9' n '9' {
                integer*=10;
                integer+=n-'0';
                n= read();
            } integer*=10 integer 10 integer+=n-'0' integer n-'0' n '0' n= read() n read() read throw new InputMismatchException(); new InputMismatchException() return neg*integer; neg*integer neg integer static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } nl { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } long number=0; number 0 int n= read(); n read() read while(isWhiteSpace(n))
            n= read(); isWhiteSpace(n) isWhiteSpace n n= read() n read() read long neg=1l; neg 1l if(n=='-') {
            neg=-1l;
            n= read();
        } n=='-' n '-' {
            neg=-1l;
            n= read();
        } neg=-1l neg -1l 1l n= read() n read() read while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        } !isWhiteSpace(n) isWhiteSpace(n) isWhiteSpace n {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        } if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException(); n>='0'&&n<='9' n>='0' n '0' n<='9' n '9' {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            } number*=10l number 10l number+=(long)(n-'0') number (long)(n-'0') n '0' n= read() n read() read throw new InputMismatchException(); new InputMismatchException() return neg*number; neg*number neg number static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } nd { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } double doub=0; doub 0 int n= read(); n read() read while(isWhiteSpace(n))
            n= read(); isWhiteSpace(n) isWhiteSpace n n= read() n read() read int neg=1; neg 1 if(n=='-') {
            neg=-1;
            n= read();
        } n=='-' n '-' {
            neg=-1;
            n= read();
        } neg=-1 neg -1 1 n= read() n read() read while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        } !isWhiteSpace(n)&&n!='.' !isWhiteSpace(n) isWhiteSpace(n) isWhiteSpace n n!='.' n '.' {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        } if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException(); n>='0'&&n<='9' n>='0' n '0' n<='9' n '9' {
                doub*=10;
                doub+=n-'0';
                n= read();
            } doub*=10 doub 10 doub+=n-'0' doub n-'0' n '0' n= read() n read() read throw new InputMismatchException(); new InputMismatchException() if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        } n=='.' n '.' {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        } n= read() n read() read double temp=1; temp 1 while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            } !isWhiteSpace(n) isWhiteSpace(n) isWhiteSpace n {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            } if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException(); n>='0'&&n<='9' n>='0' n '0' n<='9' n '9' {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                } temp/=10 temp 10 doub+=(n-'0')*temp doub (n-'0')*temp (n-'0') n '0' temp n= read() n read() read throw new InputMismatchException(); new InputMismatchException() return doub*neg; doub*neg doub neg static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    } nsl { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    } String str = ""; str "" try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } catch (IOException e) 
        { 
            e.printStackTrace(); 
        } IOException e { 
            e.printStackTrace(); 
        } e.printStackTrace() e.printStackTrace e { 
            str = br.readLine(); 
        } str = br.readLine() str br.readLine() br.readLine br return str; str static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    } isWhiteSpace {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    } if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true; n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1 n=='\t' n=='\r' n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1 n==' ' n ' ' n=='\n' n '\n' n=='\r' n '\r' n=='\t' n '\t' n==-1 n -1 1 return true; true return false; false int n n ///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    } p {
        bw.append(str);
    } bw.append(str) bw.append bw str String str str static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    } pn {
        p(str);
        bw.append("\n");
    } p(str) p str bw.append("\n") bw.append bw "\n" String str str static public void close()throws IOException {
        bw.close();
    } close {
        bw.close();
    } bw.close() bw.close bw static public void flush()throws IOException {
        bw.flush();
    } flush {
        bw.flush();
    } bw.flush() bw.flush bw ///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	} loopi {
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	} for(int i=0;i<n;i++)
			arr[i]=ni(); int i=0; int i=0; i 0 i<n i n i++ i++ i arr[i]=ni(); arr[i]=ni() arr[i] arr i ni() ni return arr; arr int[] arr arr int n n public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	} loops {
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	} for(int i=0;i<n;i++)
			arr[i]=ns(); int i=0; int i=0; i 0 i<n i n i++ i++ i arr[i]=ns(); arr[i]=ns() arr[i] arr i ns() ns return arr; arr String[] arr arr int n n public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	} loopl {
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	} for(int i=0;i<n;i++)
			arr[i]=ni(); int i=0; int i=0; i 0 i<n i n i++ i++ i arr[i]=ni(); arr[i]=ni() arr[i] arr i ni() ni return arr; arr long[] arr arr int n n public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  } prime {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  } int n=1000000; n 1000000 for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    } int i=2; int i=2; i 2 i*i<=n i*i i i n i++ i++ i {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    } {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    } if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      } !al[i] al[i] al i {
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      } for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      } int j=i*2; int j=i*2; j i*2 i 2 j<=n j n j+=i j+=i j i {
	        al[j]=true;
	      } {
	        al[j]=true;
	      } al[j]=true al[j] al j true public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	} dfs {
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	} if (visited[n]) {
			if (!com[n])
				count++;
			return;
		} visited[n] visited n {
			if (!com[n])
				count++;
			return;
		} if (!com[n])
				count++; !com[n] com[n] com n count++ count return; visited[n] = true visited[n] visited n true for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		} int i al[n] al n {
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		} {
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		} if (i!=p)
				dfs(n,i,al,visited); i!=p i p dfs(n,i,al,visited) dfs n i al visited com[n]=true com[n] com n true int p p int n n ArrayList<Integer> al[] al Boolean visited[] visited static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	} mex {
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	} int min=Integer.MAX_VALUE; min Integer.MAX_VALUE Integer Integer.MAX_VALUE if(arr[0]>0)
			return 0; arr[0]>0 arr[0] arr 0 0 return 0; 0 for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		} int i=start; int i=start; i start i<end-1 i end-1 end 1 i++ i++ i {
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		} {
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		} System.out.println(i) System.out.println System.out System System.out i if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			} arr[i+1]==arr[i]+1||arr[i+1]==arr[i] arr[i+1]==arr[i]+1 arr[i+1] arr i+1 i 1 arr[i]+1 arr[i] arr i 1 arr[i+1]==arr[i] arr[i+1] arr i+1 i 1 arr[i] arr i {
				System.out.println("equal");
				continue;
			} System.out.println("equal") System.out.println System.out System System.out "equal" continue; {
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			} min=arr[i]+1 min arr[i]+1 arr[i] arr i 1 System.out.println(arr[i]+1+" "+min) System.out.println System.out System System.out arr[i]+1+" "+min " " arr[i]+1+" "+min arr[i] arr i 1 " " min break; return min; min int start start int end end int arr[] arr public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
} main {
		int temp=ni();
		pn((temp^1)+"");
		flush();
} int temp=ni(); temp ni() ni pn((temp^1)+"") pn (temp^1)+"" (temp^1) temp 1 "" flush() flush String args[] args static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	} Node int h; h int w; w Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		} Node {
			this.h=h;
			this.w=w;
		} this.h=h this.h this this.h h this.w=w this.w this this.w w int h h int w w public static String toString(Node n)
		{
			return n.h+" "+n.w;
		} toString {
			return n.h+" "+n.w;
		} return n.h+" "+n.w; n.h+" "+n.w n.h+" "+n.w n.h n n.h " " n.w n n.w Node n n @Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		} compareTo {
			
				return this.h-n.h;
		} return this.h-n.h; this.h-n.h this.h this this.h n.h n n.h Node n n Comparable public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); 
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st; 
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;
	
	static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } 
	
	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } 

	static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } 

	static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } 

	static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }
	
	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }
	
	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	}
	
	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];
	  public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	}
	static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	}

	  public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
}
	  } public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); 
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st; 
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;
	
	static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } 
	
	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } 

	static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } 

	static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } 

	static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }
	
	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }
	
	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	}
	
	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];
	  public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	}
	static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	}

	  public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
}
	  } Main
import java.util.*;
import java.io.*;
public class Main {
///////----------------input----------------//////
	static BufferedReader br= new BufferedReader(new
            InputStreamReader(System.in)); 
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static StringTokenizer st; 
	static byte[] buffer =new byte[10*1024];
	static int index;
    static InputStream input_stream= System.in;
    static int total;
	
	static String ns() throws IOException
    { 
		 StringBuilder sb = new StringBuilder();
         int n = read();
         while (isWhiteSpace(n))
             n = read();
         while (!isWhiteSpace(n)) {
             sb.append((char)n);
             n = read();
         }
         return sb.toString();
    } 
	
	static int read() throws IOException
	{
		if(total<0)
            throw new InputMismatchException();
        if(index>=total) {
            index=0;
            total= input_stream.read(buffer);
            if(total<=0)
                return -1;
        }
        return buffer[index++];
	}
	static int ni() throws IOException
    { 
		int integer=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                integer*=10;
                integer+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*integer;
    } 

	static long nl() throws IOException
    { 
		long number=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        long neg=1l;
        if(n=='-') {
            neg=-1l;
            n= read();
        }
        while(!isWhiteSpace(n)) {
            if(n>='0'&&n<='9') {
                number*=10l;
                number+=(long)(n-'0');
                n= read();
            }
            else throw new InputMismatchException();
        }
        return neg*number;
    } 

	static double nd() throws IOException
    { 
		double doub=0;
        int n= read();
        while(isWhiteSpace(n))
            n= read();
        int neg=1;
        if(n=='-') {
            neg=-1;
            n= read();
        }
        while(!isWhiteSpace(n)&&n!='.') {
            if(n>='0'&&n<='9') {
                doub*=10;
                doub+=n-'0';
                n= read();
            }
            else throw new InputMismatchException();
        }

        if(n=='.') {
            n= read();
            double temp=1;
            while(!isWhiteSpace(n)) {
                if(n>='0'&&n<='9') {
                    temp/=10;
                    doub+=(n-'0')*temp;
                    n= read();
                }
                else throw new InputMismatchException();
            }
        }
        return doub*neg;
    } 

	static String nsl() throws IOException
    { 
        String str = ""; 
        try
        { 
            str = br.readLine(); 
        } 
        catch (IOException e) 
        { 
            e.printStackTrace(); 
        } 
        return str; 
    }
	static boolean isWhiteSpace(int n) {
        if(n==' '|| n=='\n'|| n=='\r'|| n=='\t'|| n==-1)
            return true;
        return false;
    }
	
	///////-------------output-----------------//////
	static public void p(String str) throws IOException {
        bw.append(str);
    }
	static public void pn(String str) throws IOException {
        p(str);
        bw.append("\n");
    }
	static public void close()throws IOException {
        bw.close();
    }
	static public void flush()throws IOException {
        bw.flush();
    }
	
	///////----------THE FAST I/O METHODS ENDS HERE -----------/////////////
	///////////////////////////////////////////////////////////////////////
	///////////////////////// FOR INPUT LOOP//////////////////////////////
	public static  int[] loopi(int[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	public static  String[] loops(String[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ns();
		
		return arr;
	}
	public static  long[] loopl(long[] arr,int n) throws IOException
	{
		for(int i=0;i<n;i++)
			arr[i]=ni();
		
		return arr;
	}
	/////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////
	static class Node implements Comparable<Node>{
		int h;
		int w;
		Node(int h,int w)
		{
			this.h=h;
			this.w=w;
		}
		public static String toString(Node n)
		{
			return n.h+" "+n.w;
		}
		@Override
		public int compareTo(Node n)
		{
			
				return this.h-n.h;
		}
	
	}
	
	static boolean al[]=new boolean[1100000];
	  public static void prime()
	  {
	    int n=1000000;
	   
	    for(int i=2;i*i<=n;i++)
	    {
	      if(!al[i]){
	      for(int j=i*2;j<=n;j+=i)
	      {
	        al[j]=true;
	      }
	        
	      }
	    }
	  }
	  public static int count=0;
	 static boolean com[]=new boolean[120000];
	  public static void dfs(int p,int n,ArrayList<Integer> al[],Boolean visited[])
	{
		if (visited[n]) {
			if (!com[n])
				count++;
			return;
		}
		visited[n] = true;
		for(int i:al[n])
		{
			if (i!=p)
				dfs(n,i,al,visited);
					//return true;
			
				
		}
		com[n]=true;
		//return false;
	}
	static int mex(int start,int end,int arr[])
	{
		int min=Integer.MAX_VALUE;
		if(arr[0]>0)
			return 0;
		for(int i=start;i<end-1;i++)
		{
			System.out.println(i);
			if(arr[i+1]==arr[i]+1||arr[i+1]==arr[i])
			{
				System.out.println("equal");
				continue;
			}
			else 
			{
				
				min=arr[i]+1;
				System.out.println(arr[i]+1+" "+min);
				break;
			}
		}
		return min;
	}

	  public static void main(String args[]) throws IOException {
		int temp=ni();
		pn((temp^1)+"");
		flush();
}
	  }


