#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <fstream>

#include <memory>
#include <queue>
#include <cstring>
#include <dirent.h>
#include <map>
#include <set>

#ifdef LOCALHACKER
#define LOG std::cerr
#else
#define LOG if(false) std::cerr
#endif


class Primes {
public:
    explicit Primes(long long m) {
        // Modified Sieve of Eratosthenes
        //   keeping the largest prime factor of any number in vector
        //   this makes prime factorization very efficient
        _largestPrimeFactor.resize(m+1);
        _primesUpTo.resize(m+1);
        for (int i = 1; i <= m; i++)
            _largestPrimeFactor[i] = i;
        int totalPrimes = 0;
        _primesUpTo[1] = 0;
        int lastI = 0;
        for (int i = 2; i * i <= m; i++)
        {
            if (_largestPrimeFactor[i] == i)
            {
                for (int j = i * i; j <= m; j += i)
                    _largestPrimeFactor[j] = i;
            }
        }
        for (int i = 2; i <= m; i++) {
            if (_largestPrimeFactor[i] == i) {
                totalPrimes++;
            }
            _primesUpTo[i] = totalPrimes;
        }
    }

    long long getPrimesUpTo(int n) {
        return _primesUpTo[n];
    }

    Primes() = delete;
private:
    std::vector<long long> _largestPrimeFactor;
    std::vector<long long> _primesUpTo;
};

class IOHandler {
public:
    IOHandler(std::istream &is, std::ostream &os) : input(is), output(os) {

    }
    std::istream &input;
    std::ostream &output;
};

void run(IOHandler &io) {
    Primes p(100000);
    int g;
    io.input >> g;
    for (size_t i = 0; i < g; ++i) {
        int n;
        io.input >> n;
        if (p.getPrimesUpTo(n) % 2 == 0) {
            io.output << "Bob" << std::endl;
        } else {
            io.output << "Alice" << std::endl;
        }
    }
}

void runInteractive() {
    IOHandler ioh(std::cin, std::cout);
    run(ioh);
}

bool endsWith(const std::string &str, const std::string &pattern)
{
    return str.size() >= pattern.size() && str.compare(str.size() - pattern.size(), pattern.size(), pattern) == 0;
}

void runTests(const std::string &path, std::set<std::string> ignores = {}) {
    DIR *pDIR;
    struct dirent *entry;
    std::map<std::string, std::string> testCases;
    if( pDIR=opendir(path.c_str()) ){
        while(entry = readdir(pDIR)){
            if( strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0 ){
                std::string filenameAnswer = entry->d_name;
                if (endsWith(filenameAnswer, ".answer")) {
                    std::string filename = filenameAnswer;
                    testCases.insert({filename.erase(filename.size() - 7, 7), filenameAnswer});
                }
            }
        }
        closedir(pDIR);
    }
    for (auto &it : testCases) {
        if (ignores.count(it.first) == 0) {
            std::cout << "Running " << it.first << std::endl;
            std::stringstream filename;
            filename << path << "/" << it.second;
            std::ifstream answer(filename.str());
            std::string expectedResult((std::istreambuf_iterator<char>(answer)),
                                       std::istreambuf_iterator<char>());
            answer.close();

            filename.str("");
            filename << path << "/" << it.first;
            std::ifstream ifs(filename.str());
            std::stringstream output;
            IOHandler ioh(ifs, output);
            run(ioh);
            ifs.close();
            std::string result = output.str();
            expectedResult.erase(std::remove(expectedResult.begin(), expectedResult.end(), ' '), expectedResult.end());
            expectedResult.erase(std::remove(expectedResult.begin(), expectedResult.end(), '\n'), expectedResult.end());
            result.erase(std::remove(result.begin(), result.end(), ' '), result.end());
            result.erase(std::remove(result.begin(), result.end(), '\n'), result.end());
            bool correctResult = (expectedResult == result);
            std::cout << it.second << " " << (correctResult ? "PASS" : "FAIL") << std::endl;
            if (!correctResult) {
                std::cout << "EXPECTED: " << expectedResult << std::endl;
                std::cout << "GOT     : " << result << std::endl;
            }
        }
    }
}

int main() {
#ifdef LOCALHACKER
    runTests("/home/dirb/gitrepos/101hack44/problem2");
#else
    runInteractive();
#endif
    return 0;
}