Problem:
Score : 400 points

Problem 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.

Constraints

3 ≦ N ≦ 10^{5}

N is odd.

1 ≦ A_i ≦ 10^{5}

A_i is an integer.

Input

The input is given from Standard Input in the following format:

N
A_1 A_2 A_3 ... A_{N}

Output

Print the answer.

Sample Input 1

5
1 2 1 3 7

Sample Output 1

3

One optimal solution is to perform the operation once, taking out two cards with 1 and one card with 2. One card with 1 and another with 2 will be eaten, and the remaining card with 1 will be returned to deck. Then, the values written on the remaining cards in the deck will be pairwise distinct: 1, 3 and 7.

Sample Input 2

15
1 3 5 2 1 3 2 8 8 6 2 6 11 1 1

Sample Output 2

7

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.AbstractSet;
import java.util.Set;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.Random;
import java.util.AbstractMap;
import java.util.Map;
import java.util.Map.Entry;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.NoSuchElementException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author GYSHGX868
 */
public class Main {
  public static void main(String[] args) {
    InputStream inputStream = System.in;
    OutputStream outputStream = System.out;
    InputReader in = new InputReader(inputStream);
    OutputWriter out = new OutputWriter(outputStream);
    TaskD solver = new TaskD();
    solver.solve(1, in, out);
    out.close();
  }

