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 Java (OpenJDK 11.0.6) (judge verdict: Wrong Answer)

import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

 
public class Main {
	static final long MOD1=1000000007;
	static final long MOD2=998244353;
	public static void main(String[] args) {
		PrintWriter out = new PrintWriter(System.out);
		InputReader sc=new InputReader(System.in);
		char[] cs=sc.next().toCharArray();
		int x=sc.nextInt();
		int y=sc.nextInt();
		boolean[][] dpx=new boolean[cs.length+1][16001];//右、左、縦
		dpx[0][8000]=true;
		boolean[][] dpy=new boolean[cs.length+1][16001];//上、下、横
		dpy[0][8000]=true;
		int c=0;
		for (int i = 1; i < dpx.length; i++) {
			if (c==0) {
				if (cs[i-1]=='F') {
					for (int j = 0; j <= 16000; j++) {
						if(j-1>=0)dpx[i][j]=dpx[i-1][j-1];
						dpy[i][j]=dpy[i-1][j];
					}
				}else {
					for (int j = 0; j <= 16000; j++) {
						dpx[i][j]=dpx[i-1][j];
						dpy[i][j]=dpy[i-1][j];
					}
					c++;
				}
			}else if (c%2==0) {
				if (cs[i-1]=='F') {
					for (int j = 0; j <= 16000; j++) {
						if(j-1>=0)dpx[i][j]|=dpx[i-1][j-1];
						if(j+1<=16000)dpx[i][j]|=dpx[i-1][j+1];
						dpy[i][j]=dpy[i-1][j];
					}
				}else {
					for (int j = 0; j <= 16000; j++) {
						dpx[i][j]=dpx[i-1][j];
						dpy[i][j]=dpy[i-1][j];
					}
					c++;
				}
			}else {
				if (cs[i-1]=='F') {
					for (int j = 0; j <= 16000; j++) {
						dpx[i][j]=dpx[i-1][j];
					}
					for (int j = 0; j <= 16000; j++) {
						if(j-1>=0)dpy[i][j]|=dpy[i-1][j-1];
						if(j+1<=16000)dpy[i][j]|=dpy[i-1][j+1];
					}
				}else {
					for (int j = 0; j <= 16000; j++) {
						dpx[i][j]=dpx[i-1][j];
						dpy[i][j]=dpy[i-1][j];
					}
					c++;
				}
			}
		}
		if (dpx[cs.length][x+8000]&&dpy[cs.length][y+8000]) {
			System.out.println("Yes");
			return;
		}
		System.out.println("No");
	}
		static class InputReader { 
		private InputStream in;
		private byte[] buffer = new byte[1024];
		private int curbuf;
		private int lenbuf;
		public InputReader(InputStream in) {
			this.in = in;
			this.curbuf = this.lenbuf = 0;
		}
 
		public boolean hasNextByte() {
			if (curbuf >= lenbuf) {
				curbuf = 0;
				try {
					lenbuf = in.read(buffer);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return false;
			}
			return true;
		}
 
		private int readByte() {
			if (hasNextByte())
				return buffer[curbuf++];
			else
				return -1;
		}
 
		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}
 
		private void skip() {
			while (hasNextByte() && isSpaceChar(buffer[curbuf]))
				curbuf++;
		}
 
		public boolean hasNext() {
			skip();
			return hasNextByte();
		}
 
		public String next() {
			if (!hasNext())
				throw new NoSuchElementException();
			StringBuilder sb = new StringBuilder();
			int b = readByte();
			while (!isSpaceChar(b)) {
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}
 
		public int nextInt() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public long nextLong() {
			if (!hasNext())
				throw new NoSuchElementException();
			int c = readByte();
			while (isSpaceChar(c))
				c = readByte();
			boolean minus = false;
			if (c == '-') {
				minus = true;
				c = readByte();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res = res * 10 + c - '0';
				c = readByte();
			} while (!isSpaceChar(c));
			return (minus) ? -res : res;
		}
 
		public double nextDouble() {
			return Double.parseDouble(next());
		}
 
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public long[] nextLongArray(int n) {
			long[] a = new long[n];
			for (int i = 0; i < n; i++)
				a[i] = nextLong();
			return a;
		}
 
		public char[][] nextCharMap(int n, int m) {
			char[][] map = new char[n][m];
			for (int i = 0; i < n; i++)
				map[i] = next().toCharArray();
			return map;
		}
	}
}