Problem:
Score : 300 points

Problem Statement

We have N sticks with negligible thickness.
The length of the i-th stick is A_i.

Snuke wants to select four different sticks from these sticks and form a rectangle (including a square), using the sticks as its sides.
Find the maximum possible area of the rectangle.

Constraints

4 \leq N \leq 10^5

1 \leq A_i \leq 10^9

A_i is an integer.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible area of the rectangle.
If no rectangle can be formed, print 0.

Sample Input 1

6
3 1 2 4 2 1

Sample Output 1

2

1 \times 2 rectangle can be formed.

Sample Input 2

4
1 2 3 4

Sample Output 2

0

No rectangle can be formed.

Sample Input 3

10
3 3 3 3 4 4 4 5 5 5

Sample Output 3

20

Solution in Rust (1.15.1) (judge verdict: Accepted)

use std::vec::Vec;
use std::cmp::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn main() {
  let n: usize = read();
  let mut a: Vec<u64> = read_vec();

  // 降順にソート
  a.sort_by(|a, b| b.cmp(&a));

  let v = count_same_element(&a);

  let mut x = 0;
  let mut y = 0;
  let mut num = 0;

  for &e in &v {
    if num == 2 {
      break;
    }

    if e.1 >= 4 && num == 0 {
      num = 2;
      x = e.0;
      y = e.0;
    }

    if e.1 >= 2 && num == 0 {
      num += 1;
      x = e.0;
    } else if e.1 >= 2 && num == 1 {
      num += 1;
      y = e.0;
    }
  }
  println!("{}", x * y);
}

fn count_same_element<T: Eq + Copy>(v: &Vec<T>) -> Vec<(T, usize)> {

  let mut res: Vec<(T, usize)> = Vec::new();
  if v.len() == 0 {
    return res;
  }

  let mut now: T = v[0];
  let mut count: usize = 0;
  for &e in v {
    if e == now {
      count += 1;
    }
    else {
      res.push((now, count));
      count = 1;
      now = e;
    }
  }
  res.push((now, count));

  return res;
}