#include <bits/stdc++.h>
//#include <atcoder/all>
//#include "Z:\2_Src\31_Luzhiles_s.git\template\template.cpp"
using namespace std; //using namespace atcoder;
template<typename T>  using ve=vector<T>; 
using ll=long long; using ld=long double; using str=string; using pint=pair<ll,ll>;
using vll=ve<ll>; using vd=ve<ld>; using vs=ve<str>; using vll2=ve<ve<ll>>; 
#define whole(f,x,...) ([&](decltype((x)) whole) { return (f)(begin(whole), end(whole), ## __VA_ARGS__); })(x)
#define b2e(v) v.begin(),v.end()
#define p2a(v, p) v[p.first][p.second]
#define rep(i,n)  for(ll i=0;i<(n);i++)
#define repi(i,n) for(ll i=(n-1);i>=0;i--)
#define repe(e,v) for(auto e:v)
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
const int MOD=1000000007;
//const int MOD=998244353;

int main() {
    ll nn; cin >> nn;
    //vector<pair<ll,char>> vp1;
    ve<ve<ll>> vv1(3);
    
    rep(i,2*nn) {
        ll a; char b; cin>>a>>b;
        if(b=='R') vv1[0].push_back(a);
        if(b=='G') vv1[1].push_back(a);
        if(b=='B') vv1[2].push_back(a);
    }

    ll ct=0;
    vll odd1,odd2,even;
    // 1. 色ごとの配列を作り、サイズが全て偶数なら0を出力して終了する
    repe(v1,vv1) {
        if(!(v1.size()%2)) {
            even=v1;
        } else {
            ct++;
            if(ct==1) odd1=v1;
            if(ct==2) odd2=v1;
        }
    }
    if(!ct) {
        ll ans=0;
        cout << ans << endl;
        exit(0);
    }

    // 2. 各配列をソートする
    whole( sort, even );
    whole( sort, odd1 );
    whole( sort, odd2 );

    // 3. 2配列の最小絶対誤差を求める関数を使用する(誤差l-rが正ならrを進める、負ならlを進める、ただし配列サイズでクランプ)
    auto err = [&](vll &v1, vll &v2)->ll {
        ll l=0,r=0,mi=INFL;
        while(l<v1.size() && r<v2.size()) {
            ll dif=v1[l]-v2[r];
            mi=min(mi, abs(dif));
            if(l<v1.size() && dif<0) l++;
            else r++;
        }
        return mi;
    };

    // 4. odd1とodd2の最小絶対誤差、odd1,evenとodd2,evenの最小絶対誤差の和について小さい方を取る
    ll ans=min( err(odd1,odd2), err(odd1,even)+err(odd2,even) );
    cout << ans << endl;
    
}

//author: .rod.
//#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <chrono>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <bitset>
#include <cstdio>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <numeric>
#include <sstream>
#include <random>
#include <cassert>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <cstring>
#include <unordered_map>
using namespace std;

#define ll int64_t
#define ld long double
#define ar array
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define for0(i,n) for(int i=0; i<n; i++)
#define for1(i,n) for(int i=1; i<n; i++)
#define for2(i,n) for(int i=2; i<=n; i++)
#define each(x, a) for (auto& x: a)
typedef double dl;

#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)

template<class A> void read(vt<A>& v);
template<class A, size_t S> void read(ar<A, S>& a);
template<class T> void read(T& x) {
    cin >> x;
}
void read(double& d) {
    string t;
    read(t);
    d=stod(t);
}
void read(long double& d) {
    string t;
    read(t);
    d=stold(t);
}
template<class H, class... T> void read(H& h, T&... t) {
    read(h);
    read(t...);
}
template<class A> void read(vt<A>& x) {
    each(a, x)
        read(a);
}
template<class A, size_t S> void read(array<A, S>& x) {
    each(a, x)
        read(a);
}
string to_string(char c) {
    return string(1, c);
}
string to_string(bool b) {
    return b?"true":"false";
}
string to_string(const char* s) {
    return string(s);
}
string to_string(string s) {
    return s;
}
string to_string(vt<bool> v) {
    string res;
    FOR(sz(v))
        res+=char('0'+v[i]);
    return res;
}
template<size_t S> string to_string(bitset<S> b) {
    string res;
    FOR(S)
        res+=char('0'+b[i]);
    return res;
}
template<class T> string to_string(T v) {
    bool f=1;
    string res;
    each(x, v) {
        if(!f)
            res+=' ';
        f=0;
        res+=to_string(x);
    }
    return res;
}
template<class A> void write(A x) {
    cout << to_string(x);
}
template<class H, class... T> void write(const H& h, const T&... t) {
    write(h);
    write(t...);
}
void print() {
    write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
    write(h);
    if(sizeof...(t))
        write(' ');
    print(t...);
}
void DBG() {
    cerr << "]" << endl;
}
template<class H, class... T> void DBG(H h, T... t) {
    cerr << to_string(h);
    if(sizeof...(t))
        cerr << ", ";
    DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif

void solve() {
    int64_t n;
    read(n);
    set<int64_t>dt;
    for(int64_t i = 2; i*i<=n; i++){
        int64_t c = i*i;
        while(c<=n){
            dt.insert(c);
            c*=i;
        }
    }
    print(n-dt.size());
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    cerr << "time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
    return 0;
}
