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 Ruby (2.3.3) (judge verdict: Wrong Answer)

Node = Struct.new(:a, :cnt) do
  def <=>(node)
    node.cnt <=> cnt
  end
end

class FastPriorityQueue
  attr_reader :size

  def initialize(order: :asc)
    @size = 0
    @nodes = []
  end

  def empty?
    @size.zero?
  end

  def push(node)
    index = size
    @size += 1

    while index > 0
      parent = (index - 1) / 2

      break if (@nodes[parent] <=> node) <= 0

      @nodes[index] = @nodes[parent]
      index = parent
    end

    @nodes[index] = node
  end

  alias_method :<<, :push

  def pop
    node = @nodes.first
    root = @nodes[size - 1]
    @size -= 1
    index = 0

    while index * 2 + 1 < @size
      left = 2 * index + 1
      right = left + 1

      if right < size && (@nodes[right] <=> @nodes[left]) <= 0
        left = right
      end

      break if (@nodes[left] <=> root) > 0

      @nodes[index] = @nodes[left]
      index = left
    end

    @nodes[index] = root
    node
  end

  def top
    @nodes.first
  end
end

H, W = gets.split.map(&:to_i)

counter = Hash.new(0)

H.times do
  row = gets.chomp

  row.each_char do |a|
    counter[a] += 1
  end
end

pque = FastPriorityQueue.new

grid = Array.new(H) { Array.new(W, -1) }

counter.each do |a, cnt|
  node = Node.new(a, cnt)
  pque.push(node)
end

H.times do |y|
  W.times do |x|
    next if grid[y][x] != -1

    node = pque.pop

    cnt = 1
    grid[y][x] = node.a

    ny = H - y - 1

    if grid[ny][x] == -1
      grid[ny][x] = node.a
      cnt += 1
    end

    nx = W - x - 1

    if grid[y][nx] == -1
      grid[y][nx] = node.a
      cnt += 1
    end

    if grid[ny][nx] == -1
      grid[ny][nx] = node.a
      cnt += 1
    end

    remain = node.cnt - cnt

    if remain >= 0
      pque.push(Node.new(node.a, remain)) if remain > 0
    else
      puts 'No'
      exit
    end
  end
end

puts 'Yes'