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.

Examples

Input

7 5
3 1 4 1 5 9 2


Output

3


Input

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


Output

6
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cfloat>

using std::cerr;
using std::cin;
using std::cout;
using std::endl;

int main(){
  cout << std::fixed << std::setprecision(16);
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);

  int n,m;
  cin>>n>>m;
  std::vector<int> x(n);
  for(int i=0;i<n;++i){
    cin>>x[i];
  }

  std::unordered_multiset<int> x_mod[100000];
  std::vector<int> samenumber_card(m);

  for(auto v:x){
    x_mod[v%m].insert(v);
    if(x_mod[v%m].count(v)==2){
      x_mod[v%m].erase(v);
      x_mod[v%m].erase(v);
      samenumber_card[v%m]+=2;
    }
  }

  int result=0;

  result+=x_mod[0].size()/2;
  if(m%2==0){
    result+=x_mod[m/2].size()/2;
  }

  for(int l=1;l<m;l++){
    if(l>=m-l){
      break;
    }

    int not_pair_l=x_mod[l].size();
    int not_pair_r=x_mod[m-l].size();
    int pair=std::min(not_pair_l,not_pair_r);
    not_pair_l-=pair;
    not_pair_r-=pair;
    result+=pair;

    int repair_r=samenumber_card[m-l];
    int repair_num=std::min(not_pair_l,repair_r);
    result+=repair_num;
    not_pair_l-=repair_num;
    samenumber_card[m-l]-=repair_num;

    int repair_l=samenumber_card[l];
    repair_num=std::min(not_pair_r,repair_l);
    result+=repair_num;
    not_pair_r-=repair_num;
    samenumber_card[l]-=repair_num;
  }

  for(auto v:samenumber_card){
    result+=v/2;
  }

  cout<<result<<endl;



  return 0;
}