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

#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
 
#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};
 
    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
 
#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };
 
    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };
 
    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };
 
    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };
 
    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };
 
    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}
 
use std::cmp::Ordering;
 
/// Equivalent to std::lowerbound and std::upperbound in c++
pub trait BinarySearch<T> {
    fn lower_bound(&self, &T) -> usize;
    fn upper_bound(&self, &T) -> usize;
}
 
impl<T: Ord> BinarySearch<T> for [T] {
    fn lower_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
 
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less => {
                    low = mid + 1;
                }
                Ordering::Equal | Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
 
    fn upper_bound(&self, x: &T) -> usize {
        let mut low = 0;
        let mut high = self.len();
 
        while low != high {
            let mid = (low + high) / 2;
            match self[mid].cmp(x) {
                Ordering::Less | Ordering::Equal => {
                    low = mid + 1;
                }
                Ordering::Greater => {
                    high = mid;
                }
            }
        }
        low
    }
}
 
 
 
 
 
 
use std::cmp;
use std::cmp::min;
use std::collections::BTreeMap;
use std::process;
use std::cmp::Ord;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use std::collections::BTreeSet;
use std::mem;
 
#[derive(PartialEq, Eq)]
pub struct point(i64, i64, i64);
impl Ord for point {
    fn cmp(&self, other: &point) -> Ordering {
        self.0.cmp(&other.0)
    }
}
 
impl PartialOrd for point {
    fn partial_cmp(&self, other: &point) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
/*
impl PartialEq for point {
    fn eq(&self, other: &point) -> bool {
        self.0 == other.0
    }
}
impl Eq for point {
    fn eq(&self, other: &point) -> bool {
        self.0 == other.0
    }s
}*/
type P = (i64 , i64);
fn bfs(start:&P, goal:&P, map:&Vec<Vec<char>>) -> i64 {
        let dx = vec![1, 0, -1, 0];
        let dy = vec![0, 1, 0, -1];
        let s = (start.0, start.1);
        let g = (goal.0 , goal.1);
        let mut queue:VecDeque<P> = VecDeque::new();
        let mut d:Vec<Vec<i64>> = Vec::new();
        for i in 0..map.len(){
            d.push(Vec::new());
            for j in 0..map[i].len(){
                d[i].push(30000000);
            }
        }
        queue.push_back((s.0, s.1));
        d[s.0 as usize][s.1 as usize] = 0;
        while(queue.len()!=0){
            let mut p:P = queue[0];
            queue.pop_front();
            if p.0 == g.0 && p.1 == g.1{break;}
            for i in 0..4{
                let nx = p.0 + dx[i];
                let ny = p.1 + dy[i];
                if (0<=nx && nx <map.len() as i64 && 0<=ny &&ny<map[0].len() as i64 && map[nx as usize][ny as usize]!='#' && d[nx as usize][ny as usize] == 30000000 ){
                    queue.push_back((nx, ny));
                    d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize] + 1;
                }
            }
 
        }
        d[goal.0 as usize][goal.1 as usize]
}
 
