Problem:
Score : 400 points

Problem Statement

We have an H-by-W matrix.
Let a_{ij} be the element at the i-th row from the top and j-th column from the left.
In this matrix, each a_{ij} is a lowercase English letter.

Snuke is creating another H-by-W matrix, A', by freely rearranging the elements in A.
Here, he wants to satisfy the following condition:

Every row and column in A' can be read as a palindrome.

Determine whether he can create a matrix satisfying the condition.

Note

A palindrome is a string that reads the same forward and backward.
For example, a, aa, abba and abcba are all palindromes, while ab, abab and abcda are not.

Constraints

1 ≤ H, W ≤ 100

a_{ij} is a lowercase English letter.

Input

Input is given from Standard Input in the following format:

H W
a_{11}a_{12}...a_{1W}
:
a_{H1}a_{H2}...a_{HW}

Output

If Snuke can create a matrix satisfying the condition, print Yes; otherwise, print No.

Sample Input 1

3 4
aabb
aabb
aacc

Sample Output 1

Yes

For example, the following matrix satisfies the condition.

abba
acca
abba

Sample Input 2

2 2
aa
bb

Sample Output 2

No

It is not possible to create a matrix satisfying the condition, no matter how we rearrange the elements in A.

Sample Input 3

5 1
t
w
e
e
t

Sample Output 3

Yes

For example, the following matrix satisfies the condition.

t
e
w
e
t

Sample Input 4

2 5
abxba
abyba

Sample Output 4

No

Sample Input 5

1 1
z

Sample Output 5

Yes

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<iostream>
#include<algorithm>
#include<functional>
#include <string>
#include<iomanip>
#include<cstdio>
#include<math.h>
#include<set>
#include<stack>
#include<map>
#include<queue>
#include<cstring>
#include<vector>
#include <type_traits>
typedef long long int ll;
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define EREP(i,n) for(int i=(n-1);i>=0;--i)
#define D(n,retu) REP(i,n){cin>>retu[i];}
#define mod 1000000007
#define MIN -93193111451418101
#define INF 931931114518101
using namespace std;
typedef pair<ll, ll>P;
template<typename T, typename U>
std::enable_if_t<std::rank<T>::value == 0> fill_all(T& arr, const U& v) {
	arr = v;
}
template<typename ARR, typename U>
std::enable_if_t<std::rank<ARR>::value != 0> fill_all(ARR& arr, const U& v) {
	for (auto& i : arr) {
		fill_all(i, v);
	}
}
#define MAX_NUM 50
long long comb[MAX_NUM + 1][MAX_NUM + 1];

ll par[100000], depth[100000];
static void calc_comb()
{
	for (uint32_t i = 0; i <= MAX_NUM; i++) {
		for (uint32_t j = 0; j <= i; j++) {
			if ((j == 0) || (i == j)) {
				comb[i][j] = 1;
			}
			else {
				comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
			}
		}
	}
}
#define yo 100001
typedef pair<double, double> dop;
//------------------変数-----------------------//
ll n, m, a[100010] = {}, cnt = 0, num[1001] = {};
string str;
ll h, w;
//-------------------関数----------------------//


int main() {
	cin >> h >> w;
	REP(i, h) {
		REP(j, w) {
			char hoge; cin >> hoge;
			a[(int)hoge - (int)'a']++;
		}
	}
	REP(i, 80) {
		ll izryt = a[i];
		if (izryt == 0) { continue; }
		if (a[i] % 4 == 0) { continue; }
		izryt %= 4;
		if (izryt % 2 == 0) { num[2]++; continue; }
		if (izryt / 2) { num[1]++; num[2]++; }
		else { num[1]++; }
	}
	//cout << num[1] << endl << num[2] << endl;
	if (h % 2 == 1 && w % 2 == 1) {
		if (num[1] > 1) { cout << "No" << endl; return 0; }
		if (num[2] > h/2+w/2) { cout << "No" << endl; return 0; }
	}
	else if (h % 2 == 0 && w % 2 == 0) {
		if (num[1] || num[2]) { cout << "No" << endl; return 0; }
	}
	else if(h%2==0){
		if (num[1] ) { cout << "No" << endl; return 0; }
		if(num[2]>h/2){ cout << "No" << endl; return 0; }
	}
	else {

		if (num[1]) { cout << "No" << endl; return 0; }
		if (num[2]>w / 2) { cout << "No" << endl; return 0; }
	}
	cout << "Yes" << endl;
	return 0;
}