Problem:
 Score : 100 points    Problem Statement Given is an integer x that is greater than or equal to 0 , and less than or equal to 1 .
Output 1 if x is equal to 0 , or 0 if x is equal to 1 .      Constraints  0 \leq x \leq 1  x is an integer         Input Input is given from Standard Input in the following format:  x       Output Print 1 if x is equal to 0 , or 0 if x is equal to 1 .        Sample Input 1 1      Sample Output 1 0       Sample Input 2 0      Sample Output 2 1

Solution (Python):
x = int(input())
if x == 0:
    print("1")
else:
    print("0")

Solution (Python):
x = int(input())
print(0 if x==1 else 1)

Solution (Python):
x = int(input())
print(1 - x)

Solution (Python):
print(1-int(input()))

Solution (Python):
N = int(input())

if N == 1:
  print(0)
else:
  print(1)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
N = int(input())
if N == 1:
  print(0)
else:
  print(1)

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

n = int(input())

if n == 1:
    print(0)
else:
    print(1)

Solution (Python):



x= int(input())








if x:
    print(0)
else:
    print(1)

Solution (Python):





import math
import fractions
import sys
import bisect
import heapq  
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

sr = lambda: input()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""


def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    for i in range(2, int(-(-n ** 0.5 // 1)) + 1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr.append([i, cnt])

    if temp != 1:
        arr.append([temp, 1])

    if arr == []:
        arr.append([n, 1])

    return arr



def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod



def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

inf = 10 ** 18
mod = 10 ** 9 + 7

x = ir()
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
N = int(input())
print(1 if N == 0 else 0)

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

x = i()
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
print(1-int(input()))

Solution (Python):
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
import sys
gcd = math.gcd
x = ni()
print(1-x)

Solution (Python):
x = int(input())

if x == 1:
    print(0)
else:
    print(1)

Solution (Python):
print(1-int(input()))

Solution (Python):
import sys, math
from functools import lru_cache
sys.setrecursionlimit(10**9)
MOD = 10**9+7

def input():
    return sys.stdin.readline()[:-1]

def mi():
    return map(int, input().split())

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]

def main():
    x = ii()
    print(0 if x else 1)



if __name__ == '__main__':
    main()

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x = int(input())

if x == 0:
  print(1)
else:
  print(0)

Solution (Python):
x = int(input())

if x == 1 :
    print("0") 
else :
    print("1")

Solution (Python):
n = int(input())
print (0) if n == 1 else print (1)

Solution (Python):
n = int(input())
if n == 0: print(1)
else: print(0)

Solution (Python):
A= int(input())
if A==0:
   print(1)
else:
   print(0)

Solution (Python):
print(int(not int(input())))

Solution (Python):
x = int(input())


if(x == 1):
    print(0)
else:
    print(1)

Solution (Python):
n = int(input())
if n == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
print(1 if x == 0 else 0)

Solution (Python):
print(1 - int(input()))

Solution (Python):
x=input()
if x=="1":
    print(0)
else:
    print(1)

Solution (Python):
x=int(input())
print(0 if x else 1)

Solution (Python):
N = int(input())

if N == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
import sys












stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
MIN = -10 ** 9
MOD = 10 ** 9 + 7
INF = float("inf")
IINF = 10 ** 18

def solve():
    x = int(stdin.readline().rstrip())
    
    
    
    
    
    
    if x ==1:
        print(0)
    else:
        print(1)

if __name__ == '__main__':
    solve()

Solution (Python):
print(int(input())^1)

Solution (Python):
import sys; input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**7)
from collections import defaultdict
mod = 10 ** 9 + 7; INF = float("inf")

def getlist():
	return list(map(int, input().split()))

def inverse(N, mod):
	return (pow(N, mod - 2, mod))

def main():
	X = int(input())
	print(X ^ 1)





if __name__ == '__main__':
	main()

Solution (Python):
N=int(input())
print(1-N)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
if(x==0):
  print(1)
else:
  print(0)

Solution (Python):
X = int(input())
if X==0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())

print(0 if x == 1 else 1)

Solution (Python):
x = int(input())
if x == 0:
  print(1)
else:
  print(0)

