Problem:
Score : 400 points

Problem Statement

Snuke has N strings. The i-th string is s_i.

Let us concatenate these strings into one string after arranging them in some order.
Find the maximum possible number of occurrences of AB in the resulting string.

Constraints

1 \leq N \leq 10^{4}

2 \leq |s_i| \leq 10

s_i consists of uppercase English letters.

Input

Input is given from Standard Input in the following format:

N
s_1
\vdots
s_N

Output

Print the answer.

Sample Input 1

3
ABCA
XBAZ
BAD

Sample Output 1

2

For example, if we concatenate ABCA, BAD and XBAZ in this order, the resulting string ABCABADXBAZ has two occurrences of AB.

Sample Input 2

9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA

Sample Output 2

4

Sample Input 3

7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA

Sample Output 3

4

Solution in Common Lisp (SBCL 1.1.14) (judge verdict: Wrong Answer)

(defparameter *s* #())

(defun last-char (s)
  (aref s (1- (length s))))

(defun count-ab (str)
  (let ((prev-char #\C))
    (loop :for c :across str
          :count (and (char= prev-char #\A)
                      (char= c         #\B))
          :do (setf prev-char c))))

(defun solve ()
  (let* ((last-a (loop :for s :across *s*
                       :count (char= (last-char s) #\A)))
         (first-b (loop :for s :across *s*
                        :count (char= (aref s 0) #\B)))
         (both (loop :for s :across *s*
                     :count (and (char= (last-char s) #\A) (char= (aref s 0) #\B))))
         (outer-ab
           (cond
             ((= last-a first-b both) (1- last-a))
             (t (min last-a first-b))))
         (inner-ab (loop :for s :across *s*
                         :sum (count-ab s))))
    (+ outer-ab inner-ab)))

(defun main ()
  (let* ((n (read))
         (s (loop :repeat n :collect (read-line))))
    (setf *s* (make-array (length s) :initial-contents s))
    (format t "~A~%" (solve))))

(main)