#include <bits/stdc++.h>
#define INPUT_FILE "./io/test.in"
constexpr bool Interactive = false;
// Author: Narut Sereewattanawoot
#pragma region
using namespace std;
namespace Narut {
template <class T> using TupleSize = tuple_size<remove_cv_t<remove_reference_t<T>>>;

template <class, class = void> struct IsIterable : false_type {};
template <class T>
struct IsIterable<T, decltype((void)std::begin(declval<T &>()))> : true_type {};

template <class, class = void> struct IsTuple : false_type {};
template <class T> struct IsTuple<T, decltype((void)TupleSize<T>::value)> : true_type {};

template <class Os, Os os, char TupleSep = ' ', char TupleEnd = '\n'> struct Writer {
  template <class, class = void> struct IsDefault : false_type {};
  template <class T>
  struct IsDefault<T, decltype((void)(os << declval<T &>()))> : true_type {};
  template <class, class = void> struct Space { static constexpr char value = ' '; };
  template <class T>
  struct Space<T, enable_if_t<!IsDefault<T>::value and IsIterable<T>::value>> {
    static constexpr char value = '\n';
  };
  template <class T>
  struct Space<
      T, enable_if_t<!IsDefault<T>::value and !IsIterable<T>::value and IsTuple<T>::value>> {
    static constexpr char value = TupleEnd;
  };
  template <class T> static auto Write(const T &t) -> enable_if_t<IsDefault<T>::value> {
    os << t;
  }
  template <class T>
  static auto Write(const T &t) -> enable_if_t<!IsDefault<T>::value and IsIterable<T>::value> {
    using std::begin;
    using std::end;
    auto it = begin(t);
    if (it != end(t))
      Write(*it++);
    while (it != end(t)) {
      os << Space<decltype(*it)>::value;
      Write(*it++);
    }
  }
  template <class T> static void WriteTuple(const T &t, index_sequence<>) {}
  template <class T, size_t I, size_t... Is>
  static void WriteTuple(const T &t, index_sequence<I, Is...>) {
    Write(get<0>(t));
    (void)(int[]){0, (Write(TupleSep), Write(get<Is>(t)), 0)...};
  }
  template <class T>
  static auto Write(const T &t)
      -> enable_if_t<!IsDefault<T>::value and !IsIterable<T>::value and IsTuple<T>::value> {
    WriteTuple(t, make_index_sequence<TupleSize<T>::value>{});
  }
  auto operator()() const {
    if (Interactive)
      os << endl;
    else
      os << '\n';
    return *this;
  }
  template <class First, class... Args>
  auto operator()(const First &f, const Args &... args) const {
    Write(f);
    (void)(int[]){0, (os << ' ', Write(args), 0)...};
    return (*this)();
  }
};

template <istream &is> struct Reader {
  template <class, class = void> struct IsDefault : false_type {};
  template <class T>
  struct IsDefault<T, decltype((void)(is >> declval<T &>()))> : true_type {};
  template <class T> static auto Read(T &t) -> enable_if_t<IsDefault<T>::value> { is >> t; }
  template <class T>
  static auto Read(T &t) -> enable_if_t<!IsDefault<T>::value and IsIterable<T>::value> {
    for (auto &&x : t)
      Read(x);
  }
  template <class T, size_t... Is> static void TupleRead(T &t, index_sequence<Is...>) {
    (void)(int[]){0, (Read(get<Is>(t)), 0)...};
  }
  template <class T>
  static auto Read(T &t)
      -> enable_if_t<!IsDefault<T>::value and !IsIterable<T>::value and IsTuple<T>::value> {
    TupleRead(t, make_index_sequence<TupleSize<T>::value>{});
  }
  template <class T> auto operator()(T &t) const {
    Read(t);
    return *this;
  }
  template <class T> auto operator()(T &t, int n) const {
    t.resize(n);
    Read(t);
  }
  template <class T> operator T() const {
    T t;
    Read(t);
    return t;
  }
};

template <class T> struct Vec1 : vector<T> {
  static constexpr int start_index = 1;
  using vector<T>::vector;
  decltype(auto) operator[](int i) { return vector<T>::operator[](i - 1); }
  decltype(auto) operator[](int i) const { return vector<T>::operator[](i - 1); }
  decltype(auto) at(int i) { return vector<T>::at(i - 1); }
  decltype(auto) at(int i) const { return vector<T>::at(i - 1); }
};

template <class T, class = void> struct Greater {
  constexpr bool operator()(const T &lhs, const T &rhs) const { return rhs < lhs; }
};
template <class T>
struct Greater<T, decltype((void)(declval<T &>() > declval<T &>()))> : greater<T> {};
template <class T> using MaxPQ = priority_queue<T>;
template <class T> using MinPQ = priority_queue<T, vector<T>, Greater<T>>;

struct Infinity {
  template <class T> constexpr operator T() const { return numeric_limits<T>::max(); }
};

struct BigNumber {
  template <class T> constexpr operator T() const {
    T x = 0, mask = 0x3f;
    for (int i = 0; i < sizeof(T); i++)
      x |= mask << 8 * i;
    return x;
  }
};

#ifdef NARUT_LOCAL
struct CerrRed {
  template <typename T>
  auto operator<<(const T &t) const -> decltype((void)(cerr << t), *this) {
    cerr << "\033[0;31m" << t << "\033[0m";
    return *this;
  }
  CerrRed operator<<(ostream &(*f)(ostream &)) const {
    cerr << f;
    return *this;
  }
} Cerr;
Writer<CerrRed &, Cerr, ':', ' '> Debug;
#else
struct DoNothing {
  template <class... Args> auto operator()(Args &&...) const { return *this; }
} Debug;
#endif

namespace Export {
Writer<ostream &, cout> Cout;
Reader<cin> Cin;
using Narut::Debug;
using Narut::MaxPQ;
using Narut::MinPQ;
Narut::Infinity Inf;
Narut::BigNumber Big;
using ll = long long;

using Pii = pair<int, int>;
using Vi = vector<int>;
using Vl = vector<ll>;
using Vc = vector<char>;
using Narut::Vec1;
} // namespace Export

struct IO {
  IO() {
#ifdef NARUT_LOCAL
    if (!Interactive and !freopen(INPUT_FILE, "r", stdin))
      Export::Debug("freopen failed");
    cerr << fixed << setprecision(10);
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(10);
  }
} FASTIO{};
} // namespace Narut
using namespace Narut::Export;
#pragma endregion



int n;
string s;

auto Run()
{
  cin>>n>>s;

  int r = count(begin(s), end(s), 'R');
  int b = count(begin(s), end(s), 'B');

  if (r > b) cout << "Yes";
  else cout <<"No";
  
 
}

int main() {
  Run();
}


Measured memory_bytes: 256