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)
	xcnt := make(map[int]int, n)
	for i := 0; i < n; i++ {
		var x int
		fmt.Fscan(r, &x)
		xcnt[x]++
	}

	// by reminder
	// reminder -> x -> count
	xsbyrem := make(map[int]map[int]int)

	for x, cnt := range xcnt {
		rem := x % m
		if _, ok := xsbyrem[rem]; !ok {
			xsbyrem[rem] = make(map[int]int)
		}
		xsbyrem[rem][x] = cnt
	}

	pairNum := 0

	for rem, cntByX := range xsbyrem {
		if rem > m/2 {
			continue
		}
		if rem == 0 || rem*2 == m {
			pairNum += sum(cntByX) / 2
			continue
		}
		want := m - rem
		t := xsbyrem[want]
		if t == nil {
			t = make(map[int]int)
		}
		s := cntByX
		sNum := sum(cntByX)
		tNum := sum(t)
		if sNum < tNum {
			s, t = t, s
			sNum, tNum = tNum, sNum
		}
		for x, cnt := range s {
			if !(sNum > tNum+1) {
				break
			}
			if cnt > 1 {
				c := sNum - tNum
				if c > cnt {
					c = cnt
				}
				s[x] -= c
				sNum -= c
				pairNum += c / 2
			}
		}
		pairNum += tNum
	}

	fmt.Fprintln(w, pairNum)
}

func sum(m map[int]int) int {
	s := 0
	for _, c := range m {
		s += c
	}
	return s
}

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`,
		},
	}
	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")
}