Solution (Python):
x=int(input())
print(1) if x==0 else print(0)

Solution (Python):
x = int(input())
print(x^1)

Solution (Python):
x = int(input())

x = 1 - x
print(x)

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    x=ii()
    print(1 if x == 0 else 0)





if __name__ == "__main__":
    main()

Solution (Python):
s=int(input())
print(1 if s == 0 else 0)

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    x = int(readline())

    if x == 1:
        print(0)
    else:
        print(1)


if __name__ == '__main__':
    main()

Solution (Python):


'''
Author: andyli
Time: 2020-09-13 19:58:03
'''

import os
from io import BytesIO, IOBase
import sys


def main():
    print(1-int(input()))
    return



BUFSIZE = 1048576


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')




if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

if n == 0:
    print(1)
else:
    print(0)

Solution (Python):








    






mod = int(1e9+7)

INF = 1<<50

def readInt():
    return list(map(int,input().split()))

def main():
    x = int(input())
    print(abs(x-1))
    return

if __name__=='__main__':
    main()

Solution (Python):
x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x=int(input())
if x==0:
  print(1)
else:
  print(0)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x=int(input())
print(0 if x==1 else 1)

Solution (Python):
x=int(input())
if x==0:
    print(1)
else:
    print(0)

Solution (Python):
print(1-int(input()))

Solution (Python):
x=int(input())
if x==0:
    print(1)
else:
    print(0)

Solution (Python):
N = int(input())
if N == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
if x == 0:
  print (1)
else:
  print (0)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    N = int(input())
    if N == 0:
        print(1)
    else:
        print(0)


if __name__ == '__main__':
    main()

Solution (Python):
x=int(input())
if x==1 :
  print(0)
else :
  print(1)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x=int(input())
print(1-x)

Solution (Python):
x = int(input())

print(1) if x == 0 else print(0)

Solution (Python):
x=int(input())
if x==0:
  print(1)
else:
  print(0)

Solution (Python):
n = int(input())
if n == 1:
    print(0)
else:
    print(1)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x=int(input())
if x==1:
    print(0)
else:
    print(1)

Solution (Python):
x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
if input()=='0':
  print(1)
else:
  print(0)

Solution (Python):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
input = sys.stdin.readline
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    if len(x) == 0:
        return []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa != x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))
def In(x,a): 
    k = bs.bisect_left(a,x)
    if k != len(a) and a[k] ==  x:
        return True
    else:
        return False

def pow_k(x, n):
    ans = 1
    while n:
        if n % 2:
            ans *= x
        x *= x
        n >>= 1
    return ans

"""
def nibu(x,n,r):
    ll = 0
    rr = r
    while True:
        mid = (ll+rr)//2

    if rr == mid:
        return ll
    if (ここに評価入れる):
        rr = mid
    else:
        ll = mid+1
"""


n = onem()

if n:
    print(0)
else:
    print(1)

Solution (Python):
n=int(input())
print(n^1)

Solution (Python):
x=int(input())
print(0 if x else 1)

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 6)
mod = 10**9+7
cnt = 1
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

x = k()

if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
print(1-int(input()))

Solution (Python):
def main():

    x = int(input())
    return (x+1) % 2

if __name__ == '__main__':
    print(main())

Solution (Python):
n = int(input())
print(1-n)

Solution (Python):
import sys
import re
import random
import math
import copy
from heapq import heappush, heappop, heapify
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter



input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = float("inf")
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)

def solve():
    x = bool(getN())

    print(int(not x))
def main():
    n = getN()
    for _ in range(n):
        solve()

    return
if __name__ == "__main__":
    
    solve()

Solution (Python):
def main():
    X = int(input())
    if X == 0:
        print(1)
    else:
        print(0)


if __name__ == '__main__':
    main()

Solution (Python):
print(1-int(input()))

Solution (Python):
x = int(input())
print("1" if x ==0 else "0")

Solution (Python):
print(1-int(input()))

Solution (Python):
X = int(input())
if X:
    print(0)
else:
    print(1)

Solution (Python):
print(1-int(input()))

Solution (Python):
x = int(input())

if x == 1:
  print(0)
else:
  print(1)

