output_description: Print the answer.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 A_3 ... A_{N}
attempt: import sys
  from sys import exit
  from collections import deque
  from copy import deepcopy
  from bisect import bisect_left, bisect_right, insort_left, insort_right
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod=MOD):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
      def list(self):
          l = []
          for k in self:
              l.extend([k] * self[k])
          return l
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  def pf(x, mode="counter"):
      C = counter()
      p = 2
      while x > 1:
          k = 0
          while x % p == 0:
              x //= p
              k += 1
          if k > 0:
              C.add(p, k)
          p = p + 2 - (p == 2) if p * p < x else x
      if mode == "counter":
          return C
      S = set([1])
      for k in C:
          T = deepcopy(S)
          for x in T:
              for i in range(1, C[k] + 1):
                  S.add(x * (k**i))
      if mode == "set":
          return S
      if mode == "list":
          return sorted(list(S))
  
  
  ######################################################
  
  N, A = ilint()
  C = counter()
  for a in A:
      C.add(a)
  ans = 0
  for k in C:
      ans += max(0, C[k] - 1)
  print(N - 2 * ((ans - 1) // 2 + 1))
  
problem_description: Statement
  
  Snuke has decided to play a game using cards. He has a deck consisting of N
  cards. On the i-th card from the top, an integer A_i is written.
  
  He will perform the operation described below zero or more times, so that the
  values written on the remaining cards will be pairwise distinct. Find the
  maximum possible number of remaining cards. Here, N is odd, which guarantees
  that at least one card can be kept.
  
  Operation: Take out three arbitrary cards from the deck. Among those three
  cards, eat two: one with the largest value, and another with the smallest
  value. Then, return the remaining one card to the deck.
samples: [{"input": "5\n    1 2 1 3 7", "output": "3\n    \n\nOne optimal solution is to perform the operation once, taking out two cards\nwith 1 and one card with 2. One card with 1 and another with 2 will be eaten,\nand the remaining card with 1 will be returned to deck. Then, the values\nwritten on the remaining cards in the deck will be pairwise distinct: 1, 3 and\n7.\n\n* * *"}, {"input": "15\n    1 3 5 2 1 3 2 8 8 6 2 6 11 1 1", "output": "7"}]