Takahashi and Aoki are playing a stone-taking game. Initially, there are N piles of stones, and the i-th pile contains A_i stones and has an associated integer K_i.

Starting from Takahashi, Takahashi and Aoki take alternate turns to perform the following operation:

* Choose a pile. If the i-th pile is selected and there are X stones left in the pile, remove some number of stones between 1 and floor(X/K_i) (inclusive) from the pile.



The player who first becomes unable to perform the operation loses the game. Assuming that both players play optimally, determine the winner of the game. Here, floor(x) represents the largest integer not greater than x.

Constraints

* 1 \leq N \leq 200
* 1 \leq A_i,K_i \leq 10^9
* All input values are integers.

Input

Input is given from Standard Input in the following format:


N
A_1 K_1
:
A_N K_N


Output

If Takahashi will win, print `Takahashi`; if Aoki will win, print `Aoki`.

Examples

Input

2
5 2
3 3


Output

Aoki


Input

3
3 2
4 3
5 1


Output

Takahashi


Input

3
28 3
16 4
19 2


Output

Aoki


Input

4
3141 59
26535 897
93 23
8462 64


Output

Takahashi
// package arc.arc091;

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;

public class Main {
    private static final int THRESHOLD = 2560000;

    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        long xor = 0;
        for (int i = 0; i < n ; i++) {
            int a = in.nextInt();
            int k = in.nextInt();
            xor ^= solve(a, k);
        }

        table = new int[1800][1800];

        out.println(xor == 0 ? "Aoki" : "Takahashi");
        out.flush();
    }

    private static int solve(int a, int k) {
        if (k <= THRESHOLD) {
            return solveRecursive(a, k);
        } else {
            return solveBigK(a, k);
        }
    }

    private static int[][] table;

    private static int solveBigK(int a, int k) {
        if (a < k) {
            return 0;
        }
        if (a % k == 0) {
            return a / k;
        }

        // k*k >= a
        table[0][0] = 0;
        int tid = 0;
        for (int p = k ; p+k < a ; p += k) {
            tid++;

            int li = 0;
            table[tid][li++] = p / k;
            int lastW = p / k;
            for (int idx = k-lastW ; idx <= k-1 ; idx++) {
                table[tid][li++] = table[tid-1][idx % tid];
            }
        }
        int mod = a % k;
        return table[tid][mod % (tid+1)];
    }

    private static int solveRecursive(int a, int k) {
        if (a < k) {
            return 0;
        }
        if (a % k == 0) {
            return a / k;
        }
        int L = a / k + 1;
        int mod = a % k;
        int use = (mod + L - 1) / L;

        return solve(a - use * L, k);
    }

    public static void debug(Object... o) {
        System.err.println(Arrays.deepToString(o));
    }

    public static class InputReader {
        private static final int BUFFER_LENGTH = 1 << 12;
        private InputStream stream;
        private byte[] buf = new byte[BUFFER_LENGTH];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        private int next() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public char nextChar() {
            return (char) skipWhileSpace();
        }

        public String nextToken() {
            int c = skipWhileSpace();
            StringBuilder res = new StringBuilder();
            do {
                res.append((char) c);
                c = next();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public int nextInt() {
            return (int) nextLong();
        }

        public long nextLong() {
            int c = skipWhileSpace();
            long sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = next();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = next();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            return Double.valueOf(nextToken());
        }

        int skipWhileSpace() {
            int c = next();
            while (isSpaceChar(c)) {
                c = next();
            }
            return c;
        }

        boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }
    }
}