{-# LANGUAGE BinaryLiterals #-}
{-# LANGUAGE NegativeLiterals #-}
{-# LANGUAGE HexFloatLiterals #-}
{-# LANGUAGE NumericUnderscores #-}

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE BlockArguments #-}
-- {-# LANGUAGE OverloadedLists #-}   
-- {-# LANGUAGE OverloadedStrings #-}   

{-# LANGUAGE NumDecimals #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeApplications #-}   

{-# OPTIONS_GHC -O2 #-}
{-# OPTIONS_GHC -Wno-tabs #-}

{-# LANGUAGE CPP #-}
-- #define ONLINE_JUDGE

import Control.Applicative
import Control.Arrow
import Control.Monad
import Control.Monad.ST

import Data.Bool
import Data.Bits
import Data.Char

import Data.List hiding ( (!?) )
import Data.Maybe
import Data.Either
import Data.Function

import qualified Data.ByteString.Char8 as B

import Data.Array (Array)
import Data.Array.IArray
import Data.Array.Unboxed (UArray)
import Data.Array.ST.Safe
import Data.Array.MArray
import Data.STRef

import Text.Printf
import Debug.Trace

#ifdef ONLINE_JUDGE
import Control.Monad.Extra
import Data.Tuple.Extra hiding ( (&&&), (***) )
import Data.List.Extra hiding ( (!?) )

import qualified Data.Set as Set
import qualified Data.IntSet as ISet
import qualified Data.Map as Map
import qualified Data.IntMap as IMap
import qualified Data.Sequence as Seq
import Data.Sequence ( (<|), (|>), (><), ViewL(..), ViewR(..) )
#endif

readInt = fst . fromJust . B.readInt <$> B.getLine
readInteger = fst . fromJust . B.readInteger <$> B.getLine
readInts = map ( fst . fromJust . B.readInt ) . B.words <$> B.getLine
readIntegers = map ( fst . fromJust . B.readInteger ) . B.words <$> B.getLine
readStrs = map B.unpack . B.words <$> B.getLine

yesno = bool "No" "Yes"
mp [ a, b ] = ( a, b )

count a as = length $ filter ( == a ) as
countIf f as = length $ filter f as

swapArrayElem a i j = do
	x <- readArray a i
	y <- readArray a j
	writeArray a i y
	writeArray a j x

a !? i
	| inRange ( bounds a ) i = Just $ a ! i
	| otherwise = Nothing

printList :: Show a => [a] -> IO ()
printList = putStrLn . intercalate " " . map show

#ifdef ATCODER
readStr = trim . B.unpack <$> B.getLine

printList2d :: Show a => [[a]] -> IO ()
printList2d = mapM_ printList
printArray2d ass = printList2d $ chunksOf ( x2 - x1 + 1 ) $ elems ass
	where
	( ( _, x1 ), ( _, x2 ) ) = bounds ass
#endif

main = print 0

-- main = do
-- 	n <- readInt
-- 	mapM_ putStrLn $ map f [ 1 .. n ]
-- 
-- f x
-- 	| x `mod` 3 == 0 && x `mod` 5 == 0 = "FizzBuzz"
-- 	| x `mod` 3 == 0 = "Fizz"
-- 	| x `mod` 5 == 0 = "Buzz"
-- 	| otherwise = show x