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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using Library;
using static Library.Input;

namespace AtCoderTemplate {
    class ProgramD {
        static void Main () {
            var s = Line;
            int X = NextInt, Y = NextInt;
            var dxs = new List<int>();
            var dys = new List<int>();

            int prev = 0, next = 0, count = 0;
            for(; prev < s.Length; prev = next) {
                while(next < s.Length && s[next] == 'F') next++;
                if(count % 2 == 0) {
                    dxs.Add(next - prev);
                } else {
                    dys.Add(next - prev);
                }
                while(next < s.Length && s[next] == 'T') {
                    next++;
                    count++;
                }
            }

            var xarray = Enumerable.Repeat(int.MaxValue, 20000).ToArray();
            xarray[10000] = -1;
            for(int i = 0; i < dxs.Count; i++) {
                for(int j = 2000; j <= 18000; j++) {
                    if(xarray[j] == i - 1) {
                        xarray[j + dxs[i]] = i;
                        xarray[j - dxs[i]] = i;
                    }
                }
            }

            var yarray = Enumerable.Repeat(int.MinValue, 20000).ToArray();
            yarray[10000] = -1;
            for(int i = 0; i < dys.Count; i++) {
                for(int j = 2000; j <= 18000; j++) {
                    if(yarray[j] == i - 1) {
                        yarray[j + dys[i]] = i;
                        yarray[j - dys[i]] = i;
                    }
                }
            }

            if(xarray[X + 10000] == dxs.Count - 1 && yarray[Y + 10000] == dys.Count - 1) {
                Console.WriteLine("Yes");
            } else {
                Console.WriteLine("No");
            }
        }
    }

}

namespace Library {
    class Input {
        static IEnumerator<string> enumerator = new string[] { }.AsEnumerable ().GetEnumerator ();

        public static string Line => Console.ReadLine ();

        public static string[] StrArr => Line.Split (' ');

        public static int NextInt => int.Parse (NextWord ());

        public static long NextLong => long.Parse (NextWord ());

        public static List<int> IntList => StrArr.Select (int.Parse).ToList ();

        public static List<long> LongList => StrArr.Select (long.Parse).ToList ();

        public static IEnumerable<long[]> TakeLine (int N) {
            return Enumerable.Repeat (0, N).Select (_ => Console.ReadLine ().Split (' ').Select (long.Parse).ToArray ());
        }

        public static string NextWord () {
            while (!enumerator.MoveNext ()) {
                enumerator = StrArr.AsEnumerable ().GetEnumerator ();
            }
            return enumerator.Current;
        }
    }
}

namespace Library {
    
    class Modular {
        public const int mod = 1000000007;
        public readonly long value;
        public Modular (long value) { this.value = value; }
        public static implicit operator Modular (long a) {
            var m = a % mod;
            return new Modular ((m < 0) ? m + mod : m);
        }
        public static Modular operator + (Modular a, Modular b) {
            return a.value + b.value;
        }
        public static Modular operator - (Modular a, Modular b) {
            return a.value - b.value;
        }
        public static Modular operator * (Modular a, Modular b) {
            return a.value * b.value;
        }
        public static Modular Pow (Modular a, int n) {
            switch (n) {
                case 0:
                    return 1;
                case 1:
                    return a;
                default:
                    var p = Pow (a, n / 2);
                    return p * p * Pow (a, n % 2);
            }
        }
        public static Modular operator / (Modular a, Modular b) {
            return a * Pow (b, mod - 2);
        }
        private static readonly List<int> facs = new List<int> { 1 };
        private static Modular Fac (int n) {
            for (int i = facs.Count; i <= n; ++i) {
                facs.Add ((int) (Math.BigMul (facs.Last (), i) % mod));
            }
            return facs[n];
        }
        public static Modular Ncr (int n, int r) {
            return (n < r) ? 0 :
                (n == r) ? 1 :
                Fac (n) / (Fac (r) * Fac (n - r));
        }
        public static explicit operator int (Modular a) {
            return (int) a.value;
        }
    }

}
namespace Library {
    class MyMath {
        public static long Gcd (long a, long b) {
            return b == 0 ? a : Gcd (b, a % b);
        }

        public static long Sqrt (long n) {
            if (n < 0) return 0;
            long a = 0, tmp = 0, b = 0;
            for (int i = 62; i >= 0; i -= 2) {
                tmp = (b << 1) + 1 <= (n >> i) ? 1 : 0;
                a = a << 1 | tmp;
                n -= (((b << 1) + 1) * tmp) << i;
                b = (b << 1) + tmp + tmp;
            }
            return a;
        }

        public static long Nck (int n, int k) {
            if (k == 0) return 1;
            if (n == 0) return 0;
            return n * Nck (n - 1, k - 1) / k;
        }
    }
}

namespace Library {
        public class PriorityQueue<T> {

        readonly List<T> _heap = new List<T> ();
        readonly Comparison<T> _comparison;

        public PriorityQueue (Comparison<T> comparison) {
            _comparison = comparison;
        }

        public PriorityQueue () : this (Comparer<T>.Default.Compare) { }

        public PriorityQueue (IComparer<T> comparer) : this (comparer.Compare) { }

        public void Enqueue (T item) {
            _heap.Add (item);

            int childID = _heap.Count - 1;
            int parentID = (childID - 1) / 2;

            while (childID > 0 && _comparison (_heap[parentID], _heap[childID]) > 0) {
                Swap (parentID, childID);
                childID = parentID;
                parentID = (parentID - 1) / 2;
            }
        }

        public T Dequeue () {
            var first = _heap.First ();
            _heap[0] = _heap.Last ();
            _heap.RemoveAt (_heap.Count - 1);

            int parentID = 0;
            int childID = parentID * 2 + 2;
            if (childID >= _heap.Count || _comparison (_heap[childID], _heap[childID - 1]) > 0) childID--;

            while (childID < _heap.Count && _comparison (_heap[parentID], _heap[childID]) > 0) {
                Swap (parentID, childID);
                parentID = childID;
                childID = parentID * 2 + 2;
                if (childID >= _heap.Count || _comparison (_heap[childID], _heap[childID - 1]) > 0) childID--;
            }

            return first;
        }

        void Swap (int parent, int child) {
            var tmp = _heap[parent];
            _heap[parent] = _heap[child];
            _heap[child] = tmp;
        }

        public T Peek () { return _heap[0]; }
        public int Count => _heap.Count;
        public bool Any () { return _heap.Any (); }
        public List<T> Data => _heap;
    }
}

namespace Library {
    
    public class UnionFind {
        public int[] Parents { get; set; }
        public UnionFind (int size) {
            Parents = Enumerable.Repeat (-1, size).ToArray ();
        }

        public int Find (int num) {
            if (Parents[num] < 0) return num;

            Parents[num] = Find (Parents[num]);
            return Parents[num];
        }

        public int Size (int num) {
            return -Parents[Find (num)];
        }

        public bool Same (int a, int b) {
            return Find (a) == Find (b);
        }

        public void Unite (int a, int b) {
            int x = Find (a), y = Find (b);

            if (Size (x) > Size (y)) {
                Parents[x] += Parents[y];
                Parents[y] = x;
            } else {
                Parents[y] += Parents[x];
                Parents[x] = y;
            }
        }
    }
}