Problem:
Score : 100 points

Problem Statement

You will be given an integer a and a string s consisting of lowercase English letters as input.

Write a program that prints s if a is not less than 3200 and prints red if a is less than 3200.

Constraints

2800 \leq a < 5000

s is a string of length between 1 and 10 (inclusive).

Each character of s is a lowercase English letter.

Input

Input is given from Standard Input in the following format:

a
s

Output

If a is not less than 3200, print s; if a is less than 3200, print red.

Sample Input 1

3200
pink

Sample Output 1

pink

a = 3200 is not less than 3200, so we print s = pink.

Sample Input 2

3199
pink

Sample Output 2

red

a = 3199 is less than 3200, so we print red.

Sample Input 3

4049
red

Sample Output 3

red

a = 4049 is not less than 3200, so we print s = red.

Solution in Fortran (gfortran v4.8.4) (judge verdict: Runtime Error)

module pair_stack
    implicit none
    private
    integer, allocatable:: stack(:)
    integer:: depth, max_depth
    public:: init, pop, push, is_remaining

contains
    subroutine init(x)
        integer, intent(in):: x
        max_depth = x
        allocate(stack(x))
        stack(:) = 0
        depth = 0
    end subroutine

    subroutine pop(a)
        integer, intent(out):: a
        if (depth <= 0)stop '-- --Stack is empty'
        a = stack(depth)
        depth = depth - 1
        ! print*, '-- -- poped =>', a, b
    end subroutine

    subroutine push(a)
        integer, intent(in):: a
        if (depth >= max_depth)stop '-- --Stack over flow'
        ! print*, '-- -- pushed =>', a, b
        depth = depth + 1
        stack(depth) = a
    end subroutine

    function is_remaining() result(ret)
        logical:: ret
        if (depth <= 0)then
            ret = .false.
        else
            ret = .true.
        end if
    end function
end module


program main
    implicit none
    type to
        integer,allocatable :: arr(:)
    end type
    integer:: N, Q
    integer, allocatable:: px(:, :), counter(:), ab(:, :), cnum(:)
    type(to),allocatable :: tree(:)
    integer:: i,a,b

    read*, N,Q
    allocate(px(2, Q), counter(N), ab(2, N-1), cnum(N), source=0)
    allocate(tree(N))


    do i=1, N-1
        read*, a,b
        cnum(a) = cnum(a) + 1
        cnum(b) = cnum(b) + 1
        ab(1,i) = a
        ab(2,i) = b
    enddo

    read*, px(1:2, 1:Q)

    do i=1,N
        allocate(tree(i)%arr(cnum(i)),source=0)
    enddo

    cnum(1:N) = 1

    do i=1,N-1
        a = ab(1, i)
        b = ab(2, i)
        tree(a)%arr(cnum(a)) = b
        tree(b)%arr(cnum(b)) = a
        cnum(a) = cnum(a) + 1
        cnum(b) = cnum(b) + 1
    enddo



    do i=1,Q
        counter(px(1, i)) = counter(px(1, i)) + px(2, i)
    enddo


    call dfs()
    
    do i=1, N
        write(*, '(i0)') counter(i)
    enddo

contains
    subroutine dfs()
        use pair_stack
        integer:: v, u, p, tmp, child
        logical:: visited(N)
        call init(10 + int(log10(real(N))))
        call push(1)
        child = 0
        p = 0
        visited(1:N) = .false.
        do while(is_remaining())
            call pop(v)
            visited(v) = .true.
            do i=1, size(tree(v)%arr)
                u = tree(v)%arr(i)
                if(visited(u)) cycle
                call push(u)
                counter(u) = counter(u) + counter(v)
            enddo
        enddo

    end subroutine
end program main