Rock... Paper!

After Karen have found the deterministic winning (losing?) strategy for rock-paper-scissors, her brother, Koyomi, comes up with a new game as a substitute. The game works as follows.

A positive integer n is decided first. Both Koyomi and Karen independently choose n distinct positive integers, denoted by x1, x2, ..., xn and y1, y2, ..., yn respectively. They reveal their sequences, and repeat until all of 2n integers become distinct, which is the only final state to be kept and considered.

Then they count the number of ordered pairs (i, j) (1 ≤ i, j ≤ n) such that the value xi xor yj equals to one of the 2n integers. Here xor means the [bitwise exclusive or](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) operation on two integers, and is denoted by operators ^ and/or xor in most programming languages.

Karen claims a win if the number of such pairs is even, and Koyomi does otherwise. And you're here to help determine the winner of their latest game.

Input

The first line of input contains a positive integer n (1 ≤ n ≤ 2 000) — the length of both sequences.

The second line contains n space-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 2·106) — the integers finally chosen by Koyomi.

The third line contains n space-separated integers y1, y2, ..., yn (1 ≤ yi ≤ 2·106) — the integers finally chosen by Karen.

Input guarantees that the given 2n integers are pairwise distinct, that is, no pair (i, j) (1 ≤ i, j ≤ n) exists such that one of the following holds: xi = yj; i ≠ j and xi = xj; i ≠ j and yi = yj.

Output

Output one line — the name of the winner, that is, "Koyomi" or "Karen" (without quotes). Please be aware of the capitalization.

Examples

Input

3
1 2 3
4 5 6


Output

Karen


Input

5
2 4 6 8 10
9 7 5 3 1


Output

Karen

Note

In the first example, there are 6 pairs satisfying the constraint: (1, 1), (1, 2), (2, 1), (2, 3), (3, 2) and (3, 3). Thus, Karen wins since 6 is an even number.

In the second example, there are 16 such pairs, and Karen wins again.
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Set;

public class A {

    public static void main(String args[]) throws IOException {
        FastScanner in = new FastScanner(System.in);
        int n  = in.nextInt();
        int [] x = new int[n], y = new int[n];
        Set<Integer> values = new HashSet<>();
        for(int i = 0;i<n;i++){
            x[i] = in.nextInt();
            values.add(x[i]);
        }
        for(int i = 0;i<n;i++) {
            y[i] = in.nextInt();
            values.add(y[i]);
        }
        int count = 0;
        for(int i = 0;i<n;i++){
            for(int j = 0;j<n;j++){
                int xor = x[i]^y[j];
                if(values.contains(xor)){
                    count++;
                }
            }
        }
        if(count%2 == 0){
            System.out.println("Karen");
        } else {
            System.out.println("Koyomi");
        }
    }


   static class FastScanner {

        static final int DEFAULT_BUFF = 1024, EOF = -1, INT_MIN = 48, INT_MAX = 57, NOT_SET = -1, POS = 1, DOT = 46, SPACE = 32, NL = 10, CR = 13;
        static final byte NEG = 45;
        /**
         * Stores digits for corresponding byte values
         */
        static final int[] digits = new int[58];

        /**
         * Assigning digits for corresponding byte values
         */
        static {
            int value = 0;
            for (int i = 48; i < 58; i++) {
                digits[i] = value++;
            }
        }

        InputStream stream;
        /**
         * Current buffer of bytes in memory
         */
        byte[] buff;
        /**
         * Pointer that points to the byte position in bytes buffer array
         */
        int buffPtr;
        /**
         * Shows how many bytes are read into buffer;
         */
        int numBytes;

        /**
         * Constructor of FastScanner with default bytes buffer size
         *
         * @param stream - input stream to scan
         */
        public FastScanner(InputStream stream) {
            this.stream = stream;
            this.buff = new byte[DEFAULT_BUFF];
            this.buffPtr = NOT_SET;
        }

        /**
         * Constructor of FastScanner with custom bytes buffer size
         *
         * @param stream     - input stream to scan
         * @param bufferSize - custom buffer size to read bytes into
         */
        public FastScanner(InputStream stream, int bufferSize) {
            this.stream = stream;
            this.buff = new byte[bufferSize];
            this.buffPtr = NOT_SET;
        }

