jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
//if(strcmp(s[i],"AC")==0)
//if(s[l]=='#')
/*小文字判定
if((moji>= 'a') && (moji<='z')){
    printf("a\n");
    return 0;
  }
  */

int W_Length(char *str){
	int length = 0;
	while(*str++ != '\0')
		length++;
	return length;
}

void swap(int *a, int *b){
  int temp;
  temp=*a;
  *a=*b;
  *b=temp;
}
//swap(&a, &b)

double deg(double theta){//deg to theta
return theta*(2*3.14159265359)/360;
}

int cmp( const void *p, const void *q ) {
    return *(int*)p - *(int*)q;
}//ちいさい順
//qsort(a,n,sizeof(int),cmp);
//char s[n][11]

int cmp_s(const void * left, const void * right)
{
	char *left_char = (char *)left;
  char *right_char = (char *)right;
  return strcmp(left_char, right_char);
}
//qsort(s,n,sizeof(s[0]),cmp_s);


int main (void)
{
	int a[210000],b=0,c,n,i;
  char s[200005];

scanf("%s",s);
	for(i=0;i<3;i++){
      if(s[i]=='S'){
      continue;
      }
      if(s[i]=='R'&&b==0){
      b=1;
      }
      else if(s[i]=='R'&&s[i-1]=='R'){
      b++;
      }

	}
  
  printf("%d",b);
	
return 0;
}
//  [c]
#include<stdio.h>
int main(void){
  	char s[3];
	scanf("%s",s);
	if(s[0] == 'R'){
    	if(s[1] == 'R'){
        	if(s[2] == 'R'){
            	printf("3");
            }
          	else{
              printf("2");
            }
        }
      	else{
        	printf("1");
        }
    }
  	else{
    	if(s[1] == 'R'){
        	if(s[2] == 'R'){
            	printf("2");
            }
          	else{
            	printf("1");
            }
        }
      	else{
        	if(s[2] == 'R'){
            	printf("1");
            }
          	else printf("0");
        }
    }
    	
    
  	return 0;
}
//  [c]
#include<stdio.h>

int main(){
  char s[3];
  scanf("%s",s);
  
  if(s[0]=='S' && s[1]=='S' && s[2]=='S')printf("0");
  if(s[0]=='S' && s[1]=='S' && s[2]=='R')printf("1");
  if(s[0]=='S' && s[1]=='R' && s[2]=='S')printf("1");
  if(s[0]=='R' && s[1]=='S' && s[2]=='S')printf("1");
  if(s[0]=='S' && s[1]=='R' && s[2]=='R')printf("2");
  if(s[0]=='R' && s[1]=='S' && s[2]=='R')printf("1");
  if(s[0]=='R' && s[1]=='R' && s[2]=='S')printf("2");
  if(s[0]=='R' && s[1]=='R' && s[2]=='R')printf("3");
  
  return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    // Your code here!
    char s[3];
    int res= 0,cnt = 0;
    scanf("%s",s);
    
    for (int i = 0; i < 3; i++){
        if (s[i] == 'R'){
            cnt++;
        }
        else{
            if (cnt > res){
                res = cnt;
            }
            cnt = 0;
        }
    }
    
    printf("%d\n",res);
}
//  [c]
#include<stdio.h>
int main()
{ int i,sum=1;
  char s[3];
  for(i=0;i<3;i++)
  {
  scanf("%c" ,&s[i]);
  }
  if(s[0]=='R'&&s[0]==s[1]){sum++;}
  if(s[1]=='R'&&s[1]==s[2]){sum++;}
 printf("%d",sum);
return 0;
}
//  [c]
#include<stdio.h>
int main()
{ int i,sum=1;
  char s[3];
  for(i=0;i<3;i++)
  {
  scanf("%c" ,&s[i]);
  }
 for(i=0;i<3;i++)
 {
  if(s[i]=='R'&&s[i]==s[i+1]){sum++;}
 }
 printf("%d",sum);
return 0;
}
//  [javascript]
function Main(input) {
  const S = input.trim();

  let answer = "0";

  switch (S) {
    case "RSR":
    case "RSS":
    case "SRS":
    case "SSR":
      answer = "1";
      break;
    case "RRS":
    case "SRR":
      answer = "2";
      break;
    case "RRR":
      answer = "3";
      break;
  }
  
  console.log(answer);

}
// デバッグ用
function debug(){
var input = document.getElementById("input").value;
Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(input) {
  input = input.split('');
  let max = 0;
  let currentMax = 0;
  let current = 'R';
  for (let i = 0;i < input.length;i++) {
    if (input[i] == 'R' && current == 'R') {
      max++;
    } else if (input[i] == 'R') {
      max = 1;
    }
    if (input[i] == 'S' && current == 'R') {
      currentMax = max;
      max = 0;
    }
    current = input[i];
  }
  console.log(Math.max(max, currentMax));
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))
//  [javascript]
function main(arg) {
    let s = arg.split("")

    let ans=0, max=0
    for(let i=0;i <3; i++) {
        if(s[i]==="R") {
            ans++
        } else {
            ans=0
        }
        max=Math.max(max,ans)
    }
    console.log(max)
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const S = input.split("\n");

  let answer = 0;

  switch (S) {
    case "RSR":
    case "RSS":
    case "SRS":
    case "SSR":
      answer = 1;
      break;
    case "RRS":
    case "SRR":
      answer = 2;
      break;
    case "RRR":
      answer = 3;
      break;
  }
  
  console.log('%s',answer);

}
// デバッグ用
function debug(){
var input = document.getElementById("input").value;
Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const S = input;

  let answer = 0;

  switch (S) {
    case "RSR":
    case "RSS":
    case "SRS":
    case "SSR":
      answer = 1;
      break;
    case "RRS":
    case "SRR":
      answer = 2;
      break;
    case "RRR":
      answer = 3;
      break;
  }
  
  console.log(answer);

}
// デバッグ用
function debug(){
var input = document.getElementById("input").value;
Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const S = input;

  let answer = 0;

  switch (S) {
    case "RSR":
    case "RSS":
    case "SRS":
    case "SSR":
      answer = 1;
      break;
    case "RRS":
    case "SRR":
      answer = 2;
      break;
    case "RRR":
      answer = 3;
  }
  
  console.log(answer);

}
// デバッグ用
function debug(){
var input = document.getElementById("input").value;
Main(input);
}