fn bfs01(start:&P, goal:&P, map:&Vec<Vec<char>>) -> i64 {
        let dx = vec![1, 0, -1, 0];
        let dy = vec![0, 1, 0, -1];
        let s = (start.0, start.1);
        let g = (goal.0 , goal.1);
        let mut queue:VecDeque<P> = VecDeque::new();
        let mut d:Vec<Vec<i64>> = Vec::new();
        for i in 0..map.len(){
            d.push(Vec::new());
            for j in 0..map[i].len(){
                d[i].push(30000000);
            }
        }
        queue.push_back((s.0, s.1));
        d[s.0 as usize][s.1 as usize] = 0;
        while(queue.len()!=0){
            let mut p:P = queue[0];
            queue.pop_front();
            if p.0 == g.0 && p.1 == g.1{break;}
            for i in 0..4{
                let nx = p.0 + dx[i];
                let ny = p.1 + dy[i];
                if (0<=nx && nx <map.len() as i64 && 0<=ny &&ny<map[0].len() as i64 && d[nx as usize][ny as usize] == 30000000 ){
                    if map[nx as usize][ny as usize] == '#'{
                        queue.push_back((nx, ny));
                        d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize] + 1;
                    }
                    else{
                        queue.push_front((nx, ny));
                        d[nx as usize][ny as usize] = d[p.0 as usize][p.1 as usize];
                    }
                }
            }
 
        }
        d[goal.0 as usize][goal.1 as usize]
}
struct UnionFind_W{
    par:Vec<usize>,
    rank:Vec<usize>,
    size:Vec<usize>,
    diff_weight:Vec<i64>,    
}
impl UnionFind_W{
    fn init(n:usize) -> UnionFind_W{
        let mut par = vec![0;n];
        for i in 0..n{
            par[i] = i;    
        }
        UnionFind_W{
            par:par,
            rank:vec![0;n], 
            size:vec![1;n], 
            diff_weight:vec![0i64;n],
        }
    }
    fn find(&mut self, x:usize) ->usize{
        if(self.par[x] == x){
            x    
        }
        else{
            let p = self.par[x];
            let r = self.find(p);
            self.diff_weight[x] += self.diff_weight[p];
            self.par[x] = r;
            r
        }
    }
    fn weight(&mut self,x:usize)->i64{
        self.find(x);
        self.diff_weight[x]
    }
    fn diff(&mut self, x:usize, y:usize)->i64{
        let res = self.weight(x) - self.weight(y);
        res
    }
    fn same(&mut self, a:usize, b:usize)->bool{
        self.find(a) == self.find(b)    
    }
    fn unite(&mut self, xx:usize, yy:usize, ww:i64) -> bool{
        let mut w = ww.clone();
        let mut x = xx.clone();
        let mut y = yy.clone();

        w += self.weight(x);
        w -= self.weight(y);
        x = self.find(x);
        y = self.find(y);
        if (x == y) {return false;}
        if self.rank[x] < self.rank[y]{
            mem::swap(&mut x, &mut y);
            w = -w;
        }

        if self.rank[x] == self.rank[y]{
            self.rank[y] += 1;
        }
        self.par[y] = x;
        self.size[x] += self.size[y];
        self.diff_weight[y] = w;
        return true;
    }
    fn check_size(&mut self, a:usize) -> usize{
        let x = self.find(a);
        let s = self.size[x];
        s    
    }
}





struct UnionFind{
    par:Vec<usize>,
    rank:Vec<usize>,
    size:Vec<usize>,    
}
impl UnionFind{
    fn init(n:usize) -> UnionFind{
        let mut par = vec![0;n];
        for i in 0..n{
            par[i] = i;    
        }
        UnionFind{
            par:par,
            rank:vec![0;n], 
            size:vec![1;n], 
        }
    }
    fn find(&mut self, x:usize) ->usize{
        if(self.par[x] == x){
            x    
        }
        else{
            let p = self.par[x];
            let res = self.find(p);
            self.par[x] = res;
            res
        }
    }
    fn same(&mut self, a:usize, b:usize)->bool{
        self.find(a) == self.find(b)    
    }
    fn unite(&mut self, a:usize, b:usize){
        let x = self.find(a);
        let y = self.find(b);
        if x != y{
            if (self.rank[x] < self.rank[y]){
                self.par[x] = y;
                self.size[y] += self.size[x];
            }
            else{
                self.par[y] = x;
                self.size[x] += self.size[y];
                if(self.rank[x] == self.rank[y]){ self.rank[x]+=1;}
            }
        }
    }
    fn check_size(&mut self, a:usize) -> usize{
        let x = self.find(a);
        let s = self.size[x];
        s    
    }
}
fn gcd(a:usize, b:usize)->usize{
    if b==0{return a;}
    gcd(b, a%b)
}
fn lcm(a: usize, b: usize) -> usize {
    a / gcd(a, b) * b
}
fn extgcd(a:usize, b:usize, x:&mut usize, y:&mut usize)->usize{
    let mut d = a;
    if b != 0{
        d = extgcd(b, a%b, y, x);
        *y -= (a/b) * (*x);    
    }    
    else{
        *x = 1;
        *y = 0;
    }
    d
}

use std::ops::{Deref, DerefMut, Index, IndexMut};
use std::any::{Any, TypeId};

struct vec2<T>(Vec<T>);
 
impl<T> Deref for vec2<T> {
    type Target = Vec<T>;
    fn deref(&self) -> &Vec<T> {
        &self.0
    }
}
 
impl<T> DerefMut for vec2<T> {
    fn deref_mut(&mut self) -> &mut Vec<T> {
        &mut self.0
    }
}
impl<T> Index<i64> for vec2<T> {
    type Output = T;
    fn index(&self, index: i64) -> &T {
        &self.0[index as usize]
    }
}
 
impl<T> IndexMut<i64> for vec2<T> {
    fn index_mut(&mut self, index: i64) -> &mut T {
        &mut self.0[index as usize]
    }
}

