import java.lang.Math.abs
import java.math.BigInteger

fun read() = readLine()!!

operator fun BigInteger.dec(): BigInteger = this.subtract(BigInteger.ONE)

// 階乗 (n!)
tailrec fun fact(n: BigInteger, ans: BigInteger = BigInteger.ONE) : BigInteger {
    if(n.compareTo(BigInteger.ONE) < 1) return ans
    return fact(n.dec(), ans * n)
}

// 最大公約数
tailrec fun gcd(a: Int, b: Int): Int {
    if(b == 0) return a
    return gcd(b, a % b)
}

// フィボナッチ数
//
tailrec fun fib(n: BigInteger, a: BigInteger = BigInteger.ZERO, b: BigInteger = BigInteger.ONE): BigInteger {
    if(n == BigInteger.ONE) return a
    return fib(n.dec(), b, a + b)
}

// 累乗(バイナリ法)
// a^n
tailrec fun pow(a: BigInteger, n: Int, ans: BigInteger = BigInteger.ONE): BigInteger {
    if(n == 0) return ans
    return pow(a * a, n.ushr(1), if(n.and(1) == 1) ans * a else ans)
}

tailrec fun newton(
    f: (Double) -> Double,
    df: (Double) -> Double,
    x: Double,
    eps: Double = Float.MIN_VALUE.toDouble()
): Double {
    val xnew = x - f(x) / df(x)
    if(abs(xnew - x) < eps) return xnew
    return newton(f, df, xnew, eps)
}

tailrec fun iteration(
    r: (Double) -> Double,
    x: Double,
    eps: Double = Float.MIN_VALUE.toDouble()
): Double {
    val xnew = r(x)
    if(abs(xnew - x) < eps) return xnew
    return iteration(r, xnew, eps)
}

// 二分探索 (木構造使ってない)
fun binarySearch(list: List<Int>, target: Int): Int {
    if(target < list.first() || list.last() < target) return -1

    var first = 0
    var last = list.size
    while (first + 1 != last) {
        val center = first + (last - first) / 2
        val centerVal = list[center]

        if(centerVal == target) return centerVal

        if(centerVal < target) first = center
        else last = center
    }
    return -1
}

fun main(vararg args: String) {
    println(when(read()) {
        "Sunny" -> "Cloudy"
        "Cloudy" -> "Rainy"
        "Rainy" -> "Sunny"
        else -> "Err"
    })
}