Problem:
Score : 300 points

Problem Statement

We have a string X, which has an even number of characters. Half the characters are S, and the other half are T.

Takahashi, who hates the string ST, will perform the following operation 10^{10000} times:

Among the occurrences of ST in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing.

Find the eventual length of X.

Constraints

2 ≦ |X| ≦ 200,000

The length of X is even.

Half the characters in X are S, and the other half are T.

Partial Scores

In test cases worth 200 points, |X| ≦ 200.

Input

The input is given from Standard Input in the following format:

X

Output

Print the eventual length of X.

Sample Input 1

TSTTSS

Sample Output 1

4

In the 1-st operation, the 2-nd and 3-rd characters of TSTTSS are removed.
X becomes TTSS, and since it does not contain ST anymore, nothing is done in the remaining 10^{10000}-1 operations.
Thus, the answer is 4.

Sample Input 2

SSTTST

Sample Output 2

0

X will eventually become an empty string: SSTTST ⇒ STST ⇒ ST ⇒ ``.

Sample Input 3

TSSTTTSS

Sample Output 3

4

X will become: TSSTTTSS ⇒ TSTTSS ⇒ TTSS.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.*;
import java.util.*;
import java.util.Stack;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	       InputReader in = new InputReader(System.in);
	       PrintWriter w = new PrintWriter(System.out);
		//		Scanner sc = new Scanner(System.in);
//		String s = sc.nextLine();
		Stack st = new Stack();
		char[] ch = in.readString().toCharArray();
		for (int i=0;i<ch.length;i++){
			if (st.isEmpty()){
				if (ch[i]=='S'){
					st.push("S");
				}
				else{
					st.push("T");
				}
			}
			else{
				if (ch[i]=='S'){
					st.push("S");
				}
				else if (ch[i]=='T'&& st.peek()=="S"){
						st.pop();
				}
				else{
					st.push('T');
				}
			}			
		}
		 w.println(st.size());
		 w.close();
	}
	  static class InputReader {
		  
	        private final InputStream stream;
	        private final byte[] buf = new byte[8192];
	        private int curChar, snumChars;
	        private SpaceCharFilter filter;
	 
	        public InputReader(InputStream stream) {
	            this.stream = stream;
	        }
	 
	        public int snext() {
	            if (snumChars == -1)
	                throw new InputMismatchException();
	            if (curChar >= snumChars) {
	                curChar = 0;
	                try {
	                    snumChars = stream.read(buf);
	                } catch (IOException e) {
	                    throw new InputMismatchException();
	                }
	                if (snumChars <= 0)
	                    return -1;
	            }
	            return buf[curChar++];
	        }
	 
	        public int nextInt() {
	            int c = snext();
	            while (isSpaceChar(c)) {
	                c = snext();
	            }
	            int sgn = 1;
	            if (c == '-') {
	                sgn = -1;
	                c = snext();
	            }
	            int res = 0;
	            do {
	                if (c < '0' || c > '9')
	                    throw new InputMismatchException();
	                res *= 10;
	                res += c - '0';
	                c = snext();
	            } while (!isSpaceChar(c));
	            return res * sgn;
	        }
	 
	        public long nextLong() {
	            int c = snext();
	            while (isSpaceChar(c)) {
	                c = snext();
	            }
	            int sgn = 1;
	            if (c == '-') {
	                sgn = -1;
	                c = snext();
	            }
	            long res = 0;
	            do {
	                if (c < '0' || c > '9')
	                    throw new InputMismatchException();
	                res *= 10;
	                res += c - '0';
	                c = snext();
	            } while (!isSpaceChar(c));
	            return res * sgn;
	        }
	 
	        public int[] nextIntArray(int n) {
	            int a[] = new int[n];
	            for (int i = 0; i < n; i++) {
	                a[i] = nextInt();
	            }
	            return a;
	        }
	 
	        public String readString() {
	            int c = snext();
	            while (isSpaceChar(c)) {
	                c = snext();
	            }
	            StringBuilder res = new StringBuilder();
	            do {
	                res.appendCodePoint(c);
	                c = snext();
	            } while (!isSpaceChar(c));
	            return res.toString();
	        }
	 
	        public String nextLine() {
	            int c = snext();
	            while (isSpaceChar(c))
	                c = snext();
	            StringBuilder res = new StringBuilder();
	            do {
	                res.appendCodePoint(c);
	                c = snext();
	            } while (!isEndOfLine(c));
	            return res.toString();
	        }
	 
	        public boolean isSpaceChar(int c) {
	            if (filter != null)
	                return filter.isSpaceChar(c);
	            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	        }
	 
	        private boolean isEndOfLine(int c) {
	            return c == '\n' || c == '\r' || c == -1;
	        }
	 
	        public interface SpaceCharFilter {
	            public boolean isSpaceChar(int ch);
	        }
	    }
}