fn segment_sieve(a:usize, b:usize) -> Vec<bool>{
    let mut is_prime= vec![false; b+1];
    let mut is_prime_small= vec![false; b+1];
    for i in 0..b{
        if i*i>=b{break;}    
        is_prime_small[i] = true;
    }
    for i in 0..b{
        if i>=b-a{break;}
        is_prime[i] = true;    
    }
    for i in 2..b{
        if i*i>=b{break;}
        if is_prime_small[i] == true{


            let mut j = 2*i;
            while(j*j<b){
                is_prime_small[j] = false;
                j+=i;
            }
            
            j = cmp::max(2, ((a+i-1)/i)*i);
            while(j<b){
                is_prime[j-a] = false;
                j+=i;    
            }    
        }    
    }
    is_prime


}
fn sieve(n:usize) -> (Vec<bool>, Vec<usize>){
    let mut p:usize = 0;
    let mut is_prime = vec![false; n+1];
    let mut prime = Vec::new();
    for i in 0..n+1{
        is_prime[i] = true;
    }
    is_prime[0] = false;
    is_prime[1] = false;
    for i in 2..n+1{
        if is_prime[i]{
            prime.push(i as usize);
            let mut j = 2*i;
            while(j<=n){
                is_prime[j] = false;
                j+=i;
            }
        }
    }
    (is_prime, prime)
    
}
fn divisor(n:usize) -> Vec<usize>{
    let mut res:Vec<usize> = Vec::new(); 
    for i in 1..n+1{
        if i*i>n{break;}
        if n%i == 0{
            res.push(i);
            if i != n/i{
                res.push(n/i);    
            }    
        }    
    }
    res
}

fn prime_factor(nn:usize) -> HashMap<usize, usize>{
    let mut res:HashMap<usize, usize> = HashMap::new();
    let mut n = nn.clone();
    for i in 2..n+1{
        if i*i>n{break;}
        while(n%i == 0){
            *res.entry(i).or_insert(0) += 1;
            n/=i;    
        }    
    }
    if (n != 1){res.insert(n,1);}
    res
}

use std::collections::BinaryHeap;

#[derive(PartialEq)]
struct mf(i64);

impl Eq for mf {}

