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)

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UnboxedTuples #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE MultiWayIf #-}

import Control.Monad
import Control.Monad.ST
import Control.Monad.State
import Control.Applicative
import Control.Arrow
import Data.List
import Data.Array
import Data.Array.IO
import Data.Maybe
import Data.Bits
import Data.Ord
import Data.Ratio
import Data.Int
import Data.Char
import qualified Data.ByteString.Char8 as BS
import qualified Data.Set as Set
import Data.Tuple
import Data.Function
import Text.Printf
import Debug.Trace
import Numeric

modifyArray arr i f = readArray arr i >>= \x -> writeArray arr i (f x)

listToTuple2 [a,b] = (a,b)
listToTuple3 [a,b,c] = (a,b,c)
listToTuple4 [a,b,c,d] = (a,b,c,d)
listToTuple5 [a,b,c,d,e] = (a,b,c,d,e)

getWords = getLine >>= return . words

readIntBS = fst . fromJust . BS.readInt

for = flip map

main :: IO ()
main = do
  s <- getLine
  (x,y) <- listToTuple2 . map read . words <$> getLine :: IO (Int,Int)

  let
    (xs,ys) = splitByIndexOddEven $ splitByT s
    len = length s

  dpx <- newArray ((0,-len),(length xs,len)) False :: IO (IOUArray (Int,Int) Bool)
  dpy <- newArray ((0,-len),(length ys,len)) False :: IO (IOUArray (Int,Int) Bool)

  writeArray dpx (1,0) True
  forM_ (zip [2..] (tail xs)) $ \(i,d) -> do  
    forM_ [-len..len] $ \x -> do
      a <- if x-d >= -len then readArray dpx (i-1,abs (x-d)) else return False
      b <- if x+d <= len then readArray dpx (i-1,x+d) else return False
      writeArray dpx (i,x) (a || b)

  writeArray dpy (0,0) True
  forM_ (zip [1..] ys) $ \(i,d) -> do
    forM_ [0..len] $ \y -> do
      a <- if y-d >= -len then readArray dpy (i-1,abs (y-d)) else return False
      b <- if y+d <= len then readArray dpy (i-1,y+d) else return False
      writeArray dpy (i,y) (a || b)

  putStrLn =<< (\a b -> if a && b then "Yes" else "No") <$> readArray dpx (length xs,abs (x-head xs)) <*> readArray dpy (length ys,abs y)
  
  where
    splitByT [] = []
    splitByT xs = length a : splitByT (if null b then b else tail b)
      where (a,b) = span (/='T') xs

    splitByIndexOddEven xs = aux xs 1
      where
        aux [] _ = ([],[])
        aux (x:xs) n
          | odd n = first (x:) $ aux xs (n+1)
          | even n = second (x:) $ aux xs (n-1)