Problem:
Score : 500 points

Problem Statement

A robot is put at the origin in a two-dimensional plane.
Initially, the robot is facing in the positive x-axis direction.

This robot will be given an instruction sequence s.
s consists of the following two kinds of letters, and will be executed in order from front to back.

F : Move in the current direction by distance 1.

T : Turn 90 degrees, either clockwise or counterclockwise.

The objective of the robot is to be at coordinates (x, y) after all the instructions are executed.
Determine whether this objective is achievable.

Constraints

s consists of F and T.

1 \leq |s| \leq 8 000

x and y are integers.

|x|, |y| \leq |s|

Input

Input is given from Standard Input in the following format:

s
x y

Output

If the objective is achievable, print Yes; if it is not, print No.

Sample Input 1

FTFFTFFF
4 2

Sample Output 1

Yes

The objective can be achieved by, for example, turning counterclockwise in the first T and turning clockwise in the second T.

Sample Input 2

FTFFTFFF
-2 -2

Sample Output 2

Yes

The objective can be achieved by, for example, turning clockwise in the first T and turning clockwise in the second T.

Sample Input 3

FF
1 0

Sample Output 3

No

Sample Input 4

TF
1 0

Sample Output 4

No

Sample Input 5

FFTTFF
0 0

Sample Output 5

Yes

The objective can be achieved by, for example, turning counterclockwise in the first T and turning counterclockwise in the second T.

Sample Input 6

TTTT
1 0

Sample Output 6

No

Solution in Haskell (GHC 7.10.3) (judge verdict: Runtime Error)

import Data.Array.Unboxed

--アイテムリスト、考察するスコア上限、結果テーブルのリスト
sub_total_memo::UArray Int Int->Int->[UArray Int Bool]
sub_total_memo ar n =(listArray (0,n) (True:(replicate n False))):[ listArray (0,n) [(ar_i!k)||(ar_i!(if k >= ar!i then k-ar!i else k)) |k<-[0..n] ] | (ar_i,i)<-zip (sub_total_memo ar n) [1..] ]


sub_total_b::[Int]->Int->Bool
sub_total_b items score = let ls = take ((length items)+1) (sub_total_memo (listArray (1,length items) items ) score) in
                             (last ls)!score

--これが部分和問題のソルバ
--DPができたので、あとは問題を帰着していく。


--まずTF列を必要な情報にパースする。
--最初にゼロ文字以上のFがあるという想定でいく。
--同様に末尾にゼロ文字以上のFがあるという想定でいく。
--最初にFを取得する。これはtakeWhileでよい。止まったらそこにTがあるか、リストが付きたことを意味する。
--リストが尽きなければ次に行く。
--次から、TをtakeWhileで取得する。再び、dropした物が空でない限りFをtakewhileする。

t_f_parse::String->(Int,[(Bool,Int)])
t_f_parse str = let fst_F = length (takeWhile ('F'==) str) in
                let rest  = dropWhile ('F'==) str          in
                (fst_F,tf_rest rest)

--boolフラグは奇数個かどうかの判定。奇数ならTrue、偶数ならFalse
--これは入力先頭が空かTである事が保証されている。
tf_rest::String->[(Bool,Int)]
tf_rest [] = []
tf_rest str = let b = (1 == mod (length (takeWhile ('T'==) str)) 2) in
              let fs = length (takeWhile ('F'==)  (dropWhile ('T'==) str)) in
              let rest = dropWhile ('F'==) (dropWhile ('T'==) str) in
              (b,fs):tf_rest rest

tf_xy_ls::[(Bool,Int)]->([Int],[Int])
tf_xy_ls [] = ([],[])
tf_xy_ls ((b,v):rest) = let (x,y)= tf_xy_ls rest in
                        if b then (y,v:x) else (v:x,y)

--FTリストから、x,yの移動幅リストを構成する。
tot_ls::String->([Int],[Int])
tot_ls str= let (x_fst,ls) = t_f_parse str in
            let (x,y) = tf_xy_ls ls in
            (x_fst:x,y)



--与えられた自然数リストを全てを足すか引くかしてスコア関数を作る問題を、部分和問題に帰着させる。
--リストを倍にしておき、スコアに予め全てを足しておく。
trans::([Int],Int)->([Int],Int)
trans (ls,sc) = (map (2*) ls,sc + (sum ls))

--注意！x_fstは絶対にたさなきゃいけない。コーナーケースだ。

solver::String->(Int,Int)->Bool
solver str (x,y) = let (xs,ys) = tot_ls str in
                   let (xxs,xx) = trans (tail xs,x) in
                   let (yys,yy) = trans (ys,y) in
                   (sub_total_b xxs (xx-head xs))&&(sub_total_b yys yy)


main::IO()
main=do
  str<-getLine
  xyc<-getLine
  let x:y:[]=map read (words xyc)
  putStr (if solver str (x,y) then "Yes\n" else "No\n")