//* この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	solve(os.Stdin, os.Stdout)
}

func solve(r io.Reader, w io.Writer) {
	scanner := initScanner(r)
	s := scanString(scanner)
	rainyDays := 0
	for _, v := range s {
		if v == 'R' {
			rainyDays += 1
			continue
		}
		if rainyDays > 0 {
			break
		}
	}
	fmt.Fprintln(w, rainyDays)
}

// utilityメソッド群

const maxCapacity = 512 * 1024 // デフォルト値は64*1024

func initScanner(r io.Reader) *bufio.Scanner {
	scanner := bufio.NewScanner(r)
	buf := make([]byte, maxCapacity)
	scanner.Buffer(buf, maxCapacity)
	scanner.Split(bufio.ScanWords) // スペースごとに読み込む
	return scanner
}

func scanString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	ss := strings.Split(sc.Text(), "")

	ct := 0
	max := 0
	for _, s := range ss {
		if s == "R" {
			ct++
			if max < ct {
				max = ct
			}
		} else {
			ct = 0
		}
	}
	fmt.Println(max)
}
//  [go]
package main

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

var (
	sc = bufio.NewReader(os.Stdin)
)

func main() {
	S := scanStr()
	count := 0
	maxC := 0
	last := true
	for _, s := range S {
		if s == 'R' {
			count++
			if maxC == 0 {
				maxC = 1
			}
			if last {
				if maxC < count {
					maxC = count
				}
			}
			last = true
		} else {
			last = false
			count = 0
		}
	}
	fmt.Println(maxC)
}

func absInt(a int) int      { return int(math.Abs(float64(a))) }
func scan(a ...interface{}) { _, err := fmt.Fscan(sc, a...); pnc(err) }
func scanStr() (s string)   { scan(&s); return }
func scanInt() int          { i, err := strconv.Atoi(scanStr()); pnc(err); return i }
func scanFloat() float64    { f, err := strconv.ParseFloat(scanStr(), 64); pnc(err); return f }
func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	solve(os.Stdin, os.Stdout)
}

func solve(r io.Reader, w io.Writer) {
	scanner := initScanner(r)
	s := scanString(scanner)
	rainyDays := 0
	max := 0
	for _, v := range s {
		if v == 'R' {
			rainyDays += 1
		} else {
			max = rainyDays
			rainyDays = 0
		}
	}
	if rainyDays > max {
		max = rainyDays
	}
	fmt.Fprintln(w, max)
}

// utilityメソッド群

const maxCapacity = 512 * 1024 // デフォルト値は64*1024

func initScanner(r io.Reader) *bufio.Scanner {
	scanner := bufio.NewScanner(r)
	buf := make([]byte, maxCapacity)
	scanner.Buffer(buf, maxCapacity)
	scanner.Split(bufio.ScanWords) // スペースごとに読み込む
	return scanner
}

func scanString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}
//  [go]
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

func main() {
	solve(os.Stdin, os.Stdout)
}

func solve(r io.Reader, w io.Writer) {
	scanner := initScanner(r)
	s := scanString(scanner)
	rainyDays := 0
	max := 0
	for _, v := range s {
		if v == 'R' {
			rainyDays += 1
		} else {
			max = rainyDays
			rainyDays = 0
		}
	}
	fmt.Fprintln(w, max)
}

// utilityメソッド群

const maxCapacity = 512 * 1024 // デフォルト値は64*1024

func initScanner(r io.Reader) *bufio.Scanner {
	scanner := bufio.NewScanner(r)
	buf := make([]byte, maxCapacity)
	scanner.Buffer(buf, maxCapacity)
	scanner.Split(bufio.ScanWords) // スペースごとに読み込む
	return scanner
}

func scanString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}
//  [go]
//go:generate echo "https://atcoder.jp/contests/abc175/tasks/abc175_a"
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

type scanner struct{ *bufio.Scanner }

func newScanner(r io.Reader) *scanner {
	s := bufio.NewScanner(r)
	s.Split(bufio.ScanWords)
	s.Buffer(nil, 100000000)
	return &scanner{s}
}

func (s *scanner) String() string {
	s.Scan()
	return s.Text()
}

func (s *scanner) Strings(l int) []string {
	if l == 0 {
		return []string{}
	}
	sl := make([]string, l, l)
	for i := range sl {
		sl[i] = s.String()
	}
	return sl
}

func solve(S string) int {
	switch S {
	case "SSS":
		return 0
	case "SSR", "RSS", "RSR":
		return 1
	case "RRR":
		return 3
	default:
		return 2
	}
}

