Edogawa Conan got tired of solving cases, and invited his friend, Professor Agasa, over. They decided to play a game of cards. Conan has n cards, and the i-th card has a number ai written on it.

They take turns playing, starting with Conan. In each turn, the player chooses a card and removes it. Also, he removes all cards having a number strictly lesser than the number on the chosen card. Formally, if the player chooses the i-th card, he removes that card and removes the j-th card for all j such that aj < ai.

A player loses if he cannot make a move on his turn, that is, he loses if there are no cards left. Predict the outcome of the game, assuming both players play optimally.

Input

The first line contains an integer n (1 ≤ n ≤ 105) — the number of cards Conan has. 

The next line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105), where ai is the number on the i-th card.

Output

If Conan wins, print "Conan" (without quotes), otherwise print "Agasa" (without quotes).

Examples

Input

3
4 5 7


Output

Conan


Input

2
1 1


Output

Agasa

Note

In the first example, Conan can just choose the card having number 7 on it and hence remove all the cards. After that, there are no cards left on Agasa's turn.

In the second example, no matter which card Conan chooses, there will be one one card left, which Agasa can choose. After that, there are no cards left when it becomes Conan's turn again.
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long mod2 = 1ll << 32;
bool compare(pair<int, int> quan1, pair<int, int> quan2) {
  return quan1.second < quan2.second;
}
long long power(long long base, int expo) {
  long long ans = 1;
  while (expo > 0) {
    if (expo % 2 == 1) {
      ans *= base;
    }
    base *= base;
    expo /= 2;
  }
  return ans;
}
long long sieve_to_count_primes(long long n) {
  long long is_it_prime[1000001];
  for (long long i = 1; i <= 1000000; i++) {
    is_it_prime[i] = 1;
  }
  for (long long i = 2; i <= sqrt(1000000); i++) {
    if (is_it_prime[i] == 1) {
      for (long long j = i * i; j <= 1000000;) {
        is_it_prime[j] = 0;
        j += i;
      }
    }
  }
}
long long minimax(long long t, bool isMax, long long score, long long h,
                  long long scores[]) {
  if (t + 1 == h) return score;
  if (isMax && scores[t] != 1) {
    if (scores[t] % 2 == 0) {
      return max(minimax(t + 1, false, score + scores[t] - 1, h, scores),
                 minimax(t + 1, true, score + scores[t], h, scores));
    } else {
      return max(minimax(t + 1, true, score + scores[t] - 1, h, scores),
                 minimax(t + 1, false, score + scores[t], h, scores));
    }
  } else if (isMax && scores[t] == 1) {
    return minimax(t + 1, false, score + 1, h, scores);
  } else if (!isMax && scores[t] != 1) {
    if (scores[t] % 2 == 0) {
      return max(minimax(t + 1, true, score, h, scores),
                 minimax(t + 1, false, score, h, scores));
    } else {
      return max(minimax(t + 1, false, score, h, scores),
                 minimax(t + 1, true, score, h, scores));
    }
  } else if (!isMax && scores[t] == 1) {
    return minimax(t + 1, true, score, h, scores);
  }
}
long long func(long long arr[], long long n, long long k) {
  int calculate[n][31];
  for (auto i = 0; i < n; i++) {
    for (auto j = 0; j <= 30; j++) {
      calculate[i][j] = 0;
    }
  }
  long long answer = 0;
  vector<pair<long long, int>> netvalue;
  long long y = 0;
  for (auto i = 0; i < n; i++) {
    while (arr[i] > 0) {
      calculate[i][y] = arr[i] % 2;
      arr[i] = arr[i] / 2;
      y++;
    }
    reverse(calculate[i], calculate[i] + 31);
    y = 0;
  }
  for (auto j = 0; j <= 30; j++) {
    for (auto i = 1; i < n; i++) {
      calculate[i][j] += calculate[i - 1][j];
    }
  }
  for (auto i = 0; i <= 30; i++) {
    netvalue.push_back(
        make_pair((power(2, (30 - i)) * calculate[n - 1][i]), (30 - i)));
  }
  sort(netvalue.begin(), netvalue.end(), compare);
  long long u = 0;
  while (k > 0) {
    answer += power(2, netvalue[u].second);
    k--;
    u++;
  }
  return answer;
}
void dfSearch(int person, int visited[], unordered_set<int> &settt,
              vector<pair<int, long double>> vec[],
              unordered_map<int, long double> personTotime) {
  visited[person] = 1;
  long double lasttime;
  lasttime = personTotime[person];
  settt.insert(person);
  for (int j = 0; j < vec[person].size(); j++) {
    if ((visited[vec[person][j].first] == 0) &&
        (vec[person][j].second >= lasttime)) {
      personTotime[vec[person][j].first] = vec[person][j].second;
      dfSearch(vec[person][j].first, visited, settt, vec, personTotime);
    }
  }
}
long long lessFindit(long long ele) {
  long long start = 1;
  long long ending = 100000000;
  long long middle;
  long long ans = 0;
  while (start <= ending) {
    middle = (start + ending) / 2;
    if (ele >= ((middle * (middle + 1)) / 2)) {
      start = middle + 1;
      ans = middle;
    } else {
      ending = middle - 1;
    }
  }
  return ans;
}
long long exponentiation(long long num_one, long long num_two, long long mod) {
  long long answer = 1;
  num_one = num_one % mod;
  while (num_two > 0) {
    if (num_two & 1) {
      answer = (answer * num_one) % mod;
    }
    num_two = num_two >> 1;
    num_one = (num_one * num_one) % mod;
  }
  return answer % mod;
}
long long mod_inverse(long long number, long long mod) {
  return exponentiation(number, mod - 2, mod) % mod;
}
long long combi(long long n, long long k, long long mod) {
  if (k == 0) {
    return 1;
  }
  long long factorial[n + 1];
  factorial[0] = 1;
  for (long long i = 1; i <= n; i++) {
    factorial[i] = factorial[i - 1] * i % mod;
  }
  return ((factorial[n] % mod) * mod_inverse(factorial[k], mod) % mod *
          mod_inverse(factorial[n - k], mod) % mod) %
         mod;
}
long long fastModularExpo(long long base, long long expo) {
  long long answer = 1;
  base = base % mod;
  while (expo > 0) {
    if (expo % 2 == 1) {
      answer *= base;
      answer = answer % mod;
    }
    base *= base;
    base = base % mod;
    expo /= 2;
  }
  return (answer % mod);
}
long long gcd(long long a, long long b) {
  if (b == 0) {
    return a;
  } else {
    return gcd(b, a % b);
  }
}
long w;
void fun(vector<pair<long, long>> vec, long n, long max_cost[100][101]) {
  for (long i = 0; i < n; i++) {
    for (long j = 1; j <= w; j++) {
      if (vec[i].second <= j) {
        max_cost[i][j] =
            max(max_cost[i][j], max_cost[i][j - vec[i].second] + vec[i].first);
      } else {
        max_cost[i][j] = max_cost[i - 1][j];
      }
    }
  }
}
long calculate(vector<long> v, long l, long r, long k) {
  v.push_back(l);
  v.push_back(r);
  k = k / 2;
  long sum = 0;
  for (long i = 0; i <= (v.size() - 1 - k); i++) {
    sum += v[i];
  }
  return sum;
}
long long minval(long long val[], long long included[], long long n) {
  long long minim = INT_MAX;
  long long vertex;
  for (long long i = 0; i < n; i++) {
    if (val[i] < minim && included[i] == 0) {
      minim = val[i];
      vertex = i;
    }
  }
  return vertex;
}
void getmincost(map<pair<long long, long long>, long long> visited,
                long long sx, long long sy, long long fx, long long fy,
                long long &mini_cost, long long cost) {
  if (fx == sx && fy == sy) {
    mini_cost = min(mini_cost, cost);
    return;
  }
  visited[{sx, sy}] = 1;
  if ((((sy + (2 * sx)) < 0) && visited[{(-sx), (-(sy + (2 * sx)))}] == 0) &&
      cost <= 5) {
    getmincost(visited, -sx, -(sy + (2 * sx)), fx, fy, mini_cost, cost + 1);
  }
  if ((((sy + (2 * sx)) > 0) && visited[{sx, (sy + (2 * sx))}] == 0) &&
      cost <= 5) {
    getmincost(visited, sx, sy + (2 * sx), fx, fy, mini_cost, cost + 1);
  }
  if ((((sy - (2 * sx)) > 0) && visited[{sx, (sy - (2 * sx))}] == 0) &&
      cost <= 5) {
    getmincost(visited, sx, sy - (2 * sx), fx, fy, mini_cost, cost + 1);
  }
  if ((((sy - (2 * sx)) < 0) && visited[{(-sx), (-(sy - (2 * sx)))}] == 0) &&
      cost <= 5) {
    getmincost(visited, -sx, -(sy - (2 * sx)), fx, fy, mini_cost, cost + 1);
  }
  if ((visited[{(sx + (2 * sy)), sy}] == 0) && cost <= 5) {
    getmincost(visited, sx + (2 * sy), sy, fx, fy, mini_cost, cost + 1);
  }
  if ((visited[{(sx - (2 * sy)), sy}] == 0) && cost <= 5) {
    getmincost(visited, sx - (2 * sy), sy, fx, fy, mini_cost, cost + 1);
  }
  visited[{sx, sy}] = 0;
}
long long LCM(long long aa[], long long n) {
  long long lcm = aa[0];
  for (long long i = 1; i < n; i++) {
    lcm = (((aa[i] * lcm)) / (gcd(aa[i], lcm)));
  }
  return lcm;
}
long long mxcuts(long long cuts, vector<long long> v, long long limit,
                 long long i, long long n) {
  if (limit < 0) {
    return cuts - 1;
  }
  if (i == n || limit == 0) {
    return cuts;
  }
  return max(mxcuts(cuts + 1, v, limit - v[i], i + 1, n),
             mxcuts(cuts, v, limit, i + 1, n));
}
long long factori(long long n) {
  long long factp[n + 1];
  factp[0] = 1;
  factp[1] = 1;
  for (long long i = 1; i <= n; i++) {
    factp[i] = ((factp[i - 1] * i) + mod) % mod;
  }
  return factp[n];
}
long long findparent(long long u,
                     unordered_map<long long, vector<long long>> &parent,
                     long long p[]) {
  long long cpy = u;
  while (p[cpy] != cpy) {
    cpy = p[cpy];
  }
  p[u] = cpy;
  return cpy;
}
void findd(unordered_map<long long, long long> visited, long long &c,
           long long &maxi, long long &mini, long long u,
           unordered_map<long long, vector<long long>> &parent, long long p[]) {
  visited[u] = 1;
  c++;
  mini = min(mini, u);
  maxi = max(maxi, u);
  for (long long i = 0; i < parent[u].size(); i++) {
    if (visited[parent[u][i]] == 0) {
      findd(visited, c, maxi, mini, parent[u][i], parent, p);
    }
  }
}
void finding_all_prime_factors(long long n, vector<long long> &v) {
  while (n % 2 == 0) {
    v.push_back(2);
    n = n / 2;
  }
  for (long long y = 3; y <= sqrt(n); y += 2) {
    while (n % y == 0) {
      v.push_back(y);
      n = n / y;
    }
  }
  if (n > 2) {
    v.push_back(n);
  }
}
void uni(long long u, long long v,
         unordered_map<long long, vector<long long>> &parent, long long p[]) {
  long long par1 = findparent(u, parent, p);
  long long par2 = findparent(v, parent, p);
  if (par1 != par2) {
    parent[par1].push_back(par2);
    parent[par2].push_back(par1);
    p[par1] = par2;
  }
}
long long dfs(unordered_map<long long, long long> &size, long long node,
              bool visit[], vector<long long> adj[]) {
  visit[node] = true;
  long long s = 1;
  for (int i = 0; i < adj[node].size(); i++) {
    if (visit[adj[node][i]] == false) {
      s += dfs(size, adj[node][i], visit, adj);
    }
  }
  size[node] = s;
  return size[node];
}
long long node;
void b_f_s(long long visited[], queue<long long> q, long long vertex,
           vector<long long> v[], vector<long long> adj[]) {
  q.push(vertex);
  visited[vertex] = 1;
  while (q.size() > 0) {
    node = q.front();
    visited[node] = 1;
    q.pop();
    for (long long i = 0; i < adj[node].size(); i++) {
      if (visited[adj[node][i]] == 0) {
        q.push(adj[node][i]);
        v[adj[node][i]] = v[node];
        v[adj[node][i]].push_back(node);
      }
    }
  }
}
long long optimizer(long long t, bool ischef, long long score, long long h,
                    long long scores[], long long n) {
  if (h == 0) {
    return score;
  }
  if (t == n) {
    t -= n;
  }
  if (ischef && scores[t] != 1) {
    if (t < n - 1) {
      if (scores[t] % 2 == 0) {
        return max(optimizer(t + 1, false, (score + scores[t] - 1) % mod, h - 1,
                             scores, n),
                   optimizer(t + 1, true, (score + scores[t]) % mod, h - 1,
                             scores, n));
      } else {
        return max(optimizer(t + 1, true, (score + scores[t] - 1) % mod, h - 1,
                             scores, n),
                   optimizer(t + 1, false, (score + scores[t]) % mod, h - 1,
                             scores, n));
      }
    } else {
      if (scores[t] % 2 == 0) {
        return max(optimizer(t + 1, true, (score + scores[t] - 1) % mod, h - 1,
                             scores, n),
                   optimizer(t + 1, false, (score + scores[t]) % mod, h - 1,
                             scores, n));
      } else {
        return max(optimizer(t + 1, false, (score + scores[t] - 1) % mod, h - 1,
                             scores, n),
                   optimizer(t + 1, true, (score + scores[t]) % mod, h - 1,
                             scores, n));
      }
    }
  } else if (ischef && scores[t] == 1) {
    if (t < n - 1) {
      return optimizer(t + 1, false, (score + 1) % mod, h - 1, scores, n);
    } else {
      return optimizer(t + 1, true, (score + 1) % mod, h - 1, scores, n);
    }
  } else if (!ischef && scores[t] != 1) {
    if (t < n - 1) {
      if (scores[t] % 2 == 0) {
        return max(optimizer(t + 1, true, score, h - 1, scores, n),
                   optimizer(t + 1, false, score, h - 1, scores, n));
      } else {
        return max(optimizer(t + 1, false, score, h - 1, scores, n),
                   optimizer(t + 1, true, score, h - 1, scores, n));
      }
    } else {
      if (scores[t] % 2 == 0) {
        return max(optimizer(t + 1, false, score, h - 1, scores, n),
                   optimizer(t + 1, true, score, h - 1, scores, n));
      } else {
        return max(optimizer(t + 1, true, score, h - 1, scores, n),
                   optimizer(t + 1, false, score, h - 1, scores, n));
      }
    }
  } else if (!ischef && scores[t] == 1) {
    if (t < n - 1) {
      return optimizer(t + 1, true, score, h - 1, scores, n);
    } else {
      return optimizer(t + 1, false, score, h - 1, scores, n);
    }
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  long long t, n, quer, a, b, d, m, pos;
  long long x;
  long long num;
  cin >> n;
  long long aa[n + 1];
  vector<long long> v;
  long long maxi = LLONG_MIN;
  long long c = 0;
  unordered_map<long long, long long> cnt;
  unordered_set<long long> s;
  for (long long i = 0; i < n; i++) {
    cin >> aa[i];
    cnt[aa[i]]++;
    s.insert(aa[i]);
  }
  long long f = 0;
  for (auto i : s) {
    if (cnt[i] % 2 == 1) {
      f = 1;
      break;
    }
  }
  if (f == 0) {
    cout << "Agasa" << endl;
  } else {
    cout << "Conan" << endl;
  }
  return 0;
}
