jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		try (Scanner sc = new Scanner(System.in)) {
			long r = sc.nextInt();
			long g = sc.nextInt();

			System.out.println(g * 2 - r);
		}
	}
}
//  [cpp]
#include <cstdio>
using namespace std;

int main() {
	int r, g;
	scanf("%d %d", &r, &g);
	printf("%d", 2*g-r);
	return 0;
}
//  [cpp]
#include <cstdio>

int main() {
	int r, g;
	scanf("%d %d", &r, &g);
	printf("%d\n", 2*g - r);

	return 0;
}
//  [cpp]
#include <stdio.h>

int main(){
  int R,G;
  scanf("%d",&R);
  scanf("%d",&G);
  printf("%d",2*G-R);
  return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{
 long long int a,b;
 cin>>a>>b;
 cout<<2*b-a;
 return 0;
}
//  [cpp]
#include <cstdio>
int main()
{
	int R,G,sum;
	scanf("%d%d",&R,&G);
	sum=2*G-R;
    if (R>=0,G<=4500) printf("%d\n",sum);

}
//  [c]
#include <stdio.h>
int main(void){
	int n,m;
	scanf("%d",&m);
	scanf("%d",&n);
	printf("%d",2*n-m);
	return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int R,G,S;
  scanf("%d %d",&R,&G);
  S=2*G-R;
  printf("%d",S);
}
//  [c]
  #include<stdio.h>
    int main()
    {
    	int R,G;
    	while(~scanf("%d %d",&R,&G))
    	{
    		printf("%d",2*G-R);
    		}
    		return 0;
    	}
//  [c]
#include <stdio.h>

int main (void)
{
  int rate, goal;

  scanf("%d", &rate);
  scanf("%d", &goal);

  printf("%d", 2 * goal - rate);

  return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	int r, g, ans;
	scanf("%d %d",&r, &g);
	ans=(2*g)-r;
	printf("%d\n",ans);
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

int main(void){

    int R, G;

    scanf("%d%d", &R, &G);

    printf("%d\n", 2 * G - R);

    return 0;
}
//  [javascript]
function Main(input) {
	input = input.trim().split("\n").map((a)=>Number(a));
  var R = input[0];
  var G = input[1];
  console.log(2 * G - R);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')
R = inp.shift() * 1
G = inp.shift() * 1
console.log(G * 2 - R)
//  [javascript]
'use strict'

function main(s) {

  s = s.split('\n');
  const r = Number(s[0]);
  const g = Number(s[1]);
  let ans = g + (g - r);

  console.log(ans);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input){
    var tmp = input.split(/\r\n|\r|\n/);
    var R = Number(tmp[0]);
    var G = Number(tmp[1]);

    console.log(G*2 - R);
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
    input = input.split("\n");
    var R = parseInt(input[0], 10);
    var G = parseInt(input[1], 10);
    console.log(G*2-R);
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));




// "実行する"ボタンを押した時に実行される関数 (デバッグ用)
function debug(){
	var input = document.getElementById("input").value;
	Main(input);
}
//  [javascript]
process.stdin.resume();
process.stdin.setEncoding('utf8');

var g_input = '';
process.stdin.on('data', function(chunk) {
    g_input += chunk;
});

process.stdin.on('end', function() {
    Main(g_input.split(/\r?\n/));
});

function Main(input) {

    var r = parseInt(input[0], 10);
    var g = parseInt(input[1], 10);

    var ans = 2 * g - r;
    console.log(ans);

    return 0;
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

const (
	initialBufSize = 1e4
	maxBufSize     = 1e6 + 7
)

var buf []byte = make([]byte, maxBufSize)
var sc = bufio.NewScanner(os.Stdin)

func init() {
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxBufSize)
}

func main() {
	R, G := nextInt(), nextInt()
	fmt.Println(G*2 - R)
}

func nextLine() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func abs(a int) int {
	if a > 0 {
		return a
	} else {
		return -a
	}
}

func pow(p, q int) int {
	res := p
	if q == 0 {
		return 1
	}
	for i := 0; i < q-1; i++ {
		res *= p
	}
	return res
}

func MinOf(vars ...int) int {
	min := vars[0]
	for _, i := range vars {
		if min > i {
			min = i
		}
	}
	return min
}

func MaxOf(vars ...int) int {
	max := vars[0]
	for _, i := range vars {
		if max < i {
			max = i
		}
	}
	return max
}

func gcdof2numbers(a int, b int) int {
	if b == 0 {
		return a
	}
	return gcdof2numbers(b, a%b)
}

func lcmof2numbers(a int, b int) int {
	return a / gcdof2numbers(a, b) * b
}

// マイナスの場合は考慮していない
func fuctorial(a int) int {
	if a == 1 || a == 0 {
		return 1
	} else {
		return fuctorial(a-1) * a
	}
}

func NextPermutation(x sort.Interface) bool {
	n := x.Len() - 1
	if n < 1 {
		return false
	}
	j := n - 1
	for ; !x.Less(j, j+1); j-- {
		if j == 0 {
			return false
		}
	}
	l := n
	for !x.Less(j, l) {
		l--
	}
	x.Swap(j, l)
	for k, l := j+1, n; k < l; {
		x.Swap(k, l)
		k++
		l--
	}
	return true
}

// 素因数分解したmapを返す
func primeFuctorize(n int) map[int]int {
	pf := map[int]int{}
	for i := 2; i*i <= n; i++ {
		for n%i == 0 {
			pf[i]++
			n /= i
		}
	}
	if n != 1 {
		pf[n]++
	}
	return pf
}
//  [go]
package main

import "fmt"

func main(){
	var r,g int
	fmt.Scan(&r,&g)
	fmt.Println(2*g - r)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var r, g int
	fmt.Scan(&r, &g)
	fmt.Println(g*2 - r)
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - Rating Goal
	var R, G int
	fmt.Scanf("%d\n%d", &R, &G)

	fmt.Println(2*G - R)
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func Scanner() string {
	sc.Scan()
	return sc.Text()
}

func intScanner() int {
	n, _ := strconv.Atoi(Scanner())
	return n
}

func floatScanner() float64 {
	n, _ := strconv.ParseFloat(Scanner(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func stringSliceScanner(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scanner()
	}
	return a
}
func intSliceScanner(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = intScanner()
	}
	return a
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	r := intScanner()
	g := intScanner()
	fmt.Println(g + (g - r))
}
//  [go]
package main

import (
	"fmt"
)

func main() {
  var R, G int 
  fmt.Scanf("%d", &R)
  fmt.Scanf("%d", &G)

  ans := 2 * G - R
  fmt.Printf("%d\n",ans)
}
//  [ruby]
r = gets.to_i
g = gets.to_i

puts 2*g-r
//  [ruby]
r = gets.to_i
g = gets.to_i
diff = g - r
puts g + diff
//  [ruby]
r=gets.to_i
g=gets.to_i

p (g * 2) - r
//  [ruby]
a,b=`dd`.split.map(&:to_i)
p b+b-a
//  [ruby]
r = gets.to_i
g = gets.to_i
d = g - r
puts r + d * 2
//  [ruby]
r = gets.chomp.to_i
g = gets.chomp.to_i
if r >= g
    puts r - (r - g) * 2
else
    puts r + (g - r) * 2
end
//  [rust]
use std::io::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn main() {
    let r: i32 = read();
    let g: i32 = read();

    println!("{}", 2 * g - r)
}
//  [rust]
fn main(){
    let R:i32 = {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().parse().unwrap()
    };
    let G:i32= {
        let mut t = String::new();
        std::io::stdin().read_line(&mut t).unwrap();
        t.trim_right().parse().unwrap()
    };
    println!("{}", 2 * G - R);
}
//  [rust]
// 参考
// https://techracho.bpsinc.jp/jhonda/2019_08_05/78537

// Input macro
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! stdin {
    () => {{
        use std::io::Read;
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }};
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

// Test Code
macro_rules! test {
    ($($input:expr => $output:expr),* $(,)*) => {
        #[test]
        fn solve_test() {
            $(
                assert_eq!(solve($input), $output);
            )*
        }
    };
}

test! {
r"2002
2017
" => r"2032",

r"4500
0
" => r"-4500"
}

use std::cmp;
use std::collections::HashSet;
use std::f32::MAX;

fn main() {
    println!("{}", solve(&stdin!()));
}

fn solve(src: &str) -> String {
    input! {
        source = src,
        r: i32,
        g: i32,
    }

    (r + ((g - r) * 2)).to_string()
}
//  [rust]
#![allow(non_snake_case)]
#![allow(unused_imports)]
use ascii::AsciiChar;
use ascii::AsciiStr;
use itertools::Itertools as _;
use permutohedron::LexicalPermutation as _;
use petgraph::algo::dijkstra;
use petgraph::algo::min_spanning_tree;
use petgraph::data::FromElements;
use petgraph::graph::NodeIndex;
use petgraph::graph::UnGraph;
use petgraph::unionfind::UnionFind;
use proconio::fastout;
use proconio::input;
use proconio::marker::Chars;
use proconio::marker::Usize1;
use std::cmp::max;
use std::cmp::min;
use std::collections::HashMap;
use std::collections::HashSet;
use std::collections::VecDeque;
use superslice::Ext as _;

#[fastout]
fn main() {
    input! {
        R: i64,
        G: i64,
    }

    // (R + P) / 2 = G
    // P = 2 * G - R)
    let ans = 2 * G - R;
    println!("{}", ans);
}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let r: isize = iterator.next().unwrap().parse().unwrap();
    let g: isize = iterator.next().unwrap().parse().unwrap();

    let ans = 2 * g - r;
    return ans.to_string();
}
//  [rust]
#![allow(
    non_snake_case,
    unused_variables,
    unused_assignments,
    unused_mut,
    dead_code
)]
use proconio::input;
//use proconio::marker::Usize1;
//use proconio::marker::Chars;
//use std::collections::HashSet;
//use std::cmp::*;
fn main() {
    input! {
        r: i32,g:i32
    }
    let ans = 2 * g - r;
    println!("{}", ans);
}
//  [swift]
import Glibc
extension String: CollectionType {}

//var abc = readLine()!.split(" ").map { Int($0)! }
var r = Int(readLine()!)!
var g = Int(readLine()!)!
print(g-r+g)
//  [swift]
print(0-Int(readLine()!)!+Int(readLine()!)!*2)
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [r, g] = stdin.split('\n').map(Number)

console.log(2 * g - r)
//  [typescript]
function main(input) {
  const [R, G] = input.split("\n")
  const nextRating = (parseInt(G) * 2  - parseInt(R))
  console.log(nextRating)
  }
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
"use strict";

main(require("fs").readFileSync("/dev/stdin", "utf8"));

function main(input) {
  const [r, g] = input.trim().split("\n").map(Number);

  const ans = g + (g - r);
  console.log(ans);
}
//  [typescript]
import { readFileSync } from "fs";

const read = () =>
  readFileSync(0, "utf8")
    .split("\n")
    .map((line) => line.split(" "));

const main = (input: string[][]) => {
  const R = Number(input[0][0]);
  const G = Number(input[1][0]);

  return G * 2 - R;
};

console.log(main(read()));
//  [typescript]
function main(p){
  const input = p.split('\n')
  const r = parseInt(input[0], 10)
  const g = parseInt(input[1], 10)
  console.log(2*g-r)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [typescript]
import * as fs from 'fs';

namespace AtCoder {
    export interface Paramable {
        readonly args: string[][];
    }

    export interface Task {
        main(this: Task): void;
    }
}

namespace AtCoder.abc001 {
    export class TaskA implements AtCoder.Task, AtCoder.Paramable {
        public constructor(public readonly args: string[][]) {
        }

        public main(this: TaskA): void {

            const r :number = +this.args[0][0];
            const g :number = +this.args[1][0];

            // (2032 + 2002) /2 = 2017
            // (x + 2002) /2 = 2017
            // (2017*2) - 2002 = 2032

            console.log(g*2-r);



        }
    }

    const args: string[][] = fs.readFileSync('/dev/stdin', 'utf8').trim().split('\n').map(r => r.split(' '));
    const task: AtCoder.Task = new TaskA(args);
    task.main();
}
//  [python]
N = int(input())
S = list(input())
r_num = S.count('R')
b_num = S.count('B')

if r_num > b_num:
    print("Yes")
else:
    print("No")
//  [python]
N = int(input())
S = str(input())
count = 0;
for i in range(0, N):
    if S[i] == "B":
        count += 1;
    else:
        count -=1;
if (count < 0):
    print("Yes")
else:
    print("No")
//  [python]
N = input()
s = input()
slist = list(s)
Rnumber = slist.count("R")
if Rnumber > int(N) - Rnumber:
    print("Yes")
else:
    print("No")
//  [python]
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

N = I()
s = S()
num = s.count("R")
if num <= N//2:
    print("No")
else:
    print("Yes")
//  [python]
# -*- coding: utf-8 -*-

# -*- coding: utf-8 -*-

# -*- coding: utf-8 -*-
from sys import stdin

###########################################
# delete here


############################################
#from sys import stdin
import numpy as np

# read data for n sequences.
N = int(stdin.readline().split()[0])
data = str(stdin.readline().split())

count = 0

for let in data:
    if let == "R":
        count += 1

if count > N-count:
    print("Yes")
else:
    print("No")
//  [python]
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy
from operator import itemgetter
#以下てんぷら
def j(q):
    if q==1: print("Yes")
    else:print("No")
    exit(0)


def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
n = ip()                                     #入力整数1つ
#a,b,c= (int(i) for i in input().split())       #入力整数横2つ以上
#a = [int(i) for i in input().split()]        #入力整数配列
a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列
#n = ip()                      #入力セット(整数改行あり)(1/2)
#a=[ip() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#jの変数はしようできないので注意
#全足しにsum変数使用はsum関数使用できないので注意
#こっから本文
if a.count('R') > n//2:j(1)
j(0)
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
	
	public static void main(String[] args) throws IOException {
		Main mainObj = new Main();
		mainObj.solve();
	}

	public void solve() throws IOException {
		FastScanner fs = new FastScanner();
		int n = fs.nextInt();
		String s = fs.next();
		
		int r = 0;
		int b = 0;
		
		for(int i = 0; i < n; i++) {
			char charAt = s.charAt(i);
			
			if(charAt == 'R') {
				r++;
			}else {
				b++;
			}
		}
		
		if(r > b) {
			System.out.println("Yes");
		}else {
			System.out.println("No");
		}
	}

	

	public class FastScanner {

		BufferedReader reader;
		private StringTokenizer st;

		public FastScanner() {
			st = null;
			reader = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			if (st == null || !st.hasMoreElements()) {
				st = new StringTokenizer(reader.readLine());
			}
			return st.nextToken();
		}

		public String nextLine() throws IOException {
			st = null;
			String readLine = null;
			readLine = reader.readLine();
			return readLine;
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws NumberFormatException, IOException {
			return Long.parseLong(next());
		}

		public int[] nextIntArr(int n) throws NumberFormatException, IOException {
			int[] retArr = new int[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextInt();
			}
			return retArr;
		}

		public long[] nextLongArr(int n) throws NumberFormatException, IOException {
			long[] retArr = new long[n];
			for (int i = 0; i < n; i++) {
				retArr[i] = nextLong();
			}
			return retArr;
		}

		public void close() throws IOException {
			reader.close();
		}
	}


}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {
	public static void main(String args[]) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		Solver solver = new Solver();
		solver.init();
		solver.readHead(in.readLine());
		solver.readS(in.readLine());
		// for (; solver.hasNext();) {
		// solver.readBody(in.readLine());
		// }
		// solver.solve();
	}
}

class Solver {
	int N;
	int cnt;

	public void init() {
		N = 0;
		cnt = 0;
	}

	public void readHead(String str) {
		String[] strArr = str.split(" ");
		N = Integer.parseInt(strArr[0]);
		// System.out.println(N);
	}

	public void readS(String str) {
		int r = 0;
		int b = 0;
		for (int i = 0; i < N; i++) {
			if (str.charAt(i) == 'R')
				r++;
			else
				b++;
		}
		if (r > b)
			System.out.println("Yes");
		else
			System.out.println("No");
	}

	public boolean hasNext() {
		return cnt < N;
	}

	public void readBody(String str) {
		// System.out.println(str);
		cnt++;
	}

	public void solve() {

	}
}
//  [java]
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

public class Main {
	private static final int MOD = 1000000007;

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		char[] s = sc.next().toCharArray();

		int red = 0;
		int blue = 0;
		for (int i = 0; i < s.length; i++) {
			if (s[i] == 'R') {
				red++;
			} else {
				blue++;
			}
		}

		System.out.println(red > blue ? "Yes" : "No");

	}

	private static boolean isDebug = System.getProperty("sun.desktop") != null;

	private static void debug(Object... o) {
		if (isDebug) {
			System.err.println(Arrays.deepToString(o));
		}
	}

	public static class Scanner {
		private BufferedInputStream inputStream;

		public Scanner(InputStream in) {
			inputStream = new BufferedInputStream(in);
		}

		public int nextInt() throws IOException {
			int num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(int[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
			}
		}

		public void fill(int[] a, int[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextInt();
				b[i] = nextInt();
			}
		}

		public long nextLong() throws IOException {
			long num = 0;

			int read = skip();
			do {
				num = num * 10 + (read - 0x30);
			} while ((read = inputStream.read()) > 0x20);

			return num;
		}

		public void fill(long[] a) throws IOException {
			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
			}
		}

		public void fill(long[] a, long[] b) throws IOException {
			if (a.length != b.length) {
				throw new IllegalArgumentException();
			}

			for (int i = 0; i < a.length; i++) {
				a[i] = nextLong();
				b[i] = nextLong();
			}
		}

		public long[] nextLong(int n) throws IOException {
			long[] array = new long[n];
			for (int i = 0; i < n; i++) {
				array[i] = nextLong();
			}

			return array;
		}

		public String next() throws IOException {
			StringBuilder builder = new StringBuilder();

			int read = skip();
			do {
				builder.append((char) read);
			} while ((read = inputStream.read()) > 0x20);

			return builder.toString();
		}

		private int skip() throws IOException {
			int read;
			while ((read = inputStream.read()) <= 0x20)
				;

			return read;
		}
	}
}
//  [java]
public class Main {
    private static java.util.Scanner scanner = new java.util.Scanner(System.in);

    public static void main(String[] args) {
        int n = scanner.nextInt();
        int[] count = new int[26];
        scanner.next().chars().forEach(c -> count[c - 'A']++);
        System.out.println(count['R' - 'A'] > count['B' - 'A'] ? "Yes" : "No");
    }
}
//  [java]

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		String s = in.next();

		long red = s.chars().filter(c -> c == 'R').count();
		System.out.println(N < red * 2 ? "Yes" : "No");
	}
}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			int count = scanner.nextInt();
			scanner.nextLine();
			String string = scanner.nextLine();
			if (string.chars().filter(x -> x == 'R').count() > count / 2) {
				System.out.println("Yes");
			} else {
				System.out.println("No");
			}
		}
	}
}
//  [cpp]
#include <stdio.h>

