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: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using static System.Console;
using static System.Convert;
using static System.Math;
using static Extentions;

class IO
{
    int idx;
    string[] input = In.ReadToEnd().Split(new[] { " ", "\n", "\r" },
        StringSplitOptions.RemoveEmptyEntries);

    T Get<T>(Func<string, T> parser) => parser(input[idx++]);

    public string S => Get(s => s);
    public char C => Get(char.Parse);
    public int I => Get(int.Parse);
    public long L => Get(long.Parse);
    public double F => Get(double.Parse);
    public decimal D => Get(decimal.Parse);
    public BigInteger B => Get(BigInteger.Parse);

    T[] Gets<T>(int n, Func<string, T> parser)
        => input.Skip((idx += n) - n).Take(n).Select(parser).ToArray();

    public string[] Ss(int n) => Gets(n, s => s);
    public char[] Cs(int n) => Gets(n, char.Parse);
    public int[] Is(int n) => Gets(n, int.Parse);
    public long[] Ls(int n) => Gets(n, long.Parse);
    public double[] Fs(int n) => Gets(n, double.Parse);
    public decimal[] Ds(int n) => Gets(n, decimal.Parse);
    public BigInteger[] Bs(int n) => Gets(n, BigInteger.Parse);

    public void Write<T>(params T[] xs) => WriteLine(string.Join(" ", xs));
    public void Write(params object[] xs) => WriteLine(string.Join(" ", xs));
}

#region Library

static class Extentions
{
    public static int DivCeil(int l, int r) => l / r + (l % r == 0 ? 0 : 1);
}

#endregion

static class Program
{
    public static void Main()
    {
        var sw = new StreamWriter(OpenStandardOutput()) { NewLine = "\n" };
#if DEBUG
        sw.AutoFlush = true;
#else
        sw.AutoFlush = false;
#endif
        SetOut(sw);
        Solve(new IO());
        Out.Flush();
    }

    static void Solve(IO io)
    {
        var h = io.I;
        var w = io.I;
        var a = new char[h][];
        var c = new int['z' - 'a' + 1];

        for (var i = 0; i < h; i++) a[i] = io.S.ToCharArray();

        for (var i = 0; i < h; i++)
            for (var j = 0; j < w; j++) c[a[i][j] - 'a']++;

        var k = c.Count(x => x > 0);

        if (k > DivCeil(h, 2) * DivCeil(w, 2))
        {
            io.Write("No");
            return;
        }

        var t0 = 0;
        if (h % 2 != 0) t0++;
        if (w % 2 != 0) t0++;

        var t1 = DivCeil(h, 2) * DivCeil(w, 2);
        var t2 = DivCeil(t1, 2);

        var q = c.Where(x => x > 0 && x % 4 == 0);
        var even = c.Where(x => x > 0 && x % 4 != 0 && x % 2 == 0);
        var odd = c.Where(x => x > 0 && x % 2 != 0);

        // Correct
        if (t0 == 0)
        {
            if (q.Sum() == h * w &&
                q.Count() <= t1 &&
                even.Count() == 0 &&
                odd.Count() == 0) io.Write("Yes");
            else io.Write("No");
        }
        // Correct
        if (t0 == 1)
        {
            if (q.Sum() + even.Sum() == h * w &&
                q.Count() <= t2 &&
                even.Count() <= t2 &&
                odd.Count() == 0) io.Write("Yes");
            else io.Write("No");
        }
        // Wrong?
        if (t0 == 2)
        {
            if (q.Sum() + even.Sum() + odd.Sum() == h * w &&
                (h / 2) * (w / 2) - q.Count() == h / 2 + w / 2 - even.Count() &&
                q.Count() <= t2 &&
                even.Count() <= t2 &&
                odd.Count() == 1) io.Write("Yes");
            else io.Write("No");
        }
    }
}