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::io;
use std::cmp;
use std::collections::VecDeque;
use std::collections::HashMap;

fn main() {
    let stdin = io::stdin();
    let mut buf = String::new();
    stdin
        .read_line(&mut buf)
        .expect("ERROR Can't read array size");
    let n:usize = buf.trim().parse().unwrap();
    let mut buf = String::new();
    stdin
        .read_line(&mut buf)
        .expect("ERROR Can't read array size");
    let mut a: Vec<i64> = buf.split_whitespace()
        .map(|n| n.parse().unwrap())
        .collect();

    let mut edges = HashMap::new();

    for x in a.iter() {
        let val = edges.get(x).unwrap_or(&0) + 1;
        edges.insert(x, val);
    }

    let mut e1 = 0i64;
    let mut e2 = 0i64;
    for (&x,&y) in edges.iter() {
        if y >=4 {
            e1 = cmp::max(e1, *x);
            e2 = cmp::max(e2, *x);
        } else if y>=2 {
            if e1 < *x {
                e2 = e1;
                e1 = *x;
            } else if e2 < *x {
                e2 = *x;
            }
        }
    }
    println!("{}", e1*e2);

}