  static class TaskD {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
      int n = in.nextInt();
      int[] a = IOUtils.readIntArray(in, n);
      Counter<Integer> counter = new Counter<>();
      for (int i = 0; i < n; i++) {
        counter.add(a[i]);
      }
      int numEvens = 0;
      for (Entry<Integer, Long> entry : counter.entrySet()) {
        if (entry.getValue() % 2 == 0) {
          entry.setValue(2L);
          numEvens++;
        } else {
          entry.setValue(1L);
        }
      }
      int answer = counter.entrySet().size();
      if (numEvens % 2 == 0) {
        out.printLine(answer);
      } else {
        out.printLine(answer - 1);
      }
//    for (Entry<Integer, Long> entry : counter.entrySet()) {
//      out.printLine(entry.getKey() + " " + entry.getValue());
//    }
//    int answer = counter.entrySet().size();
//    if (repeated > 0 && repeated % 2 == 0) {
//      out.printLine(answer - 1);
//    } else {
//      out.printLine(answer);
//    }
    }

  }

  static class Counter<K> extends EHashMap<K, Long> {
    public Counter() {
      super();
    }

    public Counter(int capacity) {
      super(capacity);
    }

    public long add(K key) {
      long result = get(key);
      put(key, result + 1);
      return result + 1;
    }

    public Long get(Object key) {
      if (containsKey(key)) {
        return super.get(key);
      }
      return 0L;
    }

  }

  static class IOUtils {
    private IOUtils() {
    }

    public static int[] readIntArray(InputReader in, int size) {
      int[] array = new int[size];
      for (int i = 0; i < size; i++) {
        array[i] = in.nextInt();
      }
      return array;
    }

  }

  static class EHashMap<E, V> extends AbstractMap<E, V> {
    private static final int[] shifts = new int[10];
    private int size;
    private EHashMap.HashEntry<E, V>[] data;
    private int capacity;
    private Set<Entry<E, V>> entrySet;

    static {
      Random random = new Random(System.currentTimeMillis());
      for (int i = 0; i < 10; i++) {
        shifts[i] = 1 + 3 * i + random.nextInt(3);
      }
    }

    public EHashMap() {
      this(4);
    }

    private void setCapacity(int size) {
      capacity = Integer.highestOneBit(4 * size);
      // noinspection unchecked
      data = new EHashMap.HashEntry[capacity];
    }

    public EHashMap(int maxSize) {
      setCapacity(maxSize);
      entrySet = new AbstractSet<Entry<E, V>>() {

        public Iterator<Entry<E, V>> iterator() {
          return new Iterator<Entry<E, V>>() {
            private EHashMap.HashEntry<E, V> last = null;
            private EHashMap.HashEntry<E, V> current = null;
            private EHashMap.HashEntry<E, V> base = null;
            private int lastIndex = -1;
            private int index = -1;


            public boolean hasNext() {
              if (current == null) {
                for (index++; index < capacity; index++) {
                  if (data[index] != null) {
                    base = current = data[index];
                    break;
                  }
                }
              }
              return current != null;
            }


            public Entry<E, V> next() {
              if (!hasNext()) {
                throw new NoSuchElementException();
              }
              last = current;
              lastIndex = index;
              current = current.next;
              if (base.next != last) {
                base = base.next;
              }
              return last;
            }


            public void remove() {
              if (last == null) {
                throw new IllegalStateException();
              }
              size--;
              if (base == last) {
                data[lastIndex] = last.next;
              } else {
                base.next = last.next;
              }
            }
          };
        }


        public int size() {
          return size;
        }
      };
    }

    public EHashMap(Map<E, V> map) {
      this(map.size());
      putAll(map);
    }

    public Set<Entry<E, V>> entrySet() {
      return entrySet;
    }

    public void clear() {
      Arrays.fill(data, null);
      size = 0;
    }

    private int index(Object o) {
      return getHash(o.hashCode()) & (capacity - 1);
    }

    private int getHash(int h) {
      int result = h;
      for (int i : shifts) {
        result ^= h >>> i;
      }
      return result;
    }

    public V remove(Object o) {
      if (o == null) {
        return null;
      }
      int index = index(o);
      EHashMap.HashEntry<E, V> current = data[index];
      EHashMap.HashEntry<E, V> last = null;
      while (current != null) {
        if (current.key.equals(o)) {
          if (last == null) {
            data[index] = current.next;
          } else {
            last.next = current.next;
          }
          size--;
          return current.value;
        }
        last = current;
        current = current.next;
      }
      return null;
    }

    public V put(E e, V value) {
      if (e == null) {
        return null;
      }
      int index = index(e);
      EHashMap.HashEntry<E, V> current = data[index];
      if (current != null) {
        while (true) {
          if (current.key.equals(e)) {
            V oldValue = current.value;
            current.value = value;
            return oldValue;
          }
          if (current.next == null) {
            break;
          }
          current = current.next;
        }
      }
      if (current == null) {
        data[index] = new EHashMap.HashEntry<E, V>(e, value);
      } else {
        current.next = new EHashMap.HashEntry<E, V>(e, value);
      }
      size++;
      if (2 * size > capacity) {
        EHashMap.HashEntry<E, V>[] oldData = data;
        setCapacity(size);
        for (EHashMap.HashEntry<E, V> entry : oldData) {
          while (entry != null) {
            EHashMap.HashEntry<E, V> next = entry.next;
            index = index(entry.key);
            entry.next = data[index];
            data[index] = entry;
            entry = next;
          }
        }
      }
      return null;
    }

    public V get(Object o) {
      if (o == null) {
        return null;
      }
      int index = index(o);
      EHashMap.HashEntry<E, V> current = data[index];
      while (current != null) {
        if (current.key.equals(o)) {
          return current.value;
        }
        current = current.next;
      }
      return null;
    }

    public boolean containsKey(Object o) {
      if (o == null) {
        return false;
      }
      int index = index(o);
      EHashMap.HashEntry<E, V> current = data[index];
      while (current != null) {
        if (current.key.equals(o)) {
          return true;
        }
        current = current.next;
      }
      return false;
    }

    public int size() {
      return size;
    }

    private static class HashEntry<E, V> implements Entry<E, V> {
      private final E key;
      private V value;
      private EHashMap.HashEntry<E, V> next;

      private HashEntry(E key, V value) {
        this.key = key;
        this.value = value;
      }

      public E getKey() {
        return key;
      }

      public V getValue() {
        return value;
      }

      public V setValue(V value) {
        V oldValue = this.value;
        this.value = value;
        return oldValue;
      }

    }

  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private InputReader.SpaceCharFilter filter;

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1) {
        throw new InputMismatchException();
      }
      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }
        if (numChars <= 0) {
          return -1;
        }
      }
      return buf[curChar++];
    }

    public int nextInt() {
      int c = read();
      while (isSpaceChar(c)) {
        c = read();
      }
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      int res = 0;
      do {
        if (c < '0' || c > '9') {
          throw new InputMismatchException();
        }
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public boolean isSpaceChar(int c) {
      if (filter != null) {
        return filter.isSpaceChar(c);
      }
      return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
      boolean isSpaceChar(int ch);

    }

  }

  static class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
      writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
      this.writer = new PrintWriter(writer);
    }

    public void close() {
      writer.close();
    }

    public void printLine(int i) {
      writer.println(i);
    }

  }
}