Solution (Python):
print(int(input())^1)

Solution (Python):
import sys
input = sys.stdin.readline

N = int(input())
print(0 if N == 1 else 1)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x = I()
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x=int(input())
if x==0: x=1
else: x=0
print(x)

Solution (Python):
x=int(input())
print(1 if x==0 else 0)

Solution (Python):
x = int(input())
print(1 - x)

Solution (Python):
x=int(input())
print(0 if x==1 else 1)

Solution (Python):
print(1 - int(input()))

Solution (Python):
print(1 - int(input()))

Solution (Python):
a = int(input())
print(a^1)

Solution (Python):
a=int(input())
print(1-a)

Solution (Python):
x = int(input())
if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x=int(input())
if x==1:
    print(0)
else:
    print(1)

Solution (Python):
x=int(input())

if x==1:
    print(0)
else:
    print(1)

Solution (Python):
def main():
    x=int(input())
    print(1-x)


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
print(0 if N else 1)

Solution (Python):
a = int(input())

if a == 0:
    print(1)
else:
    print(0)

Solution (Python):
i = int(input())
if i == 0:
  print(1)
else:
  print(0)

Solution (Python):
if int(input()) == 0:
    print(1)
else:
    print(0)

Solution (Python):
print(int(not bool(int(input()))))

Solution (Python):
x = int(input())
if x == 1:
  print(0)
else:
  print(1)

Solution (Python):
def LI():return list(map(int,input().split()))
def II():return int(input())
def yes():return print("Yes")
def no():return print("No")
INF=float("inf")
from collections import deque, defaultdict, Counter
from heapq import heappop, heappush
from itertools import product, combinations
from functools import reduce, lru_cache
from math import pi, gcd
from decimal import Decimal

class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv

class Unionfind:
    def __init__(self, N):
        self.p = list(range(N))
        self.rank = [0] * N
        self.size = [1] * N

    def root(self, x):
        if self.p[x] != x:
            self.p[x] = self.root(self.p[x])

        return self.p[x]

    def same(self, x, y):
        return self.root(x) == self.root(y)

    def unite(self, x, y):
        u = self.root(x)
        v = self.root(y)

        if u == v: return

        if self.rank[u] < self.rank[v]:
            self.p[u] = v
            self.size[v] += self.size[u]
            self.size[u] = 0
        else:
            self.p[v] = u
            self.size[u] += self.size[v]
            self.size[v] = 0

            if self.rank[u] == self.rank[v]:
                self.rank[u] += 1

    def count(self, x):
        return self.size[self.root(x)]


x=II()
if x==1:
    print(0)
else:
    print(1)

Solution (Python):
print(1-int(input()))

Solution (Python):
x = int(input())
if not x:
    print(1)
else:
    print(0)

Solution (Python):
print(int(input())^1)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
print(1-int(input()))

Solution (Python):
print( 1 - int(input()) )

Solution (Python):
N=int(input())
print(1-N)

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array





sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
INF = float('inf')


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

    N = ii()
    print(1 if N == 0 else 0)



if __name__ == '__main__':
    main()

Solution (Python):
x = int(input())

if x == 0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
if x:
    print(0)
else:
    print(1)

Solution (Python):
print(1 if input() == '0' else 0)

Solution (Python):
x = int(input())
print(1 - x)

Solution (Python):

n = int(input())
if n == 1:
    print(0)
else:
    print(1)

Solution (Python):
print(1-int(input()))

Solution (Python):
def main():
    x = int(input())
    print(1 if x == 0 else 0)


if __name__ == '__main__':
    main()

Solution (Python):
x = int(input())
print([1, 0][x])

Solution (Python):
x=int(input())
if x==0:
  print(1)
else:
  print(0)

Solution (Python):
print(1-int(input()))

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    x = int(readline())

    print(1 - x)

    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce, lru_cache
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()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = 10**6
mod = 10 ** 9 + 7 





print(INT()^1)

Solution (Python):
print(1-int(input()))

Solution (Python):
print(1 - int(input()))

Solution (Python):
x = int(input())
print(x^1)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a = inp()
print(a^1)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x = int(input())
print(0 if x else 1)

