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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
using static System.Convert;
using static System.Math;
using Pair = System.Tuple<int, int>;
using Edge = System.Tuple<int, int, long>;
//using Debug;
//using static System.Globalization.CultureInfo;

class Program
{
    static void Main(string[] args)
    {
        //Solve();
        WriteLine(Solve());
    }
    static string Solve()
    {
        var hw = Input.ar;
        var gred = Input.gred(hw[0]);
        var dic = new Dictionary<char, int>();
        for (var i = 0; i < Input.Alfa.Length; i++)
            dic[Input.Alfa[i]] = 0;
        for (var i = 0; i < hw[0]; i++)
            for (var j = 0; j < hw[1]; j++)
                dic[gred[i][j]]++;
        var ct = new[] { 0, 0, 0 };//4,2,1
        if (hw[0] % 2 == 0 && hw[1] % 2 == 0)
            ct[0] = hw[0] * hw[1] / 4;
        else if (hw[0] % 2 == 1 && hw[1] % 2 == 1)
        {
            ct[0] = (hw[0] / 2) * (hw[1] / 2);
            ct[1] = hw[0] / 2 + hw[1] / 2;
            ct[2] = 1;
        }
        else
        {
            ct[0] = (hw[0] / 2) * (hw[1] / 2);
            if (hw[0] % 2 == 0)
                ct[1] = hw[0] / 2;
            else ct[1] = hw[1] / 2;
        }
        var ar = new[] { 4, 2, 1 };
        foreach (var val in dic.Values)
        {
            var n = val;
            for (var j = 0; j < 3; j++)
                if (n / ar[j] > ct[j])
                {
                    n -= ct[j] * ar[j];
                    ct[j] = 0;
                }
                else
                {
                    ct[j] -= n / ar[j];
                    n %= ar[j];
                }
            if (n != 0) return "No";
        }
        return "Yes";
    }
}

public class Input
{
    public static string read => ReadLine();
    public  static int[] ar => Array.ConvertAll(read.Split(' '), int.Parse);
    public  static int num => ToInt32(read);
    public static long[] arL => Array.ConvertAll(read.Split(' '), long.Parse);
    public  static long numL => ToInt64(read);
    public static char[][] gred(int h) 
        => Enumerable.Repeat(0, h).Select(v => read.ToCharArray()).ToArray();
    public static int[][] ar2D(int num)
        => Enumerable.Repeat(0, num).Select(v => ar).ToArray();
    public static long[][] arL2D(int num)
        => Enumerable.Repeat(0, num).Select(v => arL).ToArray();
    public const long Inf = (long)1e18;
    public const double eps = 1e-6;
    public  const string Alfa = "abcdefghijklmnopqrstuvwxyz";
    public  const int MOD = 1000000007;
}