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.42.0) (judge verdict: Accepted)

use std::io::*;
use std::str::FromStr;
use std::cmp;
use std::collections::HashMap;
use std::collections::HashSet;
use std::char;
use std::cmp::{min, max};
use itertools::Itertools;
use num_integer::div_floor;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn read_tuple2<T: FromStr, S: FromStr>() -> (T, S) {
    let a = read();
    let b = read();
    (a, b)
}

fn read_tuple3<T: FromStr, S: FromStr, R: FromStr >() -> (T, S, R) {
    let a = read();
    let b = read();
    let c = read();
    (a, b, c)
}

fn main() {
    let n:u64 = read();
    let alist:Vec<u64> = (0..n).map(|_|read()).collect();
    let mut counter = HashMap::new();
    for a in alist {
        let ent =counter.entry(a).or_insert(0);
        *ent += 1;
    }
    let mut twos:Vec<u64> = counter.iter()
        .filter(|(key, val)|**val > 1)
        .map(|(key, val)|*key)
        .collect();
    twos.sort_by(|a, b|b.cmp(a));
    if let (Some(f), Some(s)) = (twos.get(0), twos.get(1)) {
        let ans = max(f * s, if *counter.get(f).unwrap_or(&0) > 3 { f * f } else { 0 });
        println!("{}", ans);
    } else {
        let mut fours:Vec<u64> = counter.iter()
            .filter(|(key, val)|**val > 3)
            .map(|(key, val)|*key)
            .collect();
        fours.sort_by(|a, b|b.cmp(a));
        if let Some(f) = fours.get(0) {
            println!("{}", f * f);
        } else {
            println!("0");
        }
    }


}