func main() {
	scan := newScanner(os.Stdin)
	S := scan.String()
	fmt.Println(solve(S))
}
//  [ruby]
s = gets.split("")
ans = 0

if s.include?("R")
  if s[0] == "R" && s[1] == "R" && s[2] == "R"
    ans = 3
  elsif s[0] == "R" && s[1] == "R" || s[1] == "R" && s[2] == "R"
    ans = 2
  else
    ans = 1
  end
else
  ans = 0
end
puts ans
//  [ruby]
case gets.chomp
  when /RRR/
  puts 3
  when /RR/
  puts 2
  when /R/
  puts 1
else
  puts 0
end
//  [ruby]
s=gets.chomp
if s.include?('RRR')
  puts 3
elsif s.include?('RR')
  puts 2
elsif s.include?('R')
  puts 1
else
  puts 0
end
//  [ruby]
s = gets.split("")
p s
#ans = 0
s.length.times{ |i|
	if s[i]== 'R'
		ans += 1
	end
}
if s[1] == 'S' and ans == 2
	ans = 1
end
puts ans
//  [ruby]
s = gets.chomp
sum = 0
p s

if s.match?(/^RRR$/) 
  sum += 3
elsif s.match?(/^RRS$/) ||  s.match?(/^SRR$/)
  sum += 2
elsif s.match?(/^RSS$/) ||  s.match?(/^RSR$/) ||  s.match?(/^SSR$/)
  sum += 1
elsif s.match?(/^SSS$/)
  sum = 0
end

puts sum
//  [ruby]
s = gets.chomp
sum = 0
p s

if s.match?(/^RRR$/) 
  sum += 3
elsif s.match?(/^RRS$/) ||  s.match?(/^SRR$/)
  sum += 2
elsif s.match?(/^RSS$/) ||  s.match?(/^RSR$/) ||  s.match?(/^SSR$/)
  sum += 1
else
  sum = 0
end

puts sum
//  [rust]
// -*- coding:utf-8-unix -*-

use proconio::input;

fn main() {
    input! {
        s: String,
    }

    let rainy_days = (s as String)
        .split("S")
        .map(|rainy| rainy.len())
        .max()
        .unwrap();

    println!("{}", rainy_days);
}
//  [rust]
use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
#[fastout]
fn main() {
    input!{
        s: Chars,
    }

    let mut cnt = 0;
    let mut flag = false;
    for i in s {
        if flag==false && i=='R' {
            cnt = 1;
            flag = true;
        } else if flag==true && i=='R' {
            cnt += 1;
        } else {
            flag = false;
        }
    }

    println!("{}", cnt);

}
//  [rust]
use proconio::{input, marker::Bytes};

fn main() {
    input!(s: Bytes);
    let mut ans = 0;
    let mut cur = 0;
    for c in s {
        if c == b'R' {
            cur += 1;
        } else {
            cur = 0;
        }
        ans = ans.max(cur);
    }
    println!("{}", ans);
}
//  [rust]
#[cfg_attr(cargo_equip, cargo_equip::equip)]
use ::lib::input;
#[allow(unused_imports)]
use std::string;
fn main() {
    input! {
        s:String
    }
    if s.contains("R") {
        if s.contains("RR") {
            if s.contains("RRR") {
                println!("3");
            } else {
                println!("2");
            }
        } else {
            println!("1");
        }
    } else {
        println!("0");
    }
}
//  [rust]
use std::io;

fn gets() -> String {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).ok();
    buf
}

fn main() {
    let line = gets();
    let s = line.trim();
    if s == "RRR" {
        println!("3");
    } else if (&s[0..2] == "R") || (&s[1..3] == "R") {
        println!("2");
    } else if (&s[0..1] == "R") || (&s[1..2] == "R") || (&s[2..3] == "R") {
        println!("1");
    } else {
        println!("0");
    }
}
//  [rust]
// unihernandez22
// https://atcoder.jp/contests/abc175/tasks/abc175_a
// implementation

use std::io::stdin;

fn main() {
    let mut s = String::new();
    stdin().read_line(&mut s).unwrap();
    let s = s.trim();

    let mut r = 0;
    for i in s.chars() {
        if i == 'R' {
            r += 1;
        }
    }
    println!("{}",
        if s[1..1] == *"S" {
            if r == 0 {
                0
            } else {
                1
            }
        } else {
            r
        }
    );
}
//  [swift]
let S = Array(readLine()!)
if S[0] == "R" {
    if S[1] == "R" {
        print(S[2] == "R" ? 3 : 2)
    } else {
        print(1)
    }
} else {
    if S[1] == "R" {
        print(S[2] == "R" ? 2 : 1)
    } else {
        print(S[2] == "R" ? 1 : 0)
    }
}
//  [swift]
let s = readLine()!

switch s {
case "RRR": print(3)
case "RRS", "SRR": print(2)
case let x where x.contains("R"): print(1)
default: print(0)
}
//  [swift]
func main() {
    let s = readLine()!
    var maxCount = 0
    var count = 0
    for character in s {
        if character == "R" {
            count += 1
            if maxCount <= count {
                maxCount = count
            }
        } else {
            count = 0
        }
    }
    print(maxCount)
}

main()
//  [swift]
func main() {
  print("hello")
}
//  [swift]
import Foundation

