#include <bits/stdc++.h>
using namespace std;

#ifdef YUCHIKIDEBUG
  #define dump(x)  cerr << #x << " = " << (x) << endl;
  #define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FUNCTION__ << endl;
#else
  #define dump(x) ;
  #define debug(x) ;
#endif // YUCHIKIDEBUG

#define int long long
#define pb push_back
#define pf push_front
#define mp make_pair
#define vi vector<int>
#define vvi vector<vi>

#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define _repr(i,n) repir(i,n,0)
#define repir(i,a,b) for(int i=(int)(a);i>=(int)(b);--i)
#define repr(...) _overload3(__VA_ARGS__,repir,_repr,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define CINV(x,n) rep(temporary_index,n){int cinvtemp; cin >> cinvtemp; x.push_back(cinvtemp); }
#define READV(x,n) rep(temporary_index,n){int cinvtemp; cin >> cinvtemp; x[temporary_index] = cinvtemp; }
#define READMATRIX(x,m,n) rep(temp_matrix,m){READV(x[temp_matrix],n);}
#define REV(x) reverse(all(x))
#define SORT(x) sort(all(x))

template<class ARG>
inline void put(ARG x) { cout << x << endl; }

inline int sqr(int x) { return x * x; }
inline int sqrti(int x) { return (int) sqrt(x); }
inline vi divisors(int x) {
  vi divs = {1};
  rep (i, 2, x) {
    if (x % i == 0) divs.push_back(i);
  }
  return divs;
}
inline vector<pair<int, int>> divpairs (int x) {
  vector<pair<int, int>> divs;
  rep (i, 1, x + 1) {
    if (x % i == 0) divs.push_back(make_pair (i, x / i));
  }
  return divs;
}

/// return the first i in [lb .. ub) where pred(i) holds.
/// if none of the above i satisfies pred, ub is returned.
template <class Predicate>
inline int bin_search(int lb, int ub, Predicate pred) { // return the first i where pred(i) holds.
  while(lb + 1 < ub) {
    int mid = (lb + ub) / 2;
    if (pred(mid)) {
      ub = mid;
    } else {
      lb = mid;
    }
  }
  return pred(lb) ? lb : ub;
}

inline vector<int> to_digits(int i) {
  vector<int> digits;
  while(i >= 10) {
    digits.push_back(i % 10);
    i /= 10;
  }
  digits.push_back(i);

  reverse(digits.begin(), digits.end());
  return digits;
}

template<class T> using matrix = vector<vector<T>>; 

template<class T>
matrix<T> make_matrix(int R, int C, T value) {
  return matrix<T>(R, vector<T>(C, value));
}

template<class T, class F>
inline vector<T> operator >> (vector<T> &v, F f) {
  return f(v);
}
template<class T, class S, class F>
inline vector<S> map(F f, const vector<T> &v) {
  vector<S> res(v.size());
  transform(v.begin(), v.end(), res.begin, f);
  return res;
}

template<class T, class F>
inline vector<T> filter(F f, const vector<T> &v) {
  vector<T> res;
  copy_if(v.begin(), v.end(), back_inserter(res), f);
  return res;
}

template<class T, class S, class F>
inline S fold(F f, S initial, const vector<T> &v) {
  return accumulate(v.begin(), v.end(), initial, f);
}

const long long MAXN = 1e6;
const long long MOD = 1e9+7;
const long long INF = __LONG_LONG_MAX__ / 2;
const double eps = DBL_MIN * 10;

using address = pair<int, int>;

inline int pow(int i, int n) { return (int)pow(i + eps, n); }


template<class T>
inline T& at(matrix<T> &m, address addr) {
  return m[addr.first][addr.second]; 
}
template<class T>
inline pair<T, T> operator + (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first + t2.first, t1.second + t2.second);
}

template<class T>
inline pair<T, T> operator - (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first - t2.first, t1.second - t2.second);
}

template<class T>
inline pair<T, T> operator * (pair<T, T> t1, pair<T, T> t2) {
  return make_pair(t1.first * t2.first, t1.second * t2.second);
}

template<class T>
inline pair<T, T> operator * (T t, pair<T, T> t2) {
  return make_pair(t + t2.first, t+ t2.second);
}

template<class T>
inline bool operator >= (set<T> container, T t) {
  return container.find(t) != container.end();
}

template<class T>
inline bool operator <= (T t, set<T> container) {
  return container.find(t) != container.end();
}

const size_t MAX_S = 8000 + 100;

void show(set<int> reachable_x, set<int> reachable_y) {
  cout << "x:";
  for (auto rx : reachable_x)
    cout << rx << " ";
  cout << "y: ";
  for (auto ry : reachable_y)
    cout << ry << " ";
  cout << endl;
}

signed main() {
  string s;
  int x, y;
  cin >> s >> x >> y;
  set<int> reachable_x;
  set<int> reachable_y;

  reachable_y.insert(0);
  bool has_turned = false;
  bool is_x = true;
  int length = 0;
  for (auto c : s)
  {
    if (c == 'F') {
      length++;
    } else {
      if (! has_turned) {
        reachable_x.insert(length);
        has_turned = true;
      } else if (is_x) {
        set<int> next_x;
        for(auto xpos: reachable_x) {
          next_x.insert(xpos + length);
          next_x.insert(xpos - length);
        }
        reachable_x = next_x;
      } else {
        set<int> next_y;
        for(auto ypos: reachable_y) {
          next_y.insert(ypos + length);
          next_y.insert(ypos - length);
        }
        reachable_y = next_y;
      }
      length = 0;
      is_x = !is_x;
    }
   // cout << c;
   // show(reachable_x, reachable_y);
  }

     if (! has_turned) {
        reachable_x.insert(length);
        has_turned = true;
      } else if (is_x) {
        set<int> next_x;
        for(auto xpos: reachable_x) {
          next_x.insert(xpos + length);
          next_x.insert(xpos - length);
        }
        reachable_x = next_x;
      } else {
        set<int> next_y;
        for(auto ypos: reachable_y) {
          next_y.insert(ypos + length);
          next_y.insert(ypos - length);
        }
        reachable_y = next_y;
      }


  //show(reachable_x, reachable_y);
  cout << ((x <= reachable_x && y <= reachable_y) ? "Yes" : "No") << endl;

  return 0;
}


Measured memory_bytes: 1024