/*************************************************************************
 *                                                                       *
 *                       Pogromcy Algorytmów 2004                        *
 *                                                                       *
 *   Rozwiązanie zadania: Tańce Gordyjskie Krzyśków                      *
 *   Plik:                tan.cpp                                        *
 *   Autor:               Krzysztof Onak                                 *
 *************************************************************************/

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define FORD(i,a,b) for(int i=(a);i>=(b);--i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define ALL(x) (x).begin(),(x).end()
#define VAR(v,init) __typeof(init) v=init
#define FOREACH(i,c) for(VAR(i,(c).begin());i!=(c).end();++i)

template<class T>
inline int size(const T&a) { return a.size(); }

const int INF = 1000000000;

//********************************************************

class Integer {
    static const int BASE = 1000000000;
    bool minus;
    vector<int> n;
    
    bool biggerAbs(const Integer &second) const {
	if (size(n) != size(second.n))
	    return size(n) > size(second.n);
	FORD(i, size(n) - 1, 0) {
	    if (n[i] != second.n[i])
		return n[i] > second.n[i];
	}
	return false;
    }
    
    void addAbs(const Integer &second) {
	int r = 0;
	int i = 0;
	if (size(second.n) > size(n))
	    n.resize(size(second.n), 0);
	for(i = 0; i < size(second.n); ++i) {
	    r += n[i] + second.n[i];
	    n[i] = r % BASE;
	    r /= BASE;
	}
	while (r != 0) {
	    if (i == size(n)) n.push_back(0);
	    r += n[i];
	    n[i] = r % BASE;
	    r /= BASE;
	    ++i;
	}
    }
    
    void subAbs(const Integer &second) {
	int r = 0;
	int i = 0;
	for(i = 0; i < size(second.n); ++i) {
	    r += n[i] - second.n[i];
	    if (r < 0) {
		r += BASE;
		n[i] = r;
		r = -1;
	    } else {
		n[i] = r;
		r = 0;
	    }
	}
	while (r != 0) {
	    r += n[i];
	    if (r < 0) {
		r += BASE;
		n[i] = r;
		r = -1;
	    } else {
		n[i] = r;
		r = 0;
	    }
	    
	    ++i;
	}
	i = size(n) - 1;
	while(i >= 0 && n[i] == 0) {
	    n.pop_back(); 
	    --i;
	}
    }
    
public:
    Integer(int i) {
	minus = i < 0;
	if (i < 0) i = -i; // nie zawsze działa, ale co tam
	while(i != 0) {
	    n.push_back(i % BASE);
	    i /= BASE;
	}
    }
    
    Integer() {}
    
    Integer(const Integer &second) : minus(second.minus), n(second.n) {}
    
    void operator+=(const Integer &plus) {
	if (minus == plus.minus) {
	    addAbs(plus);
	} else {
	    if (biggerAbs(plus)) {
		subAbs(plus);
	    } else {
		Integer tmp(plus);
		tmp.subAbs(*this);
		minus = !minus;
		swap(tmp.n, n);
	    }
	}
    }
    
    void negate() {
	minus = !minus;
    }
        
    bool isZero() {
	return size(n) == 0;
    }
    
    bool isNegative() {
	return !isZero() && minus;
    }

    bool isPositive() {
	return !isZero() && !minus;
    }
    
    void pokaz() {
	printf("%c ", minus ? '-' : '+');
	REP(i, size(n)) printf("%d ", n[i]);
	printf("\n");
    }
};


struct State {
    Integer l, m;

    State() : l(0), m(1) {}
    
    void operS() {
	l += m;
    }
    
    void operR() {
	swap(l, m);
	if (m.isNegative())
	    m.negate();
	else
	    l.negate();
    }
};

int rozplacz(State &s)
{
  int wynik = 0;
  
  while (!s.l.isZero()) {
    ++wynik;
    //s.l.pokaz();
    //s.m.pokaz();
    //printf("\n");
    //printf("%d\n", wynik);

    if (s.l.isNegative() && !(s.m.isZero()))
	s.operS();
    else
	s.operR();
  }
  return wynik;
}

int main()
{
  int i, n;
  State s;
  scanf("%d", &n);
  while (getchar() != '\n');
  for (i = 0; i < n; i++) {
    if (getchar() == 'S') {
      s.operS();
    } else { /* R */
      s.operR();
    }
  }
  printf("%d\n", rozplacz(s));
}