Solution (Python):
X=int(input())
if X==0:
    print(1)
else:
    print(0)

Solution (Python):
N = int(input())

print(1-N)

Solution (Python):
import sys
from sys import exit
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians

sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7

def lcm(x,y):
    return x*y//gcd(x,y)
def lgcd(l):
    return reduce(gcd,l)
def llcm(l):
    return reduce(lcm,l)
def powmod(n,i,mod):
    return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
    return x.bit_length()
def div10(x):
    return len(str(x))-(x==0)
def intput():
    return int(input())
def mint():
    return map(int,input().split())
def lint():
    return list(map(int,input().split()))
def ilint():
    return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
    print(l[0] if x else l[1])
def lprint(l, sep='\n'):
    for x in l:
        print(x, end=sep)
def ston(c, c0='a'):
    return ord(c)-ord(c0)
def ntos(x, c0='a'):
    return chr(x+ord(c0))
class counter(dict):
    def __init__(self, *args):
        super().__init__(args)
    def add(self,x,d=1):
        self.setdefault(x,0)
        self[x] += d
    def list(self):
        l = []
        for k in self:
            l.extend([k]*self[k])
        return l
class comb():
    def __init__(self, n, mod=None):
        self.l = [1]
        self.n = n
        self.mod = mod
    def get(self,k):
        l,n,mod = self.l, self.n, self.mod
        k = n-k if k>n//2 else k
        while len(l)<=k:
            i = len(l)
            l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
        return l[k]
def pf(x,mode='counter'):
    C = counter()
    p = 2
    while x>1:
        k = 0
        while x%p==0:
            x //= p
            k += 1
        if k>0:
            C.add(p,k)
        p = p+2-(p==2) if p*p<x else x
    if mode=='counter':
        return C
    S = set([1])
    for k in C:
        T = deepcopy(S)
        for x in T:
            for i in range(1,C[k]+1):
                S.add(x*(k**i))
    if mode=='set':
        return S
    if mode=='list':
        return sorted(list(S))

x=intput()
if x==0:
    print(1)
else:
    print(0)

Solution (Python):
x = int(input())
print(1^x)

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


print(1-I())

Solution (Python):
i = input();print(0 if i=="1" else 1)

Solution (Python):
n = int(input())
print(n ^ 1)

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
print(N ^ 1)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    x = int(input())
    print(1 if x == 0 else 0)



if __name__ == '__main__':
    resolve()

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x = int(input())

print(1 - x)

Solution (Python):
ans = [1, 0]
print(ans[int(input())])

Solution (Python):
print(1 - int(input()))

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):



from math import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq














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


INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())
x = I()
print(0 if x else 1)

Solution (Python):
x = int(input())
if x == 0:
  print(1)
else:
  print(0)

Solution (Python):
x=int(input())

print(1-x)

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):
x=int(input())
print(1-x)

Solution (Python):
x=int(input())
print(x^1)

Solution (Python):
x = int(input())
print(1 - x)

Solution (Python):
X = int(input())
print(1-X)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


def main():
    x = int(input())
    print(1 - x)


if __name__ == "__main__":
    main()

Solution (Python):
print(1^int(input()))

Solution (Python):
x = int(input())
if x == 1:
    print(0)
else:
    print(1)

Solution (Python):
n = int(input())
print((n+1)%2)

Solution (Python):
x = int(input())
print(1 - x)

Solution (Python):
print(1-int(input()))

Solution (Python):
import sys

sys.setrecursionlimit(10**6)
int1 = lambda x: int(x)-1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

print(1-II())

Solution (Python):
print(1-int(input()))

Solution (Python):
x=int(input())
print(1-x)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for _ in range(n)]
def LIR(n):
    return [LI() for _ in range(n)]
def SR(n):
    return [S() for _ in range(n)]
def LSR(n):
    return [LS() for _ in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    x = I()
    print(1-x)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
x = int(input())
print(1-x)

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

x=int(input())
print(int(not x))

Solution (Python):


def Yes(f): print('Yes' if f else 'No')
def YES(f): print('YES' if f else 'NO')
def ispow(x): return int(x ** 0.5) ** 2 == x


res = 0
n = int(input())




print(n^1)