func main() {
    guard let line = readLine() else { return }
    //let inputs = line.components(separatedBy: " ").compactMap() { Int($0) }
    var inputs = [String]()
    for a in line {
        inputs.append(String(a))
    }
    var count = 0
    if inputs[1] == "R" {
        count += 1
        if inputs[0] == "R" {
            count += 1
            if inputs[2] == "R" {
                count += 1
            }
        }
    } else {
        if inputs[0] == "R" || inputs[2] == "R" {
            count += 1
        }
    }
    print(count)
}
main()
//  [swift]
let S: String = readLine()!

if S == "RRR" {
    print(3)
} else if S == "SSR" || S == "RRS" {
    print(2)
} else if S == "SSS" {
    print(0)
} else {
    print(1)
}
//  [typescript]
import * as fs from 'fs';


const input = fs.readFileSync("/dev/stdin", "utf8").split(/\s/);

const s:string = input[0];

if(s === "RRR")
    console.log(3);
else if(s === "SRR" || s === "RRS")
    console.log(2);
else if(s === "SSR" || s === "RSS" || s==="SRS" || s==="RSR")
    console.log(1);
else
    console.log(0);
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc075 {
    export class A {
        public main(args: string): void {

            let ans: number = 0;
            args.split('').reduce((prev: string, cur: string, idx: number) => {
                if (cur === 'S') return cur;
                if (ans === 0 && cur === 'R') {
                    ans++
                } else if (prev === 'R' && cur === 'R') {
                    ans++;
                }
                return cur;
            }, 'R');
            console.log(ans);
        }
    }

    const args: string = fs.readFileSync('/dev/stdin', 'utf8').trim();
    const task: AtCoder.abc075.A = new A();
    task.main(args);
}
//  [typescript]
import { readFileSync } from 'fs'

function main(input: string) {
  const rains = input.split(/S+/g)
  const days = (rains.map(s => s.length))
  const result = Math.max(...days)

  console.log(result)
}

main(readFileSync('/dev/stdin', 'utf8').trim())
//  [typescript]
function main(input: String) {
    if (input.charAt(0) === 'S') {
        if (input.charAt(1) === 'S') {
            if (input.charAt(2) === 'S') {
                console.log('0');
            } else {
                console.log('1');
            }
        } else {
            if (input.charAt(2) === 'S') {
                console.log('1');
            } else {
                console.log('1');
            }
        }
    } else {
        if (input.charAt(1) === 'S') {
            if (input.charAt(2) === 'S') {
                console.log('2');
            } else {
                console.log('1');
            }
        } else {
            if (input.charAt(2) === 'S') {
                console.log('2');
            } else {
                console.log('3');
            }
        }
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
// A - Rainy Season
import { readFileSync } from 'fs';
const input = readFileSync('/dev/stdin', 'utf8');

switch (input) {
  case 'RRR':
    console.log(3);
    break;
  case 'SSS':
    console.log(0);
    break;
  case 'SRR':
  case 'RRS':
    console.log(2);
    break;
  default:
    console.log(1);
    break;
}
//  [typescript]
s = input()
if s == 'RRR':
  print(3)
elif s[0:2] == 'RR' or s[1:3] == 'RR':
  print(2)
elif 'R' in s:
  print(1)
else:
  print(0)
//  [python]
a=int(input())
s=input()
if a>=3200:
  print(s)
else:
  print('red')
//  [python]
a = int(input())
s = input()

if a < 3200:
    s = "red"
    
print(s)
//  [python]
A = int(input())
S = input()
if A >= 3200:
    print(S)
else:
    print('red')
//  [python]
a=int(input())
s=str(input())

if a>=3200:
  print('red')
else:
  print(s)
//  [python]
def ron():
    a=[input('a number between 2800~5000 and color ') for i in range(0,2) ]
    k=int(a[0])
    if k>=2800:
        if k<=5000:
            pass
        else:
          print('Wrong input.Please input again.')
          ron()
         
    else:
        print('Wrong input.Please input again.')
        ron()
        
   

    if a[1]=='pink':
        s='red'
    elif a[1]=='red':
        s='pink'
    else:
        print('Wrong input.Please input again.')
        ron()
    if k>=3200:
        print(a[1])
    else:
        print(s)


ron()
//  [python]
import sys
sys.setrecursionlimit(10 ** 6)
def input():
    return sys.stdin.readline()[:-1]

def dfs(v,prev = -1):
    for u in graph[v]:
        if u == prev:
            continue
        point[u] += point[v]
        dfs(u,v)

N, Q = list(map(int,input().split()))
graph = [[] for _ in range(N)]
point = [0]*N

for i in range(N-1):
    a,b = list(map(int,input().split()))
    graph[a-1].append(b-1)
    graph[b-1].append(a-1)

for i in range(Q):
    p,x = list(map(int,input().split()))
    p -= 1
    point[p] += x

dfs(0)
print(*point)
//  [java]
import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int a = Integer.parseInt(br.readLine());
        String s = br.readLine();
        
        if ( a < 3200 ) {
            System.out.println("red");
        } else {
            System.out.println(s);
        }
        
    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) {
        FastScanner sc = new FastScanner();
        int a = sc.nextInt();
        String s = sc.next();
        if (a >= 3200) {
            System.out.println(s);
            return;
        }
        System.out.println("red");
    }
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    public boolean hasNext() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}

	void run() {
		Scanner sc = new Scanner();
		int a = sc.nextInt();
		String s = sc.next();
		if (a >= 3200) {
			System.out.println(s);
		} else {
			System.out.println("red");
		}
	}

	void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

}

class Scanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		} else {
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}

	private int readByte() {
		if (hasNextByte())
			return buffer[ptr++];
		else
			return -1;
	}

	private static boolean isPrintableChar(int c) {
		return 33 <= c && c <= 126;
	}

	private void skipUnprintable() {
		while (hasNextByte() && !isPrintableChar(buffer[ptr]))
			ptr++;
	}

	public boolean hasNext() {
		skipUnprintable();
		return hasNextByte();
	}

	public String next() {
		if (!hasNext())
			throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public int nextInt() {
		return (int) nextLong();
	}

	public long nextLong() {
		if (!hasNext())
			throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while (true) {
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			} else if (b == -1 || !isPrintableChar(b)) {
				return minus ? -n : n;
			} else {
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}
}
//  [java]
import java.io.*;
import java.util.*;
import static java.lang.System.out;

public class Main {
    static MyReader in = new MyReader();

    public static void main(String[] args) {
        int a = in.i();
        char[] s = in.s(10);
        out.println(a < 3200 ? "red" : String.valueOf(s));
    }
}

class MyReader extends BufferedReader {
    char[] cbuf = new char[1024];
    int head = 0;
    int tail = 0;

    MyReader() {
        super(new InputStreamReader(System.in));
    }

    char next() {
        if (head == tail) {
            try {
                tail = super.read(cbuf, 0, cbuf.length);
            } catch (IOException e) {
                e.printStackTrace();
            }
            head = 0;
        }
        return cbuf[head++];
    }

    void back() {
        head--;
    }

    boolean minus() {
        boolean minus;
        while (true) {
            char c = next();
            if (!isDelimiter(c)) {
                if (!(minus = c == '-')) back();
                return minus;
            }
        }
    }

    void skip() {
        while (isDelimiter(next()));
        back();
    }

    char[] s(int N) {
        char[] cbuf = new char[N];
        read(cbuf, 0, N);
        return cbuf;
    }

    public int read(char[] cbuf, int off, int len) {
        skip();
        int i;
        for (i = 0; i < cbuf.length; i++) {
            char c = next();
            if (isDelimiter(c)) {
                break;
            }
            cbuf[i] = c;
        }
        return i;
    }

    boolean isDelimiter(char c) {
        return c == ' ' || c == '\n' || c == '\r';
    }

    int i() {
        boolean minus = minus();
        int n = 0;
        while (true) {
            int k = next() - '0';
            if (k < 0 || 9 < k) break;
            n = 10 * n + k;
        }
        return minus ? -n : n;
    }

    int[] ii(final int N) {
        int[] a = new int[N];
        for (int j = 0; j < a.length; j++) a[j] = i();
        return a;
    }

    long l() {
        boolean minus = minus();
        long n = 0;
        while (true) {
            int k = next() - '0';
            if (k < 0 || 9 < k) break;
            n = 10 * n + k;
        }
        return minus ? -n : n;
    }
}
//  [java]
#include <iostream>

using namespace std;

int main(){
    long g = 0;
    string n = "a";
    cin >> g;
    cin >> n;
    if (g >= 3200){
        cout << n << "\n";
    }
    else{
        cout << "red\n";
    }
    return 0;
}
//  [java]
import java.util.*;

public class Main {
	public static void main(String[] args) throws Exception{
	Scanner scn = new Scanner(System.in);
	int a = scn.nextInt();
      String s = scn.next();
      if(a<2800 || a>=5000){
        s = "red";
      }
      System.out.println(s);
	}
}
//  [cpp]
/*
このコード、と～おれ!
Be accepted!
∧＿∧　
（｡･ω･｡)つ━☆・*。
⊂　　 ノ 　　　・゜+.
　しーＪ　　　°。+ *´¨)
 　　　　　　　　　.· ´¸.·*´¨) ¸.·*¨)
		  　　　　　　　　　　(¸.·´ (¸.·'* ☆
					*/

#pragma GCC optimize("Ofast")
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define rep1(i, n) for(int i = 1; i <= (n); ++i)
#define repr(i, n) for(int i = n; i >= 0; --i)
#define reprm(i, n) for(int i = n - 1; i >= 0; --i)
#define prinrynl(a) printf(a ? "yes\n" : "no\n")
#define prinryn(a) printf(a ? "Yes\n" : "No\n")
#define prinrYN(a) printf(a ? "YES\n" : "NO\n")
#define prinrin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.16f\n", a)
#define all(x) (x).begin(), (x).end()

using ll = long long;

const int INF = 2147483647;
const ll LINF = ll(9223372036854775807);

//マクロとかここまで

#include <stdio.h>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <vector>
#include <numeric>

using namespace std;

int ggd(int number1, int number2) {
	int m = number1;
	int n = number2;

	if (number2 > number1) {
		m = number2;
		n = number1;
	}

	while (m != n) {
		int temp = n;
		n = m - n;
		m = temp;
	}

	return m;
}

int lcm(int number1, int number2) {
	return number1 * number2 / ggd(number1, number2);
}

bool is_prime(int64_t x) {
	for (int64_t i = 2; i * i <= x; i++) {
		if (x % i == 0) return false;
	}
	return true;
}
/*-----------------------------------------ここまでライブラリ-----------------------------------------*/



int main() {

	int a;
	char s[114514];
	scanf("%d%*c%s", &a, s);
	printf("%s\n", a >= 3200 ? s : "red");

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


int main(int argc, char const *argv[])
{
    int a;
    scanf("%d", &a);

    char str[11];
    scanf("%s", str);

    if(a < 3200){
        printf("red\n");
    }
    else{
        printf("%s\n", str);
    }
    
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

#define int long long
#define rep(i, a, n) for (int i = a; i < n; i++)
#define pb push_back
#define eb emplace_back
#define dump(x) cout << #x << " = " << (x) << endl
#define chk() cout << "now" << endl;
#define ALL(x) (x).begin(), (x).end()
#define SORT(c) sort((c).begin(), (c).end())
#define SORTG(c) sort(ALL(c), greater<int>());
#define fi first
#define se second
int INF = 1e9 + 7;

typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vector<int>> mat;

template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}

int a;
string s;

void solve() {
  cin>>a>>s;
  if(a>=3200) cout<<s<<endl;
  else cout<<"red"<<endl;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);

  // cout << fixed << setprecision(10);

  solve();

  return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main(){
    int n;
    char s[100];
    scanf("%d%s", &n, s);
    if(n <= 3200) printf("%s\n", s);
    else printf("red\n");
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

//#define int long long
typedef long long ll;

typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
// #define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;

//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
	ll res = 1;
	while (n) {
		if (n & 1)res = res * a%m;
		a = a * a%m; n >>= 1;
	}
	return res;
}

struct modint {
	ll n;
	modint() :n(0) { ; }
	modint(ll m) :n(m) {
		if (n >= mod)n %= mod;
		else if (n < 0)n = (n%mod + mod) % mod;
	}
	operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
	if (n == 0)return modint(1);
	modint res = (a*a) ^ (n / 2);
	if (n % 2)res = res * a;
	return res;
}

//逆元(Eucledean algorithm)
ll inv(ll a, ll p) {
	return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }

const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
	fact[0] = modint(1);
	for (int i = 0; i < max_n - 1; i++) {
		fact[i + 1] = fact[i] * modint(i + 1);
	}
	factinv[max_n - 1] = modint(1) / fact[max_n - 1];
	for (int i = max_n - 2; i >= 0; i--) {
		factinv[i] = factinv[i + 1] * modint(i + 1);
	}
}
modint comb(int a, int b) {
	if (a < 0 || b < 0 || a < b)return 0;
	return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;

int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };




void solve() {
    int a; string s; cin >> a >> s;
    if(a < 3200) cout << "res" << endl;
    else cout << s << endl;
}

signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  //cout << fixed << setprecision(10);
  //init_f();
  //init();
  //int t; cin >> t; rep(i, t)solve();
  solve();
//   stop
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;

int main() {
  
  int a;
  string s;
  cin >> A >> s;
  
  if (A>=3200) {
    cout << s << endl;
  }
  else {
    cout << "red" << endl;
  }
  
  

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

int main(){
	int a;
	char string[10];
	scanf("%d", &a);
	scanf("%s", string);
	if(a>=3200) printf("%s", string);
	else printf("red");
	
	return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

int main()
{
    int i, j, k,a;
    char s[20];
    scanf("%d", &a);
    scanf("%s", &s);
    if(a>=3200)
        printf("%s", s);
    else
        printf("red");
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
	int a;
	char s[16];
	scanf("%d%s", &a, s);
	if (a >= 3200)
		printf("%s\n", s);
	else
		printf("red\n");
	return 0;
}
//  [c]
#include <bits/stdc++.h>
using namespace std;
int main(void){
    long long int n,m,i=0,j,h,a;
    string s;
    cin >> a >> s;
    h=s.size();
    if(a<3200)
    {
        cout << "red" << endl;
    }
    else
    {
        cout << s << endl;
    }
    
    return 0;

}
//  [c]
#include <stdio.h>
int main(){
int a;
char b[100];
scanf ("%d %s",&a,b);
if (a<3600){
printf ("red");
}
else{
printf ("%s",b);
}
return 0;
}
//  [c]
#include<stdio.h>

int main(void){
  int a;
  char c[11];
  scanf("%d",&a);
  scanf("%s",c);
  if(a>=3200){
    prinf("%s\n",c);
  }else{
    printf("red\n");
  }
  return 0;
}
//  [javascript]
const Main = (input) => {
  const dataArray = input.split('\n');
  const number = Number(dataArray[0]);
  const s = dataArray[1];
  if(number >= 3200){
    console.log(s);
  } else {
    console.log('red');
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function main(arg) {
	arg = arg.trim().split('\n');
  	var a = parseInt(arg[0], 10),
        s = arg[1], flg = 3200, out = '';
  if (a >= flg) {
  	out = s;
  } else {
  	out = 'red';
  }
  console.log(out)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
const Main = (input) => {
input = input.split('\n')
const a = input[0];
const s = input[1];

if(a>=3200){
  console.log(s);
}
else{
  console.log("red");
}
  
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"))
//  [javascript]
function main(arg) {
	arg = arg.trim().split('\n');
  	var a = parseInt(arg[0], 10),
        out = arg[1], flg = 3200;
  if (a <= flg) {
  	out = 'red';
  } 
  console.log(out)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(arg) {
	arg = arg.trim().split('\n');
  	var a = parseInt(arg[0], 10),
        out = arg[1], flg = 3200;
  if (a >= flg) {
  	out = 'red';
  }
  console.log(out)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
'use strict';
function main(input) {
  const args = input.split('\n'),
        N = parseInt(args[0]),
        D = args[1].split(' ');
  for (let i = 0; i < N; ++i) {
    D[i] = parseFloat(D[i]);
  }
  D.sort();
  let value = D[0];
  for (let i = 1; i < N; ++i) {
    value = (value + D[i]) /2;
  }
  console.log(value);
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import "fmt"

func main() {
	var a int
	var s string

	fmt.Scan(&a, &s)

	if a >= 3200 {
		fmt.Println(s)
	}
	if a < 3200 {
		fmt.Println("red")
	}

}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func main() {
	sc.Split(bufio.ScanWords)
	a, s := nextInt(), next()
	if a >= 3200 {
		fmt.Println(s)
	} else {
		fmt.Println("red")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Split(bufio.ScanWords)
	log.SetFlags(log.Lshortfile)
	a := nextInt()
	s := nextString()
	if a >= 3200 {
		fmt.Println(s)
	} else {
		fmt.Println("red")
	}
}

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

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

var dy = []int{0, 1, 0, -1}
var dx = []int{1, 0, -1, 0}
var MAX = math.MaxInt32

func pow(a, b int) int {
	return int(math.Pow(float64(a), float64(b)))
}

func lcm(a, b int) int {
	return a * b / gcd(a, b)
}
func gcd(a, b int) int {
	if a < b {
		a, b = b, a
	}
	for b != 0 {
		a, b = b, a%b
	}
	return a
}
func max(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r < a[i] {
			r = a[i]
		}
	}
	return r
}
func min(a ...int) int {
	r := a[0]
	for i := 0; i < len(a); i++ {
		if r > a[i] {
			r = a[i]
		}
	}
	return r
}
func sum(a []int) (r int) {
	for i := range a {
		r += a[i]
	}
	return r
}
func abs(a int) int {
	if a < 0 {
		return -a
	}
	return a
}

type pair struct {
	a, b int
}

type pairs []pair

func (p pairs) Len() int {
	return len(p)
}
func (p pairs) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

func (p pairs) Less(i, j int) bool {
	if p[i].a == p[j].a {
		return p[i].b < p[j].b
	}
	return p[i].a < p[j].a
}
//  [go]
package main

import "fmt"

func main() {
	var a int
	var s string

	if a > 3200 {
		fmt.Println(&s)
	} else {
		fmt.Println("red")
	}
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

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

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

func main() {
	sc.Split(bufio.ScanWords)
	a, s := nextInt(), nextLine()
	if a > 3200 {
		fmt.Println(s)
	} else {
		fmt.Println("red")
	}
}
//  [go]
package main

import(
  "fmt"
)

func main() {
  var a int
  var s string
  fmt.Scan(&a,&s)
  if a > 3200 {
    fmt.Println(s)
  }else{
    fmt.Println("pink")
  }
}
//  [ruby]
# 整数 a と、英小文字からなる文字列 s が入力されます。
# 入力は以下の形式で標準入力から与えられる。
a = gets.chomp.to_i
s = gets.chomp

# a が 3200 以上なら s と出力し、a が 3200 未満なら red と出力せよ。
if a >= 3200
  puts s
else
  puts 'red'
end
//  [ruby]
if gets.to_i >= 3200
  puts gets
else
  puts 'red'
end
//  [ruby]
num = gets.to_i
line = gets.chomp

if num >= 3200
  puts line
else
  puts 'red'
end
//  [ruby]
n, q = gets.split.map(&:to_i)


g = Array.new(n+1){[]}
(n-1).times do
  a,b = gets.split.map{ |i| i.to_i }# 0-indexedに変更
  g[a].push(b)
  g[b].push(a)
end

points = Array.new(n+1,0)
q.times do |i|
  node,x = gets.split.map(&:to_i)
  points[node] += x
end

que = [1] # BFS, 木の根である頂点0から足す
used = Array.new(n,false)
while v = que.shift # 破壊的メソッド。空配列は変更が行わずnilを返す
  used[v] = true #
  g[v].each do |w|
    used[w] ? next : que.push(w)
    points[w] += points[v]
  end
end

puts points.drop(1).join(' ')
//  [ruby]
a = gets.chomp.to_i
s = gets.chomp
puts a >= 3200 ? s : "red2
//  [ruby]
a = gets.chomp.to_i
array = gets.split(" ").map(&:to_i)
sum = 0
 
a.times do |i|
    sum += Rational(1, array[i])
end
 
puts Rational(1, sum).to_f
//  [rust]
use std::io;

fn main() {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let a:i32 = match buf.trim().parse() {
		Ok(n) => n,
		_ => panic!(""),
	};
	
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let s = buf.trim();
	
	if a < 3200 {
		println!("red");
	}else{
		println!("{}", s);
	}
}
//  [rust]
use std::io::*;
use std::str::FromStr;

#[allow(dead_code)]
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")
}

fn main() {
    let a = read::<i64>();
    let s = read::<String>();
    println!("{}", if a >= 3200 { &s } else { "red" });
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

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

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

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

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

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

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

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

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

use std::iter::Iterator;


fn main() {
    input!{
        a:i32,
        s:String,
    }

    if a < 3200 {
        println!("red")
    }else{
        println!("{}", s)
    }
}
//  [rust]
if __name__ == "__main__":
    n = int(input())
    s = input()
    if n>3199:
        print(s)
    else:
        print("red")
//  [rust]
#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use std::cmp::*;
use std::collections::*;
use std::mem::*;

fn main() {
    let (r, w, e) = (std::io::stdin(), std::io::stdout(), std::io::stderr());
    let mut io = IO::new(r.lock(), w.lock(), e.lock());
    let n = io.read::<usize>();
    let a = io.readn::<usize>(n);
    let mut sowa = 0f64;

    for &x in a.iter() {
        sowa += 1.0f64 / x as f64;
    }
    io.writeln(1f64 / sowa);
}

static MX: usize = 1010101;
static MOD: i64 = 1000000007;
static INF: i64 = std::i64::MAX >> 1;
// IO
use std::io::*;
struct IO<R: Read, W: Write, E: Write> {
    Read: R,
    Write: BufWriter<W>,
    Error: BufWriter<E>,
}
impl<R: Read, W: Write, E: Write> IO<R, W, E> {
    fn new(r: R, w: W, e: E) -> IO<R, W, E> {
        IO {
            Read: r,
            Write: BufWriter::new(w),
            Error: BufWriter::new(e),
        }
    }
    fn read<T>(&mut self) -> T
    where
        T: std::str::FromStr,
    {
        let next: String = self
            .Read
            .by_ref()
            .bytes()
            .map(|c| c.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();
        next.parse().ok().unwrap()
    }
    fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
    fn chari(&mut self) -> Vec<i64> {
        self.chars()
            .iter()
            .map(|&c| (c as u8 - b'0') as i64)
            .collect::<Vec<i64>>()
    }
    fn readn<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read::<T>()).collect::<Vec<_>>()
    }
    fn readmat<T: std::str::FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>> {
        (0..n).map(|_| self.readn(m)).collect()
    }
    fn write<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
    }
    fn writeln<S: ToString>(&mut self, val: S) {
        self.Write.write(val.to_string().as_bytes());
        self.Write.write(b"\n");
    }
    fn debug<S: std::fmt::Debug>(&mut self, val: S) {
        writeln!(self.Error, "(debug) {:?}", &val);
    }
    fn debug2<S: std::fmt::Debug, T: std::fmt::Debug>(&mut self, val1: S, val2: T) {
        writeln!(self.Error, "(debug2) {:?} -> {:?}", val1, val2);
    }
    fn debug3<S: std::fmt::Debug, T: std::fmt::Debug, U: std::fmt::Debug>(
        &mut self,
        val1: S,
        val2: T,
        val3: U,
    ) {
        writeln!(
            self.Error,
            "(debug3) {:?} -> {:?} -> {:?}",
            val1, val2, val3
        );
    }
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        a:i32,
        s:String
    };

    if a>=3200 {
        println!("{}",s);
    }
    else {
        println!("red");
    }

    
}
//  [swift]
let a=Int(readLine()!)!
let s=readLine()!
if a>=3200{
  print(s)
}else{
  print("red")
}
//  [swift]
let a=Int(readLine()!)!
let s=readLine()!

if( a >= 3200 ) {
  print( s )
} else {
  print( "red" )
}
//  [swift]
import Foundation

let a = Int(readLine()!)
let s = readLine()!

if a >= 3200 {
  print(s)
} else {
  print("red")
}
//  [swift]
let a=Int(readLine()!)!
let s=readLine!
if a>=3200{
  print(s)
}else{
  print("red")
}
//  [swift]
a=Int(readLine()!)!
s=readLine!
if a>=3200{
  print(s)
}else{
  print("red")
}
//  [swift]
import Foundation

let a = readLine()!
let s = readLine()!

if a >= 3200 {
  print(s)
} else {
  print("red")
}
//  [typescript]
((input: string): void => {
    const [a, s] = input.split("\n")
    console.log(Number(a) >= 3200 ? s : "red");
})(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [typescript]
import * as fs from "fs"

function solve() {
  const input = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n') as string;
  const a = +input[0];
  const s = input[1];
  if (a >= 3200) {
    console.log(s);
  } else {
    console.log('red');
  }
}

solve();
//  [typescript]
import * as fs from 'fs';

//in
//
//out
//
const main = (inp: string) => {
    const a: number = parseInt(inp.split('\n')[0]);
    const s: string = inp.split('\n')[1];

    if (a >= 3200) {
        console.log(s);
    } else {
        console.log('red');
    }

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
import * as fs from 'fs';

//in
//
//out
//
const main = (inp: string) => {
    const [a, b]: number = inp.split('\n').map(Number);
    // a+b
    // a-b
    // a*b
    const ans1: number = a + b;
    const ans2: number = a - b;
    const ans3: number = a * b;

    console.log(Math.max(ans1,ans2,ans3));

    // if (ans1 >= ans2 && ans1 >= ans3) {
    //     console.log(ans1);
    // }
    // if (ans2 >= ans1 && ans2 >= ans3) {
    //     console.log(ans2);
    // }
    // if (ans3 >= ans1 && ans3 >= ans2) {
    //     console.log(ans3);
    // }

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
import * as fs from 'fs';

//in
//
//out
//
const main = (inp: string) => {
    const a: number = parseInt(inp.split('\n')[0]);
    const s: string = inp.split('\n')[1];

    if (a >= 3200) {
        console.log('red');
    } else {
        console.log(s);
    }

};

main(fs.readFileSync('/dev/stdin', 'utf8').trim());
//  [typescript]
'use strict'
function main(input: string) {
    const n: number = Number(input.split('\n')[0]);
    if (n > 3200) {
        console.log(input.split('\n')[1]);
        return;
    }
    console.log("red");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
import math
a, b = map(int, input().split())
print(math.ceil((a+b)/2))
//  [python]
a,b = map(int, input().split())
s = (a+b)//2
if (a+b)%2:
  print(s+1)
else:
  print(s)
//  [python]
a, b = map(int, input().split())
print(-(-(a + b) // 2))
//  [python]
a,b=map(int,input().split())
import math
print(math.ceil(a*b/2))