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 Go (1.6) (judge verdict: Wrong Answer)

package main

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"strings"
)

func main() {
	b, _ := ioutil.ReadAll(os.Stdin)
	if len(b) == 0 {
		test()
	} else {
		solve(bytes.NewReader(b), os.Stdout)
	}
}

func solve(r io.Reader, w io.Writer) {
	var n, m int
	fmt.Fscanln(r, &n, &m)
	cntByX := make(map[int]int)
	cntByMod := make(map[int]int)
	for i := 0; i < n; i++ {
		var x int
		fmt.Fscan(r, &x)
		cntByX[x]++
		cntByMod[x%m]++
	}
	pairN := 0

	for mod := 0; mod <= m/2; mod++ {
		cnt := cntByMod[mod]
		if mod == 0 || (m%2 == 0 && mod == m/2) {
			pairN += cnt / 2
			cntByMod[mod] %= 2
			continue
		}
		that := m - mod
		if cnt > cntByMod[that] {
			cnt = cntByMod[that]
		}
		pairN += cnt
		cntByMod[mod] -= cnt
		cntByMod[that] -= cnt
	}

	for x, cnt := range cntByX {
		if cnt > 1 && cntByMod[x%m] > 1 {
			if cnt > cntByMod[x%m] {
				cnt = cntByMod[x%m]
			}
			pairN += cnt / 2
		}
	}

	fmt.Fprintln(w, pairN)
}

func test() {
	tests := []struct {
		in   string
		want string
	}{
		{
			in: `
7 5
3 1 4 1 5 9 2
`,
			want: `3`,
		},
		{
			in: `
15 10
1 5 6 10 11 11 11 20 21 25 25 26 99 99 99
`,
			want: `6`,
		},
		{
			in: `
3 10
8 8 8
`,
			want: `1`,
		},
		{
			in: `
2 5
15 5
`,
			want: `1`,
		},
	}
	for i, tt := range tests {
		fmt.Printf("=== TEST %d\n", i)
		buf := new(bytes.Buffer)
		solve(strings.NewReader(chomp(tt.in)), buf)
		if got, want := chomp(buf.String()), chomp(tt.want); got != want {
			fmt.Printf("%d: got %v, want %v\n", i, got, want)
		}
	}
}

func chomp(s string) string {
	return strings.Trim(s, "\n")
}