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: Wrong Answer)

use std::collections::HashMap;

fn main() {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    let a: Vec<usize> = s.trim().split_whitespace().map(|x| x.parse().unwrap()).collect();

    let mut h: HashMap<usize, usize> = HashMap::new();
    for i in &a {
        let x = match h.get(i) {Some(x) => *x, None => 0};
        h.insert(*i, x+1);
    }
    let mut x = 0;
    let mut y = 0;
    let mut z = h.keys().clone().map(|x| *x).collect::<Vec<usize>>();
    z.sort();
    z.reverse();
    println!("{:?}", z);
    for i in &z {
        let j = h.get(i).unwrap();
        let mut b = false;
        if *i > x && *j >= 2 {x = *i; b = true;}
        if *i > y && ((b && *j >= 4) || (!b && *j >= 2)) {y = *i;}
    }

    println!("{}", x * y);
}