impl PartialOrd for mf {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl Ord for mf {
    fn cmp(&self, other: &mf) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}




#[derive(Copy, Clone, Eq, PartialEq)]
struct edge1{from:usize, to:usize, cost:i64}
impl Ord for edge1 {
    fn cmp(&self, other: &edge1) -> Ordering {
        other.cost.cmp(&self.cost)
    }
}

impl PartialOrd for edge1 {
    fn partial_cmp(&self, other: &edge1) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}
fn kruskal(es:&mut Vec<edge1>, n:usize) -> i64{
    es.sort();
    es.reverse();
    let mut uf =  UnionFind::init(n);
    let mut res = 0;
    for i in 0..es.len(){
        let e = es[i];
        if uf.same(e.from, e.to) == false{
            uf.unite(e.from, e.to);
            res += e.cost;
        }

    }
    res
}




fn bellman_ford(s:usize, n:usize, inf:i64, es:&Vec<edge1>) -> Vec<i64>{
    let mut d = vec![inf;n];
    d[s] = 0;
    for j in 0..n-1{
        let mut update = false;
        for i in 0..es.len(){
            let e = es[i];
            if (d[e.from] != inf && d[e.to] > d[e.from] + e.cost){
                d[e.to] = d[e.from] + e.cost;
            }
                
        }
    }

    d
}
fn find_negative_loop(n:usize, es:&Vec<edge1>, inf:i64) -> bool{
    let mut d = vec![0;n];
    for i in 0..n{
        for j in 0..es.len(){
            let e = es[j];
            if d[e.to] > d[e.from] + e.cost{
                d[e.to] = d[e.from] + e.cost;
                if (i == n-1) {return false;}
            }
        }
    }
    return true;
}
#[derive(Copy, Clone, Eq, PartialEq)]
struct State{
    cost: i64,
    position: usize,
}
impl Ord for State {
    fn cmp(&self, other: &State) -> Ordering {
        // Notice that the we flip the ordering on costs.
        // In case of a tie we compare positions - this step is necessary
        // to make implementations of `PartialEq` and `Ord` consistent.
        other.cost.cmp(&self.cost)
    }
}

// `PartialOrd` needs to be implemented as well.
impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

struct edge2{
    to:usize,
    cost:i64,
}
fn dijkstra(adj_list: &Vec<Vec<edge2>>, start:usize, inf:i64) -> Vec<i64>{
    let mut d= vec![inf;adj_list.len()];
    let mut heap = BinaryHeap::new();
    d[start] = 0;
    heap.push(State{cost: 0, position: start });
    while (heap.len() != 0){
        let p = heap.pop().unwrap();
        let v = p.position;
        if(d[v] < p.cost) {continue;}
        for i in 0..adj_list[v].len(){
            let e = &adj_list[v][i];
            if d[e.to] > d[v] + e.cost{
                d[e.to] = d[v] + e.cost;
                heap.push(State{cost:d[e.to], position:e.to});
            }
        }
            
    }
    d
        
}
// no verify
fn prim(n:usize, cost:&Vec<Vec<i64>>, inf:i64, s:usize) -> i64{
    let mut mincost = vec![inf;n];
    let mut used = vec![false;n];
    mincost[s] = 0;
    let mut res = 0;
    while(true){
        let mut v:i64 = -1;
        for  u in 0..n{
            if (used[u] == false && (v == -1 || mincost[u] <mincost[v as usize])){v = u.clone() as i64;}
        }
        if v == -1{break;}
        used[v as usize] = true;
        res += mincost[v as usize];
        for u in 0.. n{
            mincost[u] = cmp::min(mincost[u], cost[v as usize][u]);
        }
    }
    return res;
}
//
fn find_negative_loop2(n:usize, es:&Vec<edge1>, inf:i64, dist:&mut Vec<i64>) -> Vec<bool>{
    let mut neg = vec![false;n];
    for i in 0..n{
        for j in 0..es.len(){
            
            let e = es[j];
            if dist[e.from] == inf{continue;}

            if dist[e.to] > dist[e.from] + e.cost{
                dist[e.to] = dist[e.from] + e.cost;
                neg[e.to] = true;
            }
            if neg[e.from] == true{ neg[e.to] = true;}
        }
    }
    return neg;
}
fn mod_for_big_int(k:Vec<char>, C:usize)-> usize{
    let mut k_mod_C = 0;
    for i in 0..k.len(){
        k_mod_C = (k_mod_C*10+(k[i] as usize - 48) as usize)%C;
    }
    k_mod_C
}
/*
fn imos() {
    input!{
        n:usize,
        m:usize,
        q:usize,
        lr:[(usize, usize);m],
        pq:[(usize, usize);q],
    }
    let mut v = vec![vec![0;n+2];n+2];
    for i in 0..m{
        v[lr[i].0][lr[i].1] +=1;
    }
    
    for i in 1..n+2{
        for j in 1..n+2{

            v[i][j] +=v[i-1][j];
        }
    }
    for i in 1..n+2{
        for j in 1..n+2{

            v[i][j] +=v[i][j-1];
        }
    }
    for i in 0..q{
        println!("{}", v[pq[i].1][pq[i].1] - v[pq[i].0-1][pq[i].1] - v[pq[i].1][pq[i].0-1] + v[pq[i].0-1][pq[i].0-1] );
    }
}
*/
fn main(){
    input!{
        s:chars,
        x1:i64,
        y1:i64,
    }
    let mut x = x1.abs() as usize;
    let mut y = y1.abs() as usize;
    let mut now = 0;
    let mut a = Vec::new();
    let mut b= Vec::new();
    let mut af = true;
    for i in 0..s.len(){
        if s[i] =='T'{
            if af{
                a.push(now);
                now = 0;
                af = false;
            }
            else{
                b.push(now);
                now = 0;
                af = true;
            }
        }
        else{
            now += 1;
        }
    }
    if af{
        a.push(now);
    }
    else{
        b.push(now);
    }
    a.sort();
    b.sort();
    a.reverse();
    b.reverse();
    let dt = 16001;
    let mut dp = vec![-1;dt];

    dp[8000] = 0;
    for i in 0..a.len(){
        let mut tmp2 = vec![-1;dt];
        for j in 0..dt{
            if dp[j]==0{
                tmp2[j+a[i]] = 0;
                tmp2[j-a[i]] = 0;
            }
        }
        mem::swap(&mut tmp2, &mut dp);

    }
    if dp[x+dt/2] == 0{
        af = true;
    }
    else{
        af= false;
    }
    dp = vec![-1;dt];
    dp[8000] = 0;
    for i in 0..b.len(){
        let mut tmp2 = vec![-1;dt];
        for j in 0..dt{
            if dp[j]==0{
                tmp2[j+b[i]] = 0;
                tmp2[j-b[i]] = 0;
            }
        }
        mem::swap(&mut tmp2, &mut dp);

    }
    if af && dp[y+dt/2] >= 0{
        println!("Yes");
    }
    else{
        println!("No");
    }
    



    
}