int main() {
    int N;
    char s[128];
    scanf("%d%s", &N, s);
    int r = 0;
    int b = 0;
    for (int i = 0; i < N; i++) {
        if (s[i] == 'R') {
            r++;
        }
        else {
            b++;
        }
    }
    puts(r > b ? "Yes" : "No");
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>

#define REP(i,n) for (int i = 0; i < (n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
typedef long long ll;

using namespace std;

int n;
string s;
int ans=0;

int main(){
    cin>>n>>s;
    for(int i=0;i<s.length();i++){
        if(s[i]=='R'){
            ans++;
        }else{
            ans=ans-1;
        }
    }
    if(ans>0){
        cout<<"Yes";
    }else{
        cout<<"No";
    }
}
//  [cpp]
#include <bits/stdc++.h>

int main() {

    int N; std::cin >> N;
    std::string s; std::cin >> s;
    int r = std::count(s.begin(), s.end(), 'R');
    std::cout << ((r + r > s.length()) ? "Yes" : "No") << std::endl;
}
//  [cpp]
#include<iostream>
#include<cstdlib>
#include<stack>
#include<queue>
using namespace std;

int max(int x, int y);
int min(int x, int y);
int gcd(int x, int y);	/*最大公約数*/
int lcm(int x, int y);	/*最小公倍数*/

typedef stack<int> IntStack;
typedef queue<int> IntQueue;

/*ここまでテンプレ*/



/*ここからmain関数*/

int main()
{
	int N;
	char s[100];
	cin >> N >> s;

	int r = 0;
	int b = 0;

	for (int i=0;i < N;i++)
	{
		if (s[i] == 'R')
			r++;
		else
			b++;
	}

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

	return 0;
}

/*2数の大きい方を返す*/
int max(int x, int y)
{
	int max;

	if (x < y)
		max = y;
	else
		max = x;

	return max;
}

/*2数の小さい方を返す*/
int min(int x, int y)
{
	int min;

	if (x < y)
		min = x;
	else
		min = y;

	return min;
}

/*2数の最大公約数を返す*/
int gcd(int x, int y)
{
	int m;
	int gcd = 1;

	m = min(x, y);

	for (int i = 1;i <= m; i++)
	{
		if (x%i == 0 && y%i == 0)
			gcd = i;
	}

	return gcd;
}

/*2数の最小公倍数を返す*/
int lcm(int x, int y)
{
	int m;

	for (int i = 1;i <= y;i++)
	{
		if ((x*i) % y == 0) {
			m = x * i;
			break;
		}
	}

	return m;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int main(){
  long long n,cnt=0;
  string s;
  cin >> n >> s;
  for(int i=0;i<n;i++){
    if(s[i]=='R')cnt++;
  }
  if(cnt>n-cnt){
    cout << "Yes" << endl;
  }else{
    cout << "No" << endl;
  }
  return 0;
}
//  [cpp]
#include <iostream>
#include <cstdio>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <iterator>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;

template<typename T>
void remove(std::vector<T>& vector, unsigned int index)
{
    vector.erase(vector.begin() + index);
}

#define rep(i, n, m) for (int i = n; i <= m; i++)
#define Rep(i, n, m) for (int i = m; i >= 1; i--)

typedef long long ll;

int main() {
    int n;
    cin >> n;
    string str;
    cin >> str;
    int r = 0, b = 0;
    rep(i, 0, n - 1)
        if (str[i] == 'R')
            r++;
        else
            b++;
    cout << (r > b ? "Yes" : "No") << endl;
}
//  [c]
#include <stdio.h>

int main(){
    int N,i,r=0,b=0;
    scanf("%d",&N);
    char str[N+1];
    scanf("%s",str);
    for(i=0;i<N;i++){
        if(str[i] == 'R') r++;
        else b++;
    }
    if(r>b) printf("Yes\n");
    else printf("No\n");
    return 0;
}
//  [c]
#include <stdio.h>

char s[110];
int main(){
	int n;
	scanf("%d%s",&n,s);
	int ans=0;
	for(int i=0;i<n;i++){
		if(s[i]=='R')ans++;
		else ans--;
	}
	puts(ans>0?"Yes":"No");
}
//  [c]
#include <stdio.h>
int main() {
	int n, r = 0;
	char s[101];
	scanf("%d%s", &n, s);
	for (int i = 0; i < n; i++) {
		if (s[i] == 'R') {
			r++;
		}
	}
	if (n - r < r) {
		printf("Yes\n");
	} else {
		printf("No\n");
	}
	return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	int N;
	char s[128] = "";
	int kitaeri = 0;
	int i;
	if (scanf("%d", &N) != 1) return 1;
	if (scanf("%127s", s) != 1) return 1;
	for (i = 0; i < N; i++) {
		if (s[i] == 'R') kitaeri++; else kitaeri--;
	}
	puts(kitaeri > 0 ? "Yes" : "No");
	return 0;
}
//  [c]
#include <stdio.h>

int main(void){
  int s; scanf("%d", &s);
  char color[101];
  scanf("%s", color);

  int i, r=0, b=0;
  for(i=0;i<s;i++){
	if(color[i] == 'R') r++;
	else b++;
  }

  if(r > b) printf("Yes\n");
  else printf("No\n");
  
  return 0;
}
//  [c]
#include <stdio.h>

int main()
{
  int n=0;
  char s[101];
  scanf("%d", &n);
  scanf("%s", s);

  int ri=0, bi=0;
  for(int i = 0; i < n; i++){
    if(s[i] == 'R'){
      ri++;
    }else{
      bi++;
    }
  }
  
  if(ri > bi){
    printf("Yes\n");
  }else{
    printf("No\n");
  }
  return 0;
}
//  [javascript]
function Main(input) {
	var r = 0;
	var b = 0;
	input = input.split("\n");
	var arr = input[1].split("");
	for(var i=0;i<arr.length;i++){
		if(arr[i]=="R") r++;
		else b++;
	}
	console.log(r>b?"Yes":"No")
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
function Main(input) {
	tmp = input.split("\n");
	
	var a = parseInt(tmp[0]);
	var red = 0;
	var blue = 0;
	
	for (var i = 0; i < a; i++){
		if(tmp[1].charAt(i)=="R"){
			red++;
		}
		if(tmp[1].charAt(i)=="B"){
			blue++;
		}
	}
	
	if(red>blue){
		console.log("Yes");
	}else{
		console.log("No");
	}
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";
function I(s,f){this._s=s.split("\n");this._c=0;this._l=0;this._f=f||Number}I.prototype.a=function(){var l=this._s[this._l];if(!l)return;var t=l.trim().split(" ");var a=t[this._c];this._c++;if(t.length===this._c){this._c=0;this._l++}return this._f(a)};I.prototype.l=function(){var l=this._s[this._l];if(!l)return;this._c=0;this._l++;return l.split(" ").map(this._f)};

function main(input) {
  const o = new I(input, String);

  const N = Number(o.a());
  const s = o.a();

  let countR = 0;
  let countB = 0;
  for ( let i = 0; i < s.length; i++) {
    if (s[i] === "R") {
      countR += 1;
    } else {
      countB += 1;
    }
  }

  console.log(countR > countB ? "Yes":"No");
}


main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {

  var input = input.split("\n");
  var n = input[0];
  var arys = input[1].split("");

  var r = 0;
  var b = 0;

  arys.forEach(function(e) {
    if(e == "R") {
      r++;
    } else {
      b++;
    }
  });
  if(r > b) {
    console.log("Yes");
  } else {
    console.log("No");
  }

}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
"use strict";

// read lines from stdin
const input = require("fs")
  .readFileSync("/dev/stdin", "utf8")
  .split("\n");

const N = parseInt(input[0], 10);
const S = input[1];

let R = 0;
let B = 0;

for (let i = 0; i < N; i++) {
  if (S.charAt(i) === "R") { R++; }
  else { B++; }
}

console.log(R > B ? "Yes" : "No");
//  [javascript]
function main(i) {
  var n = Number(i.split('\n')[0]);
  var red = i.split('\n')[1].split('R').length - 1;
  if (red > n/2) {
    console.log('Yes');
  } else {
    console.log('No');
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	"fmt"
	"strings"
)

func main() {
	var (
		n int
		s string
	)
	fmt.Scan(&n, &s)

	r := strings.Count(s, "R")
	b := n - r
	if r > b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
// exawizards2019_b

package main

import "fmt"

func main() {
	var N int
	fmt.Scanf("%d", &N)
	var s string
	fmt.Scanf("%s", &s)

	var r, b int
	for _, c := range s {
		if c == 'R' {
			r++
		} else if c == 'B' {
			b++
		}
	}
	if r > b {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var n, cnt int
	var s string
	fmt.Scan(&n, &s)
	rs := []rune(s)
	for _, v := range rs {
		if string(v) == "R" {
			cnt++
		}
	}
	if cnt > n/2 {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	// Code for B - Red or Blue
	var N int
	fmt.Scanf("%d", &N)

	var S string
	fmt.Scanf("%s", &S)

	ans := make(map[string]int, N)
	for i := 0; i < len(S); i++ {
		ans[S[i:i+1]]++
	}

	if ans["R"] > ans["B"] {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func Scan() string {
	sc.Scan()
	return sc.Text()
}
func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}
func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	n := iScan()
	s := Scan()
	r := 0
	for _, v := range s {
		if string(v) == "R" {
			r++
		}
	}
	if r > n-r {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [ruby]
n = gets.to_i
s = gets.chomp
r = s.count('R')
b = s.count('B')

puts r > b ? 'Yes' : 'No'
//  [ruby]
line = readlines
len = line.length
i = 0

while i < len
    line[i] = line[i].chomp
    i += 1
end

N = line[0].to_i
S = line[1]

num_r = 0
for i in 1..N do
  if S[i-1] == "R" then
    num_r += 1
  else
    num_r -= 1
  end
end
  
if num_r > 0 then
  print "Yes"
else
  print "No"
end
//  [ruby]
N = gets.to_i
s = gets.chomp

puts s.count("R") > s.count("B")? :Yes : :No
//  [ruby]
N,S = `dd`.split
puts S.count("R") > S.count("B") ? "Yes" : "No"
//  [ruby]
s=`dd`;puts s.count(?R)>s.count(?B)?:Yes: :No
//  [ruby]
require 'pp'

def gets; ARGF.gets; end

class Solver

  def initialize
  end

  def main
    n = gets.chomp.to_i
    s = gets.chomp

    r_cnt = 0
    b_cnt = 0
    s.each_char do |c|
      if c == 'R'
        r_cnt += 1
      else
        b_cnt += 1
      end
    end

    if b_cnt < r_cnt
      puts "Yes"
    else
      puts "No"
    end
  end
end

if __FILE__ == $0
  Solver.new.main
end
//  [rust]
#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
use std::io::*;
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::*;

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);

impl<T: PartialEq> Eq for Total<T> {}

impl<T: PartialOrd> Ord for Total<T> {
    fn cmp(&self, other: &Total<T>) -> std::cmp::Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}


//const MAX:usize = 100006;
//const INF:u64 = u64::max_value();

fn main() {
    let n:u32 = read();
    let s:Vec<char> = read::<String>().chars().collect();

    let cnt = s.iter().filter(|&x| *x == 'R').count();

    println!("{}", if s.len()-cnt < cnt {"Yes"} else {"No"});
    
}
//  [rust]
#[macro_use]
mod input {

use std;
use std::io;

const SPLIT_DELIMITER: char = ' ';

#[macro_export]
#[allow(unused_macros)]
macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

#[allow(dead_code)]
pub fn input_line_str() -> String {
    let mut s = String::new();
    io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

#[allow(dead_code)]
pub fn p<T>(t: T)
where
    T: std::fmt::Display,
{
    println!("{}", t);
}

#[allow(dead_code)]
pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
where
    T: std::str::FromStr,
{
    let mut v: Vec<Vec<T>> = Vec::new();

    for _ in 0..line {
        let vec_line = input_vector();
        v.push(vec_line);
    }
    v
}

#[allow(dead_code)]
pub fn input_vector<T>() -> Vec<T>
where
    T: std::str::FromStr,
{
    let mut v: Vec<T> = Vec::new();

    let s = input_line_str();
    let split_result = s.split(SPLIT_DELIMITER);
    for z in split_result {
        let buf = match z.parse() {
            Ok(r) => r,
            Err(_) => panic!("Parse Error"),
        };
        v.push(buf);
    }
    v
}

#[allow(dead_code)]
pub fn str2vec(s: &str) -> Vec<char> {
    let mut v: Vec<char> = Vec::new();
    for c in s.chars() {
        v.push(c);
    }
    v
}
}

use input::*;

fn main() {
    let n: usize;
    input!(n);
    let s = str2vec(&input_line_str());
    let cr = s.iter().filter(|&&x| x == 'R').count();
    let cb = n - cr;
    if cr > cb {
        p("Yes");
    } else {
        p("No");
    }
}
//  [rust]
use std::io::{stdin, Read, StdinLock};
use std::str::FromStr;

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut scan = Scanner::new(cin);

    let _n = scan.read::<usize>();
    let s = scan.chars();
    let cnt = count(&s);
    println!("{}", if getd(&cnt, 'R') > getd(&cnt, 'B') {"Yes"} else {"No"});
}

#[allow(dead_code)]
fn count<T: Eq + std::hash::Hash + Clone>(slice: &[T]) -> std::collections::HashMap<T, usize> {
    let mut hmap = std::collections::HashMap::new();
    for item in slice {
        *hmap.entry(item.clone()).or_insert(0) += 1;
    }
    hmap
}

// region template
#[allow(dead_code)]
fn getd<S, T>(hmap: &std::collections::HashMap<S, T>, key: S) -> T
    where S : Eq + std::hash::Hash, T : Default + Copy {
    *hmap.get(&key).unwrap_or(&Default::default())
}

#[allow(dead_code)]
fn uz(i: i32) -> usize { i as usize }

#[allow(dead_code)]
fn chmax<T: PartialOrd>(a: &mut T, b: T) -> bool {
    if *a < b {
        *a = b;
        true
    } else { false }
}

#[allow(dead_code)]
fn chmin<T: PartialOrd>(a: &mut T, b: T) -> bool {
    if *a > b {
        *a = b;
        true
    } else { false }
}

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

#[allow(dead_code)]
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner { cin: cin }
    }

    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect::<String>();
        token.parse::<T>().ok()
    }

    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }

    fn readn<T: FromStr>(&mut self, n: i32) -> Vec<T> {
        let mut ret = vec![];
        for _ in 0..n { ret.push(self.read::<T>()) }
        ret
    }

    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
// endregion
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use itertools::Itertools;
use std::process::exit;
use std::cmp::*;
use num::*;
use num::integer::Roots;

fn main() {
    input! {
    a:usize,
    b:String,
    }
    let mut b=b.chars().collect_vec();
    let mut c=0;
    for i in 0..b.len(){
        if b[i]=='R'{
            c+=1
        }
    }
    println!("{}",if c>a-c{"Yes"}else{"No"})
}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();

    let answer = solve(&buf);

    println!("{}", answer);
}

fn solve(input: &str) -> String {
    let mut iterator = input.split_whitespace();

    let n: usize = iterator.next().unwrap().parse().unwrap();
    let s: Vec<char> = iterator.next().unwrap().chars().collect();

    let mut r = 0;
    let mut b = 0;
    for i in 0..n {
        if s[i] == 'R' {
            r += 1;
        } else {
            b += 1;
        }
    }

    if r > b {
        "Yes".to_string()
    } else {
        "No".to_string()
    }
}
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

fn main() {
    let _: usize = read!();
    let s: String = read!();
    let s = s.chars();
    let r = s.clone().filter(|&c| c == 'R').count();
    let b = s.filter(|&c| c == 'B').count();
    let ans = if r > b { "Yes" } else { "No" };
    println!("{}", ans);
}
//  [swift]
var _=readLine()!,r=0,b=0;readLine()!.characters.forEach{$0=="R" ?r++:b++};print(r>b ?"Yes":"No")
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    func count() -> Int {
        return self.characters.count
    }
}
extension Array where Element: Comparable {
    func max() -> Element! {
        return self.maxElement()
    }
    func min() -> Element! {
        return self.minElement()
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let _ = readInt()!
let S = readLine()!

var redCount = 0
var blueCount = 0
for c in S.characters {
    switch c {
    case "R":
        redCount += 1
    case "B":
        blueCount += 1
    default:
      	break
    }
}

print((redCount > blueCount) ? "Yes" : "No")
//  [typescript]
"use strict";
const Main = (input) =>{
   let xs = input.trim().split('\n');
   let N = Number(xs[0]);
   let s = xs[1].split('');
   let count = 0;
   for(let i=0; i<N; i++){
      if(s[i]=='R'){
         count++
      }
   }
   if(count>N-count){
      console.log('Yes');
   }else{
   console.log('No');
   }
}
Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [typescript]
[N,s]=require('fs').readFileSync('/dev/stdin','utf8').split('\n')
s=s.split('')
R=s.filter(c=>c=='R').length
B=s.filter(c=>c=='B').length
console.log(R>B?'Yes':'No')
//  [typescript]
export class Main {
  static main(input): string {
    const [nTmp, str]: string[] = input.split("\n");
    const n: number = Number(nTmp);
    const tmp: string[] = str.split("").slice(0, n);
    return `${tmp.filter(s => s == "R").length * 2 > n ? "Yes" : "No"}`;
  }
}
console.log(Main.main(require("fs").readFileSync("/dev/stdin", "utf8")));
//  [typescript]
s=require('fs').readFileSync('/dev/stdin','utf8').split('\n')[1].split('')
console.log(s.filter(c=>c=='R').length>s.filter(c=>c=='B').length?'Yes':'No')
//  [typescript]
function main(input) {
  const [N, s] = input.split("\n");
  console.log(s.length / 2 > s.replace(/R/g, "").length ? "Yes" : "No");
}
main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [typescript]
const p = (...args) => {
  process.env.NODE_ENV === "test" ? console.log(...args) : ""
}

const solve = (input) => {
  const [n, s] = input.split("\n")
  const ss = s.split("")
  const red = ss.filter((c) => c == "R")
  return Math.floor(ss.length / 2) < red.length ? "Yes" : "No"
}

if (process.env.NODE_ENV === "test") {
  module.exports = (input) => solve(input.trim())
} else {
  const input = require("fs").readFileSync("/dev/stdin", "utf8")
  console.log(solve(input.trim()))
}
//  [python]
def main():
    n = int(input())
    a = list(map(int, input().split()))
    dp = [-10**15]*(n+1)
    dp[2] = max(a[0], a[1])
    if n > 2:
        dp[3] = max(a[:3])
        aa = a[0]+a[2]
        for i in range(4, n+1):
            if i%2:
                aa += a[i-1]
                dp[i] = max(dp[i-1], dp[i-2]+a[i-1])
            else:
                dp[i] = max(aa, dp[i-2]+a[i-1])
    print(dp[n])

if __name__ == "__main__":
    main()
//  [python]
def main():
    import sys
    input=sys.stdin.readline
    n=int(input())
    A=list(map(int,input().split()))
    A_=[0]*n
    for i in range(n):
        if i%2==0:
            A_[i]=A[i]
        else:
            A_[i]==0
    for i in range(n-1):
        A_[i+1]+=A_[i]
    dp=[0]*n
    dp[1]=max(A[0],A[1])
    for i in range(2,n):
        if i%2==0:
            dp[i]=max(dp[i-2]+A[i],dp[i-1])
        else:
            dp[i]=max(dp[i-2]+A[i],A_[i-1])
    print(dp[n-1])
if __name__ == '__main__':
    main()
//  [python]
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n = ni()
a = na()

dp = [0]*n
b = a[0]

dp[1] = max(a[0],a[1])

for i in range(2,n):
    if i%2 == 0:
        b += a[i]
        dp[i] = max(dp[i-1],dp[i-2]+a[i])
    else:
        dp[i] = max(b,dp[i-2]+a[i])

print(dp[-1])
//  [python]
import numpy as np
n = int(input())
a = list(map(int,input().split()))
dp = np.full((2, n//2 + 1), -10**18, dtype=np.int64)
"""
dp[i][j] := iは偶奇, jは何個決めるか
"""
dp[0][0] = 0
dp[1][0] = 0
for i in range(n):
	k = i % 2
	for j in [2, 1, 0]:
		if i//2+j <= n//2:
			if i//2-1+j >= 0:
				dp[k][i//2+j] = np.maximum(dp[1-k][i//2+j], dp[k][i//2-1+j]+a[i])

print(max(dp[0][n//2], dp[1][n//2]))
//  [python]
import math
import sys
sys.setrecursionlimit(1000000)

N = int(input())
A = [int(i) for i in input().split()]

memo = {}
def sub_max(n, m):
    if((n, m) in memo):
        return memo[(n, m)]
    
    if(m == 1 and n >= 1):
        memo[(n, m)] = max(A[-n:])
        return memo[(n, m)]

    if(m > math.ceil(n/2)):
        memo[(n, m)] = -float('inf')
        return -float('inf')
    
    res = -float('inf')
    for i in range(3):
        res = max(res, A[-n + i] + sub_max(n - i - 2, m - 1))
    memo[(n, m)] = res
    return res

print(sub_max(N, N//2))
# print(memo)
//  [python]
import sys
sys.setrecursionlimit(10**7)

from functools import lru_cache

@lru_cache(None)
def dfs(p, remain):

    n = len(arr)

    if remain == 0 or p >= n:
        return 0

    if remain == 1:
        return max(arr[p:])
        
    len_remain = n - (p + 1)

    t = -float('inf')
    if (remain - 1) * 2 + 1 <= len_remain:
        t = dfs(p + 1, remain)

    t2 = arr[p] + dfs(p + 2, remain - 1)

    return max(t, t2)

    


n = int(input())

arr = list(map(int, input().split()))

ans = dfs(0, n // 2)

print (ans)
//  [java]
import java.util.*;

public class Main {
    static Map<Long, Long> mp = new HashMap<>();
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        long[] A = new long[N];
        for(int i=0;i<N;i++){
            A[i] = sc.nextLong();
        }
        System.out.println(helper(A, 0, N/2));
    }
    private static long helper(long[] A, int ofs, int cnt){
        long key = ofs * 3_000_00 + cnt;
        if(mp.containsKey(key)){
            return mp.get(key);
        }
        if(cnt == 0){
            return 0;
        }
        int size = (A.length-ofs);
        if(size == 1 && cnt == 1){
            return A[ofs];
        }
        if(size == 2 && cnt == 1){
            return Math.max(A[ofs], A[ofs+1]);
        }
        if(size % 2 == 1 && size/2+1 == cnt){
            long ans = A[ofs] + helper(A, ofs+2, cnt-1);;
            mp.put(key, ans);
            return ans;
        }
        long use = A[ofs] + helper(A, ofs+2, cnt-1);
        long nouse = helper(A, ofs+1, cnt);
        long ans = Math.max(use, nouse);;
        mp.put(key,ans);
        return ans;
    }
}