#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// floor(a^(1/k))
unsigned long long floorKthRoot(unsigned long long a, unsigned long long k) {
  if (a == 0) {
    return 0;
  } else if (k <= 1) {
    return a;
  } else if (k == 2) {
    unsigned long long b = a, x = 0, y = 0;
    for (int e = (63 - __builtin_clzll(a)) & ~1; e >= 0; e -= 2) {
      x <<= 1;
      y <<= 1;
      if (b >= (y | 1) << e) {
        b -= (y | 1) << e;
        x |= 1;
        y += 2;
      }
    }
    return x;
  } else if (k <= 40) {
    // min x s.t. x^k >= 2^64
    static constexpr unsigned long long HIS[] =
        {0, 0, 4294967296ULL, 2642246, 65536, 7132, 1626, 566, 256, 139, 85, 57,
         41, 31, 24, 20, 16, 14, 12, 11, 10, 9, 8, 7, 7, 6, 6, 6, 5, 5, 5, 5,
         4, 4, 4, 4, 4, 4, 4, 4, 4};
    const int bsr = 63 - __builtin_clzll(a);
    unsigned long long lo = 1ULL << (bsr / k);
    unsigned long long hi = std::min(1ULL << (bsr / k + 1), HIS[k]);
    for (; lo + 1 < hi; ) {
      const unsigned long long mid = (lo + hi) / 2;
      unsigned long long b = mid * mid;
      for (unsigned i = 2; i < k; ++i) b *= mid;
      ((b <= a) ? lo : hi) = mid;
    }
    return lo;
  } else if (k <= 63) {
    return ((1ULL << k) <= a) ? 2 : 1;
  } else {
    return 1;
  }
}


void expr() {
  constexpr int N = 2000;
  for (int K = 1; K <= 5; ++K) {
    vector<int> gs(N);
    for (int x = 0; x < N; ++x) {
      set<int> app;
      for (int y = 1; round(pow(y, K)) <= x; ++y) {
        app.insert(gs[x - y]);
      }
      for (int g = 0; ; ++g) if (!app.count(g)) {
        gs[x] = g;
        break;
      }
    }
    cerr << K << ": " << gs << endl;
    if (K >= 2) {
      for (int i = 0; ; ++i) {
        const int x0 = round(pow(i, K));
        const int x1 = round(pow(i + 1, K));
        const int len = min(x1 - x0, 40);
        if (x0 + len > N) break;
        for (int x = x0; x < x0 + len; ++x) cerr << gs[x] << " ";
        if (x0 + len < x1) cerr << "...";
        cerr << endl;
      }
    }
  }
}


int K;
Int power(Int a) {
  Int aa = 1;
  for (int k = 0; k < K; ++k) aa *= a;
  return aa;
}


namespace k1 {
Int prefix(Int a) {
  const Int b = a / 4 * 4;
  Int ans = 0;
  for (Int x = b; x <= a; ++x) {
    ans ^= x;
  }
  return ans;
}
}  // k1


namespace k35 {
// fs[a]: [0, a^K)
vector<Int> fs;
void build() {
  assert(K == 3 || K == 5);
  const Int lim = (K == 3) ? (1 << 20) : (1 << 12);
  fs.assign(lim + 1, 0);
  for (Int b = 0; b < lim; ++b) {
    fs[b + 1] = fs[b] ^ b ^ ((b & 1) ? k1::prefix(b) : 0);
  }
}
Int prefix(Int a) {
  const Int b = floorKthRoot(a, K);
  const Int bK = power(b);
  Int ans = 0;
  ans ^= fs[b];
  ans ^= b;
  const Int q = (a - bK) / (b + 1);
  const Int r = (a - bK) % (b + 1);
  if (q & 1) ans ^= k1::prefix(b);
  if (r) ans ^= k1::prefix(r - 1);
  return ans;
}
}  // k35


