import sys

sys.setrecursionlimit(10 ** 9)

# input = sys.stdin.readline    ####

def int1(x): return int(x) - 1

def II(): return int(eval(input()))

def MI(): return list(map(int, input().split()))

def MI1(): return list(map(int1, input().split()))

def LI(): return list(map(int, input().split()))

def LI1(): return list(map(int1, input().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

def MS(): return input().split()

def LS(): return list(eval(input()))

def LLS(rows_number): return [LS() for _ in range(rows_number)]

def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))

INF = float('inf')

# from math import ceil, floor, log2

from collections import deque, defaultdict

# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations

# from heapq import heapify, heappop, heappush

# import numpy as np    # cumsum

# from bisect import bisect_left, bisect_right



def solve():

    N = II()

    A = LI()

    counter = defaultdict(int)

    for a in A:

        counter[a] += 1

    # print(counter)



    odd = 0

    ans = N

    for key, val in list(counter.items()):

        if val > 1:

            c = val - 1

            # print(val, c, c // 2)

            if c % 2 == 1:

                odd += 1

            ans -= (c // 2) * 2

    # print(ans, odd)

    ans = ans - (odd // 2) * 2 - (odd % 2) * 2

    print(ans)



            



    



if __name__ == '__main__':

    solve()



import sys

sys.setrecursionlimit(10 ** 9)

# input = sys.stdin.readline    ####

def int1(x): return int(x) - 1

def II(): return int(eval(input()))

def MI(): return list(map(int, input().split()))

def MI1(): return list(map(int1, input().split()))

def LI(): return list(map(int, input().split()))

def LI1(): return list(map(int1, input().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]

def MS(): return input().split()

def LS(): return list(eval(input()))

def LLS(rows_number): return [LS() for _ in range(rows_number)]

def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))

INF = float('inf')

# from math import ceil, floor, log2

from collections import deque, defaultdict

# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations

# from heapq import heapify, heappop, heappush

# import numpy as np    # cumsum

# from bisect import bisect_left, bisect_right



def solve():

    N = II()

    A = LI()

    counter = defaultdict(int)

    for a in A:

        counter[a] += 1

    # print(counter)



    odd = 0

    ans = N

    for key, val in list(counter.items()):

        if val > 1:

            c = val - 1

            # print(val, c, c // 2)

            if c % 2 == 1:

                odd += 1

            ans -= (c - c % 2)

    # print(ans, odd)

    ans = ans - (odd // 2) * 2 - (odd % 2) * 2

    print(ans)



            



    



if __name__ == '__main__':

    solve()



import sys

sys.setrecursionlimit(10**9)
# input = sys.stdin.readline    ####
def int1(x):
    return int(x) - 1


def II():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def MI1():
    return list(map(int1, input().split()))


def LI():
    return list(map(int, input().split()))


def LI1():
    return list(map(int1, input().split()))


def LLI(rows_number):
    return [LI() for _ in range(rows_number)]


def MS():
    return input().split()


def LS():
    return list(eval(input()))


def LLS(rows_number):
    return [LS() for _ in range(rows_number)]


def printlist(lst, k=" "):
    print((k.join(list(map(str, lst)))))


INF = float("inf")
# from math import ceil, floor, log2
from collections import deque, defaultdict

# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np    # cumsum
# from bisect import bisect_left, bisect_right
def solve():
    N = II()
    A = LI()
    counter = defaultdict(int)
    for a in A:
        counter[a] += 1
    # print(counter)
    odd = 0
    ans = N
    for key, val in list(counter.items()):
        if val > 1:
            c = val - 1
            # print(val, c, c // 2)
            if c % 2 == 1:
                odd += 1
            ans -= (c // 2) * 2
    # print(ans, odd)
    ans = ans - (odd // 2) * 2 - (odd % 2) * 2
    print(ans)


if __name__ == "__main__":
    solve()

import sys

sys.setrecursionlimit(10**9)
# input = sys.stdin.readline    ####
def int1(x):
    return int(x) - 1


def II():
    return int(eval(input()))


def MI():
    return list(map(int, input().split()))


def MI1():
    return list(map(int1, input().split()))


def LI():
    return list(map(int, input().split()))


def LI1():
    return list(map(int1, input().split()))


def LLI(rows_number):
    return [LI() for _ in range(rows_number)]


def MS():
    return input().split()


def LS():
    return list(eval(input()))


def LLS(rows_number):
    return [LS() for _ in range(rows_number)]


def printlist(lst, k=" "):
    print((k.join(list(map(str, lst)))))


INF = float("inf")
# from math import ceil, floor, log2
from collections import deque, defaultdict

# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np    # cumsum
# from bisect import bisect_left, bisect_right
def solve():
    N = II()
    A = LI()
    counter = defaultdict(int)
    for a in A:
        counter[a] += 1
    # print(counter)
    odd = 0
    ans = N
    for key, val in list(counter.items()):
        if val > 1:
            c = val - 1
            # print(val, c, c // 2)
            if c % 2 == 1:
                odd += 1
            ans -= c - c % 2
    # print(ans, odd)
    ans = ans - (odd // 2) * 2 - (odd % 2) * 2
    print(ans)


if __name__ == "__main__":
    solve()

-            ans -= (c // 2) * 2 +            ans -= c - c % 2