// This only takes minimal groups summing to 0, ie no subset must sum to 0.
#include <cassert>
#include <iostream>
#include <map>
#include <unordered_map>
#include <vector>

using namespace std;

// Tuples that can be removed. The inner vector has size k.
vector<vector<int>> zeros;
void init_zeros(int k, vector<int>& cnt) {
	cnt.resize(8, 0);
	for(int i1 = 0; i1 <= k && i1 <= cnt[1]; ++i1) {
		for(int i2 = 0; i1 + i2 <= k && i2 <= cnt[2]; ++i2) {
			for(int i3 = 0; i1 + i2 + i3 <= k && i3 <= cnt[3]; ++i3) {
				for(int i4 = 0; i1 + i2 + i3 + i4 <= k && i4 <= cnt[4]; ++i4) {
					for(int i5 = 0; i1 + i2 + i3 + i4 + i5 <= k && i5 <= cnt[5]; ++i5) {
						for(int i6 = 0; i1 + i2 + i3 + i4 + i5 + i6 <= k && i6 <= cnt[6]; ++i6) {
							for(int i7 = 0; i1 + i2 + i3 + i4 + i5 + i6 + i7 <= k && i7 <= cnt[7];
							    ++i7) {
								int s =
								    1 * i1 + 2 * i2 + 3 * i3 + 4 * i4 + 5 * i5 + 6 * i6 + 7 * i7;
								if(s > 0 && s % k == 0) {
									vector<int> candidate = {0, i1, i2, i3, i4, i5, i6, i7};
									bool minimal          = true;
									for(auto& c : zeros) {
										bool smaller = true;
										for(int i = 0; i < k; ++i) {
											smaller &= c[i] <= candidate[i];
										}

										if(smaller) {
											minimal = false;
											break;
										}
									}
									if(minimal) {
										zeros.push_back(candidate);
									}
								}
							}
						}
					}
				}
			}
		}
	}
	cnt.resize(k);
}

map<vector<int>, int> cache;
int k;
// NOTE This is TLE because it can not use effective caching.
int solve(vector<int>& v, int idx_from = 0) {
	bool done = true;
	for(int i = 0; i < k; ++i)
		if(v[i] > 0) done = false;
	if(done) return 0;

	// if(cache.contains(v)) {
	// 	return cache[v];
	// }
	int best = -1;
	for(int idx = idx_from; idx < zeros.size(); ++idx) {
		auto& cnt = zeros[idx];
		bool ok   = true;
		for(int j = 1; j < k; ++j) ok &= cnt[j] <= v[j];
		if(!ok) continue;
		for(int j = 1; j < k; ++j) v[j] -= cnt[j];
		best = max(best, 1 + solve(v, idx));
		for(int j = 1; j < k; ++j) v[j] += cnt[j];
	}

	return best;
}
int main() {
	int n;
	cin >> n >> k;
	int sum = 0;
	vector<int> cnt(k);
	int ans = 0;
	for(int i = 0; i < n; ++i) {
		int x;
		cin >> x;
		sum += x;
		if(x % k == 0) {
			++ans;
		} else {
			cnt[x % k] += 1;
		}
	}

	// opposite pairs
	for(int i = 1; 2 * i < k; ++i) {
		auto x = min(cnt[i], cnt[k - i]);
		cnt[i] -= x;
		cnt[k - i] -= x;
		ans += x;
	}
	if(k % 2 == 0) {
		ans += cnt[k / 2] / 2;
		cnt[k / 2] %= 2;
	}

	init_zeros(k, cnt);
	cerr << zeros.size() << endl;

	cache[vector<int>(k, 0)] = 0;

	cout << sum / k - ans - solve(cnt, 0) << endl;
}