namespace k24 {
/*
0
1 0 1
2 0 1 2 0
3 1 2 0 3 1 2
4 0 3 1 2 4 0 3 1
5 2 4 0 3 1 5 2 4 0 3
6 1 5 2 4 0 3 6 1 5 2 4 0
7 3 6 1 5 2 4 0 7 3 6 1 5 2 4
8 0 7 3 6 1 5 2 4 8 0 7 3 6 1 5 2
9 4 8 0 7 3 6 1 5 2 9 4 8 0 7 3 6 1 5
10 2 9 4 8 0 7 3 6 1 5 10 2 9 4 8 0 7 3 6 1
11 5 10 2 9 4 8 0 7 3 6 1 11 5 10 2 9 4 8 0 7 3 6
12 1 11 5 10 2 9 4 8 0 7 3 6 12 1 11 5 10 2 9 4 8 0 7 3
13 6 12 1 11 5 10 2 9 4 8 0 7 3 13 6 12 1 11 5 10 2 9 4 8 0 7
14 3 13 6 12 1 11 5 10 2 9 4 8 0 7 14 3 13 6 12 1 11 5 10 2 9 4 8 0
15 7 14 3 13 6 12 1 11 5 10 2 9 4 8 0 15 7 14 3 13 6 12 1 11 5 10 2 9 4 8
16 0 15 7 14 3 13 6 12 1 11 5 10 2 9 4 8 16 0 15 7 14 3 13 6 12 1 11 5 10 2 9 4
  
  rows
  [ 0,  1): 0
  [ 1,  3): 0 1
  [ 3,  7): 0 2 1 3
  [ 7, 15): 0 4 2 5 1 6 3 7
  [15, 31): 0 8 4 9 2 10 5 11 1 12 6 13 3 14 7 15
*/
Int sub(Int e, Int n) {
  Int ret = 0;
  if (e) {
    ret ^= sub(e - 1, (n + 1) / 2);
    ret ^= k1::prefix((1LL << (e - 1)) - 1) ^ k1::prefix((1LL << (e - 1)) + (n / 2) - 1);
  }
  return ret;
}
Int prefix(Int a) {
  const Int b = floorKthRoot(a, K);
  const Int bK = power(b);
  Int ans = 0;
  for (Int e = 0; ; ++e) {
    const Int bL = (1LL << e) - 1;
    const Int bR = (1LL << (e + 1)) - 1;
    if (bR <= b) {
      ans ^= k1::prefix((1LL << e) - 1);
    } else {
      ans ^= sub(e, b - bL);
      break;
    }
  }
  const Int q = (a - bK + 1) / (b + 1);
  const Int r = (a - bK + 1) % (b + 1);
  if (q & 1) ans ^= k1::prefix(b);
  // TODO
  /*
            0
          10
        201
      3120
    40312
  */
  vector<Int> seq(2 * b + 1);
  for (Int c = 0; c <= b; ++c) {
    seq[2 * (b - c)] = c;
    if (c) seq[2 * (b - c) + 1] = seq[2 * (b - c) + 1 + c];
  }
// cerr<<b<<": "<<seq<<endl;
  for (Int i = 0; i < r; ++i) {
    ans ^= seq[i];
  }
  return ans;
}
}  // k24


int main() {
  // expr();
  
// K=3;k35::build();for(Int b=1;b<=5;++b){for(Int a=power(b);a<power(b+1);++a)cerr<<(k35::prefix(a-1)^k35::prefix(a))<<" ";cerr<<endl;}
  
  int T;
  for (; ~scanf("%d%d", &T, &K); ) {
    switch (K) {
      case 1: break;
      case 2: break;
      case 3: k35::build(); break;
      case 4: break;
      case 5: k35::build(); break;
      default: assert(false);
    }
    
    for (int t = 0; t < T; ++t) {
      int N;
      scanf("%d", &N);
      vector<Int> A(N);
      for (int i = 0; i < N; ++i) {
        scanf("%lld", &A[i]);
      }
      
      Int ans = 0;
      for (int i = 0; i < N; ++i) {
        switch (K) {
          case 1: ans ^= k1::prefix(A[i]); break;
          case 2: ans ^= k24::prefix(A[i]); break;
          case 3: ans ^= k35::prefix(A[i]); break;
          case 4: ans ^= k24::prefix(A[i]); break;
          case 5: ans ^= k35::prefix(A[i]); break;
          default: assert(false);
        }
      }
      puts(ans ? "Lily" : "Kaguya");
    }
  }
  return 0;
}