#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;
}