        /**
         * Method for obtaining next available 32 bit integer from the input. Not
         * that it just skips all the non numeric characters around numeric slice
         * and returns the numeric slice.
         *
         * @return - 32 bit integer value if one exist in input.
         * @throws IOException if no more digits are found
         */
        public int nextInt() throws IOException {
            int val = 0;
            int sign = readNonNumerics();
            while (isDigit(buff[buffPtr]) && numBytes != EOF) {
                val = (val << 3) + (val << 1) + digits[buff[buffPtr]];
                buffPtr++;
                if (buffPtr == numBytes) {
                    updateBuff();
                }
            }
            return val * sign;
        }

        /**
         * Method for obtaining next available 64 bit integer from the input. Note
         * that it just skips all the non numeric characters around numeric slice
         * and returns the numeric slice.
         *
         * @return - 64 bit integer value if one exist in input.
         * @throws IOException if no more digits are found
         */
        public long nextLong() throws IOException {
            long val = 0L;
            int sign = readNonNumerics();
            while (isDigit(buff[buffPtr]) && numBytes != EOF) {
                val = (val << 3) + (val << 1) + digits[buff[buffPtr]];
                buffPtr++;
                if (buffPtr == numBytes) {
                    updateBuff();
                }
            }
            return val * sign;
        }


        /**
         * Method for reading next available 64 bit floating point number(double).
         * It is just a simple implementation with parse double operation. Further enhancements will be thought out.
         */
        public double nextDouble() throws IOException {
            double val = 0d;
            int sign = readNonNumerics();
            String doubleStr = next();
            val = Double.parseDouble(doubleStr);
            return val * sign;
        }

        /**
         * Reads next string slice
         *
         * @return String the next available string without space characters
         * @throws IOException if some exception occurs while input output
         */
        public String next() throws IOException {
            readAllSpaces();
            StringBuilder res = new StringBuilder();
            while (numBytes != EOF && buff[buffPtr] != SPACE && buff[buffPtr] != NL && buff[buffPtr] != CR) {
                res.append((char) buff[buffPtr]);
                buffPtr++;
                if (buffPtr == buff.length) {
                    updateBuff();
                }
            }
            return res.toString();
        }

        /**
         * Reads all non numeric symbols and assigns the buffer's pointer to the
         * first available numeric character byte
         *
         * @return integer sign denoting the sign of the integer to be red next
         * @throws IOException if no more numeric character is found
         */
        private int readNonNumerics() throws IOException {
            if (buffPtr == NOT_SET || buffPtr == buff.length) {
                updateBuff();
            }
            if (numBytes == EOF) {
                throw new IOException("End of stream reached");
            }
            int signByte = NOT_SET;
            while (!isDigit(buff[buffPtr])) {
                signByte = buff[buffPtr];
                buffPtr++;
                if (buffPtr >= buff.length) {
                    updateBuff();
                }
                if (numBytes == EOF) {
                    throw new IOException("End of stream reached");
                }
            }
            if (signByte == NEG) {
                return -POS;
            }
            return POS;
        }

        private void readAllSpaces() throws IOException {
            if (buffPtr == NOT_SET || buffPtr >= numBytes) {
                updateBuff();
            }
            if (numBytes == EOF) {
                throw new IOException("End of stream reached");
            }
            while (buff[buffPtr] == SPACE || buff[buffPtr] == NL || buff[buffPtr] == CR) {
                buffPtr++;
                if (buffPtr >= numBytes) {
                    updateBuff();

                }
                if (numBytes == EOF) {
                    throw new IOException("End of stream reached");
                }
            }
        }

        /**
         * Closes the input stream passed as parameter to a constructor. We
         * recommend to avoid calling this method explicitly if not necessary!
         *
         * @throws IOException if some exception occurs while closing the stream
         */
        public void close() throws IOException {
            stream.close();
        }

        /**
         * Checks whether byte is for numeric character
         *
         * @param b - byte number of character
         * @return true if the input byte number is for numeric character
         */
        private boolean isDigit(int b) {
            return b >= INT_MIN && b <= INT_MAX;
        }

        /**
         * Loads next buffer of bytes and resets the buffer pointer
         *
         * @throws IOException if some exception occurs while reading bytes into the
         *                     buffer array.
         */
        private void updateBuff() throws IOException {
            buffPtr = 0;
            numBytes = stream.read(buff);
        }

        public void reset() throws IOException {
            this.stream.reset();
        }
    }
}