Problem:
Score : 700 points

Problem Statement

Takahashi is playing with N cards.

The i-th card has an integer X_i on it.

Takahashi is trying to create as many pairs of cards as possible satisfying one of the following conditions:

The integers on the two cards are the same.

The sum of the integers on the two cards is a multiple of M.

Find the maximum number of pairs that can be created.

Note that a card cannot be used in more than one pair.

Constraints

2≦N≦10^5

1≦M≦10^5

1≦X_i≦10^5

Input

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

N M
X_1 X_2 ... X_N

Output

Print the maximum number of pairs that can be created.

Sample Input 1

7 5
3 1 4 1 5 9 2

Sample Output 1

3

Three pairs (3,2), (1,4) and (1,9) can be created.

It is possible to create pairs (3,2) and (1,1), but the number of pairs is not maximized with this.

Sample Input 2

15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99

Sample Output 2

6

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

/// Thank you tanakh!!!
/// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let mut s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::cmp;

fn main() {
    input!(n: usize, m: usize, x: [usize; n]);

    let max: usize = *x.iter().max().unwrap();
    let mut remainder_count = vec![vec![]; m];
    for &x in x.iter() {
        let r = x % m;
        remainder_count[r].push(x);
    }

    let mut ans = 0;
    for i in 0..m {
        if i == 0 || i * 2 == m {
            ans += remainder_count[i].len() / 2;
        } else if m - i < i {
            break;
        } else {
            let j = m - i;

            let len_i = remainder_count[i].len();
            let len_j = remainder_count[j].len();
            ans += cmp::min(len_i, len_j);

            let t = if len_i > len_j { i } else { i };
            remainder_count[t].sort();

            let mut pair = 0;
            let mut i = 1;
            while i < remainder_count[t].len() {
                if remainder_count[t][i - 1] == remainder_count[t][i] {
                    pair += 1;
                    i += 2;
                } else {
                    i += 1;
                }
            }

            let remain = cmp::max(len_i, len_j) - cmp::min(len_i, len_j);
            ans += cmp::min(remain / 2, pair);
        }
    }

    println!("{}", ans);
}