Problem:
Score : 300 points

Problem Statement

You are given a string S consisting of lowercase English letters.
Another string T is initially empty.
Determine whether it is possible to obtain S = T by performing the following operation an arbitrary number of times:

Append one of the following at the end of T: dream, dreamer, erase and eraser.

Constraints

1≦|S|≦10^5

S consists of lowercase English letters.

Input

The input is given from Standard Input in the following format:

S

Output

If it is possible to obtain S = T, print YES. Otherwise, print NO.

Sample Input 1

erasedream

Sample Output 1

YES

Append erase and dream at the end of T in this order, to obtain S = T.

Sample Input 2

dreameraser

Sample Output 2

YES

Append dream and eraser at the end of T in this order, to obtain S = T.

Sample Input 3

dreamerer

Sample Output 3

NO

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::*;
use std::str::FromStr;

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 s: String = read();
    let p = ["dreameraser", "dreamerase", "dreamer", "dream", "eraser", "erase"];

    let mut u: String = String::from(s.to_string());
    let mut t: String = "".to_string();

    let mut ans = None;

    'outer: loop {
        for x in p.into_iter() {
            let i = match u.find(x) {
                None => continue,
                Some(i) => i,
            };
            if i != 0 {
                continue
            }
            t = format!("{}{}", t, x);
            u = u[x.to_string().len()..u.len()].to_string();
            println!("{}", u);
            if s == t {
                ans = Some("YES");
                break 'outer;
            }
            continue 'outer;
        }
        break
    }
    println!("{}", ans.unwrap_or("NO"));
}