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 Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports, unused_macros, dead_code)]

macro_rules! min {
    (.. $x:expr) => {{
        let mut it = $x.iter();
        it.next().map(|z| it.fold(z, |x, y| min!(x, y)))
    }};
    ($x:expr) => ($x);
    ($x:expr, $($ys:expr),*) => {{
        let t = min!($($ys),*);
        if $x < t { $x } else { t }
    }}
}
macro_rules! max {
    (.. $x:expr) => {{
        let mut it = $x.iter();
        it.next().map(|z| it.fold(z, |x, y| max!(x, y)))
    }};
    ($x:expr) => ($x);
    ($x:expr, $($ys:expr),*) => {{
        let t = max!($($ys),*);
        if $x > t { $x } else { t }
    }}
}
macro_rules! ewriteln {
    ($($args:expr),*) => { let _ = writeln!(&mut std::io::stderr(), $($args),*); };
}
macro_rules! trace {
    ($x:expr) => { ewriteln!(">>> {} = {:?}", stringify!($x), $x) };
    ($($xs:expr),*) => { trace!(($($xs),*)) }
}
macro_rules! put {
    (.. $x:expr) => {{
        let mut it = $x.iter();
        if let Some(x) = it.next() { print!("{}", x); }
        for x in it { print!(" {}", x); }
        println!("");
    }};
    ($x:expr) => { println!("{}", $x) };
    ($x:expr, $($xs:expr),*) => { print!("{} ", $x); put!($($xs),*) }
}

const M: i64 = 1_000_000_007;

fn main() {
    let mut sc = Scanner::new();
    let h: usize = sc.cin();
    let w: usize = sc.cin();
    let mut cx = DefaultMap::new(0);
    for _ in 0..h { for c in sc.chars() { cx[c] += 1; } }

    match (h % 2, w % 2) {
        (0, 0) => {
            put!(
                if cx.iter().all(|(_, x)| x % 4 == 0) {
                    "Yes"
                } else {
                    "No"
                });
        }
        (0, 1) => {
            let mut b = 0;
            let mut c = 0;
            for (_, x) in cx.iter() {
                if x % 4 == 0 {}
                else if x % 2 == 0 { b += 1; }
                else { c += 1; }
            }
            put!(if c == 0 && b <= h / 2 { "Yes" } else { "No" });
        }
        (1, 0) => {
            let mut b = 0;
            let mut c = 0;
            for (_, x) in cx.iter() {
                if x % 4 == 0 {}
                else if x % 2 == 0 { b += 1; }
                else { c += 1; }
            }
            put!(if c == 0 && b <= w / 2 { "Yes" } else { "No" });
        }
        (1, 1) => {
            let mut b = 0;
            let mut c = 0;
            for (_, x) in cx.iter() {
                if x % 4 == 0 {}
                else if x % 2 == 0 { b += 1; }
                else { c += 1; }
            }
            put!(if c == 1 && b <= h / 2 + w / 2 { "Yes" } else { "No" });
        }
        _ => {}
    }
}

struct DefaultMap<S, T> {
    data: std::collections::HashMap<S, T>,
    default: T,
}
impl<S: Eq + std::hash::Hash, T> DefaultMap<S, T> {
    fn new(default: T) -> DefaultMap<S, T> {
        DefaultMap {
            data: std::collections::HashMap::new(),
            default: default
        }
    }
    fn keys(&self) -> std::collections::hash_map::Keys<S, T> { self.data.keys() }
    fn iter(&self) -> std::collections::hash_map::Iter<S, T> { self.data.iter() }
    fn len(&self) -> usize { self.data.len() }
}
impl<S: Eq + std::hash::Hash, T> std::ops::Index<S> for DefaultMap<S, T> {
    type Output = T;
    fn index(&self, key: S) -> &Self::Output {
        if let Some(val) = self.data.get(&key) {
            val
        } else {
            &self.default
        }
    }
}
impl<S: Eq + std::hash::Hash + Clone, T: Clone> std::ops::IndexMut<S> for DefaultMap<S, T> {
    fn index_mut(&mut self, key: S) -> &mut Self::Output {
        self.data.entry(key.clone()).or_insert(self.default.clone());
        self.data.get_mut(&key).unwrap()
    }
}

use std::io::{self, Write};
use std::str::FromStr;
use std::collections::VecDeque;

struct Scanner { stdin: io::Stdin, buffer: VecDeque<String>, }
impl Scanner {
    fn new() -> Self { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }
    fn cin<T: FromStr>(&mut self) -> T {
        while self.buffer.len() == 0 {
            let mut line = String::new();
            let _ = self.stdin.read_line(&mut line);
            for w in line.split_whitespace() {
                self.buffer.push_back(String::from(w));
            }
        }
        self.buffer.pop_front().unwrap().parse::<T>().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> { self.cin::<String>().chars().collect() }
    fn vec<T: FromStr>(&mut self, n: usize) -> Vec<T> { (0..n).map(|_| self.cin()).collect() }
}