jiahuimbzuai/CoQuIR huggingface dataset:
//  [c]
#include <stdio.h>
#include <string.h>
int main(void){
  char s[100000];
  char t[100000]; // maerd , remaerd , esare , resare 
  int s_length,i;
  scanf("%s",s);
  s_length = strlen(s);
  for(i=s_length-1;i>=0;i--){
    if(s[i]=='m'){
      t[i]='m'; t[i-1]='a'; t[i-2]='e'; t[i-3]='r'; t[i-4]='d';
      i=i-4;
    }else if(s[i]=='e'){
      t[i]='e'; t[i-1]='s'; t[i-2]='a'; t[i-3]='r'; t[i-4]='e';
      i=i-4;
    }else if(s[i-2]=='m'){
      t[i]='r'; t[i-1]='e'; t[i-2]='m'; t[i-3]='a'; t[i-4]='e';
      t[i-5]='r'; t[i-6]='d';
      i=i-6;
    }else if(s[i-2]=='s'){
      t[i]='r'; t[i-1]='e'; t[i-2]='s'; t[i-3]='a'; t[i-4]='r'; t[i-5]='e';
      i=i-5;
    }
  }
    if(strcmp(s,t)==0 && i==0){
      printf("YES\n");
    }else{
      printf("NO\n");
    }

  return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>
int main(void){
  char s[100000];
  char t[100000]; // maerd , remaerd , esare , resare 
  int s_length,i;
  scanf("%s",s);
  s_length = strlen(s);
  for(i=s_length-1;i>=0;i--){
    if(s[i]=='m'){
      t[i]='m'; t[i-1]='a'; t[i-2]='e'; t[i-3]='r'; t[i-4]='d';
      i=i-4;
    }else if(s[i]=='e'){
      t[i]='e'; t[i-1]='s'; t[i-2]='a'; t[i-3]='r'; t[i-4]='e';
      i=i-4;
    }else if(s[i-2]=='m'){
      t[i]='r'; t[i-1]='e'; t[i-2]='m'; t[i-3]='a'; t[i-4]='e';
      t[i-5]='r'; t[i-6]='d';
      i=i-6;
    }else if(s[i-2]=='s'){
      t[i]='r'; t[i-1]='e'; t[i-2]='s'; t[i-3]='a'; t[i-4]='r'; t[i-5]='e';
      i=i-5;
    }
  }
    if(strcmp(s,t)==0 && i=0){
      printf("YES\n");
    }else{
      printf("NO\n");
    }

  return 0;
}
//  [javascript]
// ABC 049

// inputに入力データ全体が入る
function Main(input) {
  var str = input.split("\n")[0];
  str = str.replace(/eraser/g, '0');
  str = str.replace(/erase/g, '0');
  str = str.replace(/dreamer/g, '0');
  str = str.replace(/dream/g, '0');
  str = str.replace(/0/g, '');
  if(str === '') {
    console.log('YES');
  } else {
    console.log("NO");
  }
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var output;
var input = require("fs").readFileSync("/dev/stdin", "utf8").trim().split("\n");
var obj = {
  "list" : input,
  "index" : 0,
  "max" : input.length,
  "next" : function(){
    if(!this.hasNext()){throw "NoSuchElementException:次に要素は無いよ";}
    var returnObj = this.list[this.index];
    this.index++;
    return returnObj;
  },
  "hasNext" : function(){return (this.index < this.max);}
}
Main();
function next(){return obj.next();}
function hasNext(){return obj.hasNext();}
function myout(t){console.log(t);}//standard output
function myerr(t){console.error(t);}//standard error
//[no]要素の扱い。数値型
//不明値、異常時:引数そのまま返す
//1:数値へ変換 2:半角SPで分割 4:半角SPで分割し、数値配列へ
//6:1文字に分割 7:1文字に分割し、数値配列へ
//8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map((a)=>Number(a));case 6:return i.split("");case 7:return i.split("").map((a)=>Number(a));case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}
function Main() {
  var s = next();
  while(s.length > 0){
     var five = s.slice(-5);
     var six = s.slice(-6);
     var seven = s.slice(-7);
     if(five == "dream" || five == "erase"){
        s = s.slice(0,s.length - 5);
     }else if(seven == "dreamer"){
        s = s.slice(0,s.length - 7);
	 }else if(six == "eraser"){
		s = s.slice(0,s.length - 6);
	 }else{
        myout("NO");
       return;
     }
  }
  myout("YES");
}
//  [javascript]
var S = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')[0]
var ans = 0
var status =0
while(status == 0){
  	//console.log(S,status)
  	if(S != ""){
		var seven = S.slice(-7);
      	var six = S.slice(-6)
		var five = S.slice(-5);
      	//console.log(six)
		if(seven =="dreamer"){
	      S = S.slice(0,-7)
    	}
      	else if(six =="eraser"){
	      S = S.slice(0,-6)
    	}
		else if(five == "dream" || five == "erase"){
          //console.log(five)
	      S = S.slice(0,-5)
	    } 
  		else{
      		status = 1
      		console.log("NO")
    	}
    }else{
      status =1;
      console.log("YES")
    }
}
//  [javascript]
function spilitInput(input) {
  var splited = [];
  var rows = input.split('\n');
  for (var i = 0; i < rows.length; i += 1) {
    splited.push(rows[i].split(' '));
  }
  return splited;
}
function Main(input) {
  var splited = spilitInput(input);
  var S = splited[0][0];
  var ys = ['eraser', 'erase', 'dream', 'dreamer'];
  
while (S.length > 0) {
  var match = false;
  for (var i = 0; i < ys.length && !match; i += 1) {
    if (S.slice(0, ys[i].length) == ys[i]) {
      match = true;
      S = S.replace(ys[i], '');
    }
  }
  if (!match) {
    break;
  }
}
  
  if (S.length > 0) {
    console.log('NO');
  } else {
    console.log('YES');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function spilitInput(input) {
  var splited = [];
  var rows = input.split('\n');
  for (var i = 0; i < rows.length; i += 1) {
    splited.push(rows[i].split(' '));
  }
  return splited;
}
function Main(input) {
  var splited = spilitInput(input);
  var S = splited[0][0];
  var ys = ['dream', 'dreamer', 'erase', 'eraser'];
  
while (S.length > 0) {
  var match = false;
  for (var i = 0; i < ys.length && !match; i += 1) {
    if (S.slice(0, ys[i].length) == ys[i]) {
      match = true;
      S = S.replace(ys[i], '');
    }
  }
  if (!match) {
    break;
  }
}
  
  if (S.length > 0) {
    console.log('NO');
  } else {
    console.log('YES');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const arr = ['dream','dreamer','erase','eraser'];
  const rev = str => [...str].reduce((prev, curr) => curr + prev);
  const arrRev = arr.map(rev);
  const inputRev = rev(input.trim());

  function reducer(str) {
    if (str === '') {
      console.log('YES');
      return;
    }
    const target = str.slice(0, 7);
    const arrFiltered = arrRev.filter(word => target.indexOf(word) === 0);

    if (arrFiltered.length === 0) {
      console.log('NO');
      return;
    } else {
      const len = arrFiltered[0].length;
      const sub = str.substring(len);
      reducer(sub);
    }
  }

  reducer(inputRev);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	// scanner := bufio.NewScanner(reader)
	// scanner.Scan()
	// S := scanner.Text()
	burReader := bufio.NewReaderSize(reader, 100000)
	input := make([]byte, 0, 100000)

	for {
		line, isPrefix, err := burReader.ReadLine()

		if err != nil {
			if err.Error() == "EOF" {
				break
			}

			panic(err)
		}

		input = append(input, line...)

		if !isPrefix {
			break
		}
	}

	words := []string{"dream", "dreamer", "erase", "eraser"}

LOOP_MAIN:
	for i := len(input) - 1; i >= 0; {
	LOOP_WORDS:
		for _, word := range words {
			if len(word)-1 > i {
				continue
			}

			for j := 0; j < len(word); j++ {
				if word[len(word)-1-j] != input[i-j] {
					continue LOOP_WORDS
				}
			}

			i -= len(word)
			continue LOOP_MAIN
		}

		fmt.Fprintln(writer, "NO")
		return
	}
	fmt.Fprintln(writer, "YES")
}
//  [go]
package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	// scanner := bufio.NewScanner(reader)
	// scanner.Scan()
	// S := scanner.Text()
	burReader := bufio.NewReaderSize(reader, 100000)
	buf := make([]byte, 0, 100000)

	for {
		line, isPrefix, err := burReader.ReadLine()

		if err != nil {
			if err.Error() == "EOF" {
				break
			}

			panic(err)
		}

		buf = append(buf, line...)

		if !isPrefix {
			break
		}
	}

	input := buf
	words := []string{"dream", "dreamer", "erase", "eraser"}

LOOP_MAIN:
	for i := len(input) - 1; i >= 0; {
	LOOP_WORDS:
		for _, word := range words {
			if len(word)-1 > i {
				continue
			}

			for j := 0; j < len(word); j++ {
				if word[len(word)-1-j] != input[i-j] {
					continue LOOP_WORDS
				}
			}

			// fmt.Println(i, word)
			i -= len(word)
			// fmt.Println(i, word)
			continue LOOP_MAIN
		}

		fmt.Fprintln(writer, "NO")
		return
	}
	fmt.Fprintln(writer, "YES")
}

func reverse(str string) string {
	runes := []rune(str)

	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}

	return string(runes)
}
//  [go]
package main

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

var (
	reader io.Reader = os.Stdin
	writer io.Writer = os.Stdout
)

func main() {
	run()
}

func run() {
	// scanner := bufio.NewScanner(reader)
	// scanner.Scan()
	// S := scanner.Text()
	burReader := bufio.NewReaderSize(reader, 100000)
	input := make([]byte, 0, 100000)

	for {
		line, isPrefix, err := burReader.ReadLine()

		if err != nil {
			if err.Error() == "EOF" {
				break
			}

			panic(err)
		}

		input = append(input, line...)

		if !isPrefix {
			break
		}
	}

	// words := []string{"dream", "dreamer", "erase", "eraser"}
	words := [][]byte{[]byte("dream"), []byte("dreamer"), []byte("erase"), []byte("eraser")}

LOOP_MAIN:
	for i := len(input) - 1; i >= 0; {
	LOOP_WORDS:
		for _, word := range words {
			if len(word)-1 > i {
				continue
			}

			for j := 0; j < len(word); j++ {
				if word[len(word)-1-j] != input[i-j] {
					continue LOOP_WORDS
				}
			}

			i -= len(word)
			continue LOOP_MAIN
		}

		fmt.Fprintln(writer, "NO")
		return
	}
	fmt.Fprintln(writer, "YES")
}
//  [go]
package main

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

var (
	sc = bufio.NewScanner(os.Stdin)
	ts = []string{"dream", "dreamer", "erase", "eraser"}
	s  = ""
)

func main() {
	s = nextWord()
	if len(s) == 0 {
		fmt.Println("NO")
		return
	}

	if rec(0) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func rec(i int) bool {
	if i == len(s) {
		return true
	}
	for _, t := range ts {
		if len(s[i:]) >= len(t) && s[i:i+len(t)] == t {
			if rec(i + len(t)) {
				return true
			}
		}
	}
	return false
}

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

func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [go]
package main

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

var (
	sc = bufio.NewScanner(os.Stdin)
	ts = []string{"dream", "dreamer", "erase", "eraser"}
	s  = ""
)

func main() {
	s = nextWord()

	if rec(0) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func rec(i int) bool {
	if i == len(s) {
		return true
	}
	for _, t := range ts {
		if len(s[i:]) >= len(t) && s[i:i+len(t)] == t {
			if rec(i + len(t)) {
				return true
			}
		}
	}
	return false
}

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

func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [go]
package main

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

var (
	sc = bufio.NewScanner(os.Stdin)
	ts = []string{"dream", "dreamer", "erase", "eraser"}
	s  = ""
)

func main() {
	s = nextWord()

	if rec(0) {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}

func rec(i int) bool {
	// if len(s) == 0 {
	// 	return false
	// }
	if i == len(s) {
		return true
	}
	for _, t := range ts {
		if strings.HasPrefix(s[i:], t) {
			if rec(i + len(t)) {
				return true
			}
		}
	}
	return false
}

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

func pnc(err error) {
	if err != nil {
		panic(err)
	}
}
//  [ruby]
s = gets.chomp
puts s =~ /\A(dream|dreamer|erase|eraser)*\Z/ ? 'YES' : 'NO'
//  [ruby]
s = gets.chomp
print s =~ /\A(dream|dreamer|erase|eraser)*\z/ ? 'YES' : 'NO'
//  [ruby]
s = gets.chomp.split("")
i = 0
a = []
while true
    arr = []
    kotoba = s.shift
    arr << kotoba
    if kotoba == "d"
        4.times do |i|
            if s != []
            kotoba = s.shift
            arr << kotoba
            end
        end
        if arr.join("") == "dream"
            if s[0] == "r"
                s.shift
            end
        else
            a << "NO"
            break
        end
    elsif kotoba == "e"
        4.times do |j|
            if s != []
            kotoba = s.shift
            arr << kotoba
            end
        end
        if arr.join("") == "erase"
            if s[0] == "r"
                s.shift
            end
        else
            a << "NO"
            break
        end
    else
        a << "NO"
        break
    end
    if s == []
        break
    end
end
if a == []
    puts "YES"
else
    puts a.pop
end
//  [ruby]
ary =  %w[dream dreamer erase eraser]

s = gets.chomp
res = "NO"
4.times do |i|
  4.times do |j|
     res = "YES" if ary[i] + ary[j] == s
  end
end

puts res
//  [ruby]
s = gets.chomp
list = %w(dream dreamer erase eraser)
until s.empty?
  is_match = false
  list.each do |word|
    re = Regexp.new(".*#{word}$")
    if re =~ s
      s = s[0...s.size-word.size]
      is_match = true
      break
    end
  end
  if is_match
    next
  else
    puts 'NO'
    exit
  end
end
puts 'YES'
//  [rust]
fn main() {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    let v: Vec<char> = s.trim().chars().collect();

    const D: [char; 5] = ['d', 'r', 'e', 'a', 'm'];
    const E: [char; 5] = ['e', 'r', 'a', 's', 'e'];
    const A: [char; 3] = ['a', 's', 'e'];
    const R: [char; 2] = ['e', 'r'];
    const W: [char; 1] = ['r'];

    let mut i = 0;
    let mut q = 0;
    loop {
        if i >= v.len() {println!("YES"); return;}
        let r = v.len() - i;
        if q == 0 {
            if r >= 5 && &v[i..i+5] == D {i += 5; q = 1;}
            else if r >= 5 && &v[i..i+5] == E {i += 5; q = 2;}
            else {println!("NO"); return;}
        }
        else if q == 1 {
            if r >= 5 && &v[i..i+5] == D {i += 5; q = 1;}
            else if r >= 2 && &v[i..i+2] == R {i += 2; q = 3;}
            else {println!("NO"); return;}
        }
        else if q == 2 {
            if r >= 5 && &v[i..i+5] == D {i += 5; q = 1;}
            else if r >= 5 && &v[i..i+5] == E {i += 5; q = 2;}
            else if r >= 1 && &v[i..i+1] == W {i += 1; q = 3;}
            else {println!("NO"); return;}
        }
        else if q == 3 {
            if r >= 5 && &v[i..i+5] == D {i += 5; q = 1;}
            else if r >= 5 && &v[i..i+5] == E {i += 5; q = 2;}
            else if r >= 3 && &v[i..i+3] == A {i += 3; q = 2;}
            else {println!("NO"); return;}
        }
    }
}
//  [rust]
pub fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

pub fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

pub fn read_vec2<T: std::str::FromStr>(n: usize) -> Vec<Vec<T>> {
    (0..n).map(|_| read_vec()).collect()
}

pub fn read_col<T: std::str::FromStr>(n: usize) -> Vec<T> {
    (0..n).map(|_| read()).collect()
}

fn remove_erase(v: &mut Vec<char>) -> bool {
    if v.len() < 5 {
        return false;
    }
    let e2 = v.pop().unwrap();
    let s = v.pop().unwrap();
    let a = v.pop().unwrap();
    let r = v.pop().unwrap();
    let e1 = v.pop().unwrap();
    if e1 != 'e' || e2 != 'e' || r != 'r' || a != 'a' || s != 's' {
        return false;
    }
    true
}

fn remove_eraser(v: &mut Vec<char>) -> bool {
    if v.len() < 6 {
        return false;
    }
    let r2 = v.pop().unwrap();
    let e2 = v.pop().unwrap();
    let s = v.pop().unwrap();
    let a = v.pop().unwrap();
    let r1 = v.pop().unwrap();
    let e1 = v.pop().unwrap();
    if e1 != 'e' || e2 != 'e' || r1 != 'r' || a != 'a' || s != 's' || r2 != 'r' {
        return false;
    }
    true
}

fn remove_dream(v: &mut Vec<char>) -> bool {
    if v.len() < 5 {
        return false;
    }
    let m = v.pop().unwrap();
    let a = v.pop().unwrap();
    let e = v.pop().unwrap();
    let r = v.pop().unwrap();
    let d = v.pop().unwrap();
    if d != 'd' || r != 'r' || e != 'e' || a != 'a' || m != 'm' {
        return false;
    }
    true
}
fn remove_dreamer(v: &mut Vec<char>) -> bool {
    if v.len() < 7 {
        return false;
    }
    let r2 = v.pop().unwrap();
    let e2 = v.pop().unwrap();
    let m = v.pop().unwrap();
    let a = v.pop().unwrap();
    let e1 = v.pop().unwrap();
    let r1 = v.pop().unwrap();
    let d = v.pop().unwrap();
    if d != 'd' || r1 != 'r' || e1 != 'e' || r2 != 'r' || e2 != 'e' || a != 'a' || m != 'm' {
        return false;
    }
    true
}

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

    while svec.len() > 4 {
        let l = svec.len();
        if svec[l - 1] == 'm' {
            if !remove_dream(&mut svec) {
                println!("NO");
                return;
            }
        } else if svec[l - 1] == 'e' {
            if !remove_erase(&mut svec) {
                println!("NO");
                return;
            }
        } else if svec[l - 1] == 'r' && svec[l - 3] == 'm' {
            if !remove_dreamer(&mut svec) {
                println!("NO");
                return;
            }
        } else if svec[l - 1] == 'r' && svec[l - 3] == 's' {
            if !remove_eraser(&mut svec) {
                println!("NO");
                return;
            }
        } else {
            println!("NO");
            return;
        }
    }

    if svec.is_empty() {
        println!("YES");
    } else {
        println!("NO");
    }
}
//  [rust]
use proconio::input;
use proconio::marker::Chars;

fn main() {
    input! {
        mut s: Chars,
    };
    s.reverse();
    loop {
        if s.len() == 0 {
            println!("Yes");
            return;
        }
        if s[0..5].iter().zip("maerd".chars()).all(|(x,y)| *x == y) {
            s.drain(0..5);
            continue;
        }
        if s[0..5].iter().zip("esare".chars()).all(|(x,y)| *x == y) {
            s.drain(0..5);
            continue;
        }
        if s[0..6].iter().zip("resare".chars()).all(|(x,y)| *x == y) {
            s.drain(0..6);
            continue;
        }
        if s[0..7].iter().zip("remaerd".chars()).all(|(x,y)| *x == y) {
            s.drain(0..7);
            continue;
        }
        break;
    }
    println!("No");
}
//  [rust]
use std::io::prelude::*;
use std::str::FromStr;
pub struct Scanner<R: Read>(R);
impl<R: Read> Scanner<R> {
    pub fn new(reader: R) -> Self {
        Self(reader)
    }
    pub fn read<T: FromStr>(&mut self) -> T {
        let token = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| (b as char).is_whitespace())
            .take_while(|&b| !(b as char).is_whitespace())
            .collect::<Vec<u8>>();
        unsafe { std::str::from_utf8_unchecked(token.as_slice()) }
            .parse()
            .ok()
            .expect("Can't parse it.")
    }
    pub fn vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
fn main() {
    let (stdin, stdout) = (std::io::stdin(), std::io::stdout());
    let mut sc = Scanner::new(stdin.lock());
    let mut out = std::io::BufWriter::new(stdout.lock());
    solve(&mut sc, &mut out);
    out.flush().ok().unwrap();
}
fn solve(sc: &mut Scanner<std::io::StdinLock>, out: &mut std::io::BufWriter<std::io::StdoutLock>) {
    let mut s: String = sc.read();

    let patterns = vec!["dream", "dreamer", "erase", "eraser"];
    'again: while s.len() > 0 {
        for &pat in &patterns {
            if s.ends_with(pat) {
                s.split_off(s.len() - pat.len());
                break 'again;
            }
        }
        println!("NO");
        return;
    }
    println!("YES");
}
//  [rust]
fn solve(s: String, acc: String) -> String {
    if s == acc {
        "YES".to_string()
    } else if s.starts_with(&format!("{}maerd", acc)) {
        solve(s, format!("{}maerd", acc))
    } else if s.starts_with(&format!("{}remaerd", acc)) {
        solve(s, format!("{}remaerd", acc))
    } else if s.starts_with(&format!("{}esare", acc)) {
        solve(s, format!("{}esare", acc))
    } else if s.starts_with(&format!("{}resare", acc)) {
        solve(s, format!("{}resare", acc))
    } else {
        "NO".to_string()
    }
}

fn main() {
    let s = read();

    println!("{}", solve(s.chars().rev().collect::<String>(), "".to_string()));
}

fn read() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().to_string()
}
//  [swift]
func main() {
    let S = Array(readLine()!)
    let n = S.count
    let A: Set = ["dream", "dreamer", "erase", "eraser"]
    
    var s = ""
    for i in 1...n {
        s.insert(S[n - i], at: s.startIndex)
        if s.count > 7 {
            print("NO")
            return
        }
        if A.contains(s) {
            s = ""
        }
    }
    
    if s.count == 0 {
        print("YES")
    } else {
        print("NO")
    }
}

main()
//  [swift]
func main() {
    let A = ["dream", "dreamer", "erase", "eraser"]
    var S = readLine()!
    
    while let a = A.first(where: { S.hasSuffix($0) }) {
        S.removeLast(a.count)
    }
    
    if S.count == 0 {
        print("YES")
    } else {
        print("NO")
    }
}

main()
//  [swift]
func main() {
    var line = readLine()!
    let words = ["dream", "dreamer", "erase", "eraser"]
    while true {
        let s = words.first(where: { (word) -> Bool in
            line.hasSuffix(word)
        })
        if let s = s {
            line.removeLast(s.count)
        } else {
            break
        }
    }
    if line.count == 0 {
        print("YES")
    } else {
        print("NO")
    }
}

main()
//  [swift]
import Foundation

let targets: [String] = ["eraser", "erase", "dreamer", "dream"]

func main() {
	var input = "readLine()!"
	for i in 0..<targets.count {
		if input == "" { break }
		input = input.replacingOccurrences(of: targets[i], with: "")
	}
	print(input.isEmpty ? "YES" : "NO")
}

main()
//  [swift]
let targets: [String] = ["eraser", "erase", "dreamer", "dream"]

func main() {
	var input = readLine()!
	for i in 0..<targets.count {
		if input == "" { break }
		input = input.replacingOccurrences(of: targets[i], with: "")
	}
	print(input.isEmpty ? "YES" : "NO")
}

main()
//  [swift]
import Foundation

func main() {
	var input = readLine()!
	for i in 0..<targets.count {
		if input == "" { break }
		input = input.replacingOccurrences(of: targets[i], with: "")
		print(input)
	}
	print(input.isEmpty ? "YES" : "NO")
}

main()
//  [typescript]
(function() {
    const str = require('fs').readFileSync('/dev/stdin', 'utf-8').trim().replace(/\n/g, '');
    // const str = 'dreameraser'
    let i = 0;
    while (i < str.length) {
        // console.log(str.slice(i, i+7));
        if(str.substring(i, i+11) == 'dreameraser') {
            i += 11;
        } else if (str.substring(i, i+10) == 'dreamerase') {
            i += 10;
        } else if(str.substring(i, i+7) == 'dreamer') {
            i += 7;
        } else if (str.substring(i, i+6) == 'eraser') {
            i += 6;
        } else if (str.substring(i, i+5) == 'erase' || str.substring(i, i+5) == 'dream') {
            i += 5;
        } else {
            console.log('NO');
            return
        }
    }
    console.log('YES');
})()
//  [typescript]
function Main(input) {
  input = input.split(" ");
  var S = input[0].replace("\n","");

  var Words = function(){
    this.Can = {"dream":5, "dreamer":7, "erase":5, "eraser":6};
    this.S = S;
    this.dp = Array(this.S.length);
    this.flag = true;
  }

  Words.prototype = {
    procedure: function(){
      this.dp[0]=1;
      for(var i = 1; i <= this.S.length; i++){
        this.flag = true;
        if(i >= 5){
          if(this.dp[i-5] == 1 && this.S.substr(i-5, 5) == "dream"){
            this.dp[i]=1;
            continue;
          }else if(this.dp[i-5] == 1 && this.S.substr(i-5, 5) == "erase"){
            this.dp[i]=1;
            continue;
          }else{
            this.flag = false;
          }
        }
        if(i >= 6){
          if(this.dp[i-6] == 1 && this.S.substr(i-6, 6) == "eraser"){
            this.dp[i]=1;
            continue;
          }else{
            this.flag = false;
          }
        }
        if(i >= 7){
          if(this.dp[i-7] == 1 && this.S.substr(i-7, 7) == "dreamer"){
            this.dp[i]=1;
            continue;
          }else{
            this.flag = false;
          }
        }
        if(i < 5){
          this.dp[i]=0;
        }
        if(this.flag == false) this.dp[i] =0;
      }
      if(this.dp[this.S.length] == 1){
        return "YES"
      }else{
        return "NO"
      }
    }
  }

var words = new Words();
console.log(words.procedure(""));
}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
const input = require("fs").readFileSync("/dev/stdin", "utf8").trim();
// var input = `dreamerer`;
input = input.split('').reverse().join('');
const STRINGS = ['dream', 'dreamer', 'erase', 'eraser'].map(s => s.split('').reverse().join(''));

while(1) {
    var canDivide = false;
    for (var i = 0; i < STRINGS.length; i++) {
        var s = STRINGS[i];
        var divide = input.substring(0, s.length);
        if (divide === s) {
            input = input.substring(s.length);
            canDivide = true;
            continue;
        }
    }
    if (!canDivide) {
        break;
    }
}

console.log(input === '' ? 'YES' : 'NO');
//  [typescript]
(function() {
    const str = require('fs').readFileSync('/dev/stdin', 'utf-8').trim().replace(/\n/g, '');
    // const str = 'dream'
    let i = 0;
    while (i < str.length) {
        if(str.substring(i, i+7) == 'dreamer') {
            i += 7;
        } else if (str.substring(i, i+6) == 'eraser') {
            i += 6;
        } else if (str.substring(i, i+5) == 'erase' || str.substring(i, i+5) == 'dream') {
            i += 5;
        } else {
            console.log('NO');
            return
        }
    }
    console.log('YES');
})()
//  [typescript]
(function() {
    const str = require('fs').readFileSync('/dev/stdin', 'utf-8').trim().replace(/\n/g, '');
    const i = 0;
    while (i < str.length) {
        if(str.substring(i, i+7) == 'dreamer') {
            i += 7;
        } else if (str.substring(i, i+6) == 'eraser') {
            i += 6;
        } else if (str.substring(i, i+5) == 'erase' || str.substring(i, i+5) == 'dream') {
            i += 5;
        } else {
            console.log('NO');
            return
        }
    }
    console.log('YES');
})()
//  [typescript]
(function() {
    const str = require('fs').readFileSync('/dev/stdin', 'utf-8').trim();
    const i = 0;
    while (i < str.length) {
        if(str.substring(i, i+7) == 'dreamer') {
            i += 7;
        } else if (str.substring(i, i+6) == 'eraser') {
            i += 6;
        } else if (str.substring(i, i+5) == 'erase' || str.substring(i, i+5) == 'dream') {
            i += 5;
        } else {
            console.log('NO');
            return
        }
    }
    console.log('YES');
})()
//  [python]
str = input()
str = str.split()

for i in range(3):
    str[i] = int(str[i])

a = float(str[0] / str[2])

if a <= str[1]:
    print("Yes")
    
else:
    print("No")
//  [python]
D,T,S =  map(int,input().split())
if D/S <= T:
  print("Yes")
else:
  print("No")
//  [python]
D, T, S = map(int, input().split())
if D / S <= T:
    print ("Yes")
else:
    print('No')
//  [python]
dist, time, speed = map(int, input().split())
print('Yes' if dist/speed < time else 'No')
//  [python]
D, T, S = map(int, input().split())

if (D / S) < T:
  print('Yes')
else:
  print('No')
//  [python]
d = int(input())
t = int(input())
s = int(input())
if(d <= t*s):
    print("Yes")
else:
    print("No")
//  [java]
import java.util.*;
import java.util.Scanner;
import java.io.*;
import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.util.Scanner; 
import java.util.StringTokenizer;

import javax.lang.model.util.ElementScanner6; 

public class Main
{
    static class FastReader
    { 
        BufferedReader br; 
        StringTokenizer st; 

        public FastReader() 
        { 
            br = new BufferedReader(new
                    InputStreamReader(System.in)); 
        } 

        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        } 

        int nextInt() 
        { 
            return Integer.parseInt(next()); 
        } 

        long nextLong() 
        { 
            return Long.parseLong(next()); 
        } 

        double nextDouble() 
        { 
            return Double.parseDouble(next()); 
        } 

        String nextLine() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    } 
    

    
    public static void main(String args[])
    {  
        FastReader in=new FastReader();
        int t=1;
        //t=in.nextInt();
        while(t-->0)
        {
           
            double d=in.nextDouble();
            double time=in.nextDouble();
            double s=in.nextDouble();
            
            if(d/time<=s)
            {
                System.out.println("Yes");
            }
            else
                System.out.println("No");
           
        }
    }
}
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[]args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String a = br.readLine();
		String[] b = a.split(" ");
		long S = 0 ; 
		long D = 0 ;
		long T = 0 ;
		for(int i  = 0 ; i < b.length ; i++) {
			if(i == 0 )
				D = Long.parseLong(b[i]);
			if(i == 1 )
				T = Long.parseLong(b[i]);
			if(i == 2 )
				S = Long.parseLong(b[i]);
			
		}
		double result = D/S ;
		if(result <= T) 
			System.out.println("Yes");
		else
			System.out.println("No");

		
		
	}

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

public class Main {
	public static void main(String[]args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String a = br.readLine();
		String[] b = a.split(" ");
		long S = 0 ; 
		long D = 0 ;
		long T = 0 ;
		for(int i  = 0 ; i < b.length ; i++) {
			if(i == 0 )
				D = Long.parseLong(b[i]);
			if(i == 1 )
				T = Long.parseLong(b[i]);
			if(i == 2 )
				S = Long.parseLong(b[i]);
			
		}
		long result = D/S ;
		if(result <= T) 
			System.out.println("Yes");
		else
			System.out.println("No");

		
		
	}

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

public class answer {
	public static void main(String[]args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String a = br.readLine();
		String[] b = a.split(" ");
		long S = 0 ; 
		long D = 0 ;
		long T = 0 ;
		for(int i  = 0 ; i < b.length ; i++) {
			if(i == 0 )
				D = Long.parseLong(b[i]);
			if(i == 1 )
				T = Long.parseLong(b[i]);
			if(i == 2 )
				S = Long.parseLong(b[i]);
			
		}
		long result = D/S ;
		if(result <= T) 
			System.out.println("Yes");
		else
			System.out.println("No");

		
		
	}

}
//  [cpp]
#include<stdio.h>
int main(void)
{
  int D,T,S;
  if(!scanf("%d %d %d",&D,&T,&S))return -1;
  return puts(D<=T*S?"Yes":"No"),0;
}
//  [cpp]
#include <cstdio>

int main(){
    int d, t, s; scanf("%d%d%d", &d, &t, &s);
    if (d <= t*s) puts("Yes");
    else puts("No");

    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define reps(i,n) for(int i=1;i<(int)(n);i++)

typedef long long ll;
using namespace std;
int main()
{

  ll d,t,s;
  cin>>d>>t>>s;
  if(s*t>=d){
    cout<<"Yes"<<endl;
  }else{
    cout<<"No"<<endl;
  }
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
#include<string.h>
using namespace std;
int main()
{
    int x,y,z;
    cin>>x>>y>>z;
    (double(x/z)<=y)?cout<<"Yes":cout<<"No";
}
//  [cpp]
#include<bits/stdc++.h>
#include<string.h>
using namespace std;
int main()
{
    int x,y,z;
    cin>>x>>y>>z;
    (x/z<=y)?cout<<"Yes":cout<<"No";
}
//  [cpp]
#include<bits/stdc++.h>
#include<string.h>
using namespace std;
int main()
{
    int x;
    cin>>x;
    if(x==1){cout<<0;}
    else{cout<<1;}
}
//  [c]
#include <stdio.h>

int main(void){
    int d, t , s;
    scanf("%d %d %d", &d, &t, &s);

    if((t*s) < d){
        printf("No");
    } else {
        printf("Yes");
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main()
{
    int a, b, c;
    float d;

    scanf("%d %d %d", &a, &b, &c);

    d= (float)a/b;

    if (d <= c)
        printf("Yes\n");
    else
        printf("No\n");

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

int main (void)
{
	int d,t,s;
	double a;
	
	scanf("%d %d %d",&d,&t,&s);
	
	a=(double)d/(double)s;
	
	if(t>=a){
		printf("Yes");
		return 0;
	}
	printf("No");
	return 0;
}
//  [c]
#include<stdio.h>
int main() {
	int D, T, S;
	scanf("%f %f %f", &D, &T, &S);
	if ((D / S) <= T)
		printf("Yes\n");
	else
		printf("No\n");

	return 0;
}
//  [c]
#include<stdio.h>
int main() {
	int D, T, S;
	scanf("%d %d %d", &D, &T, &S);
	if ((float)((D / S) <= T))
		printf("Yes\n");
	else
		printf("No\n");

	return 0;
}
//  [c]
#include<stdio.h>
int main() {
	int D, T, S;
	scanf_s("%d %d %d", &D, &T, &S);
	if ((D / S) <= T)
		printf("Yes\n");
	else
		printf("No\n");

	return 0;
}
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const D = parseInt(arg[0].split(" ")[0]);
    const T = parseInt(arg[0].split(" ")[1]);
    const S = parseInt(arg[0].split(" ")[2]);

    console.log(D / S <= T ? "Yes" : "No");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
((input) => {
  const [D, T, S] = input.split(' ').map(Number);
  const str = D / S <= T ? 'Yes' : 'No';
  console.log(str);
})(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	input = input.trim().split("\n").map(function(x) { return x.split(" ")});
	let D = parseInt(input[0][0], 10);
	let T = parseInt(input[0][1], 10);
	let S = parseInt(input[0][2], 10);
	if (D / S <= T) console.log('Yes');
	else console.log('No');


}

Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const SieveOfEratosthenes = (n) => {
    let flg = (new Array(n)).fill(0)/* set flg[i] to true when it is seived */
    let primes = []/* list of prime numbers */
    for(let i=2; i*i<=n; i++) {
        if(!flg[i]) {
            primes.push(i)
            for(let j=i; j*j<=n; j+=i) {
                flg[j] = 1
            }
        }
    }
    return primes
}

const factorizationBySoE = (n, primes) => {
    //const primes = SieveOfEratosthenes(n)
    let factors = {}
    primes.some(p => {
        if(n < p) return true
        while(n%p===0) {
            if(!factors[p])factors[p]=1
            else factors[p]++
            n/=p
        }
    })
    if(n>1)factors[n]=1
    return factors
}


const getGCD = (a,b) => {
    if(b===0)return a
    else if(a===0)return b
    return getGCD(b, a%b)
}

const main = (arg) => {
    const N = Number(arg.split("\n")[0])
    const a = arg.split("\n")[1].split(" ").map(Number)
    
    const MAX_A = 10**6+1
    
    //  check if p is in {a} (paircoprime)
    const primes = SieveOfEratosthenes(A)
//    return
    let set = [...new Array(MAX_A)].fill(0)
    isPairCoprime = true
    for(let i=0; i<N; i++) {
        const factors = Object.keys(factorizationBySoE(a[i], primes))
        for(let j=0; j<factors.length; j++ ) {
            // console.log(`i=${i}, j=${j}, ${factors[j]}`)
            // console.log(factors)
            if(set[factors[j]] === 1) {
                isPairCoprime = false
            }
            set[factors[j]] = 1
        }
    }
/*
    for(let i=0; i<N; i++) {
        set[a[i]]++
    }
//  return
    for(let i=2; i<MAX_A; i++) {
         let cnt=0
         for(let j=i; j<MAX_A; j+=i) {
             cnt+=set[j]
         }
        if(cnt>1) {
             isPairCoprime = false
         }
     }
 */
    if(isPairCoprime) {
        console.log("pairwise coprime")
        return
    }
     // return
    // setcoprime
    // let gcd = getGCD(a[0], a[1])
    let gcd = 0
    for(let i=0; i<a.length; i++) {
        gcd = getGCD(gcd, a[i])
        // console.log(gcd)
    }
    
    if(gcd===1) {
        console.log("setwise coprime")
        return
    }
    
    console.log("not coprime")
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const [d, t, s] = input.trim().split(' ').map(x => parseInt(x))
  if (s*t <= d) {
    console.log('Yes')
  } else {
    console.log('No')
  }
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  const [d, t, s] = input.split(' ').map(x => parseInt(x))
  if (s*t <= d) {
    console.log('Yes')
  } else {
    console.log('No')
  }
}

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

import "fmt"

func main() {
	var d, t, s int
	fmt.Scan(&d, &t, &s)
	if d <= t*s {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var D, T, S float64
	fmt.Scan(&D, &T, &S)

  var time = (D / S)

  if T >= time {
    fmt.Println("Yes")
  }else{
    fmt.Println("No")
  }
}
//  [go]
package main

import "fmt"

func main() {
	var D, T, S int
	fmt.Scan(&D, &T, &S)

  var dis = (T * S)

  if dis >= D {
    fmt.Println("Yes")
  }else{
    fmt.Println("No")
  }
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var D, T, S int

	fmt.Scan(&D, &T, &S)

	if D/S <= T {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var d, s, t int
	fmt.Scan(&d, &s, &t)

	if s >= (d / t) {
		fmt.Printf("Yes")
	} else {
		fmt.Printf("No")
	}
}
//  [go]
package main

import (
  "fmt"
)

func main(){
  var D int
  var T int
  var S int

  fmt.Scan(&D)
  fmt.Scan(&T)
  fmt.Scan(&S)

  if T>=D/S {
    fmt.Println("Yes")
  }else{
    fmt.Println("No")
  }


}
//  [ruby]
D, T, S = gets.split(' ').map(&:to_i)
 if S*T >= D
   puts 'Yes'
 else
   puts 'No'
 end
//  [ruby]
d,t,s=gets.split.map(&:to_i)
puts d > t*s ? :No : :Yes
//  [ruby]
d, t, s = gets.strip.split.map(&:to_i)
if d <= t * s
  puts "Yes"
else
  puts "No"
end
//  [ruby]
n = $stdin.readline.to_i
a = $stdin.readline.chomp.split.map(&:to_i)
m = 10 ** 6
d = Array.new(m + 1)

2.step(m) do |i|
  next if !d[i].nil?
  
  d[i] = i
  (m / i).times do |j|
    k = (j + 1) * i
    next if !d[k].nil?
    d[k] = i
  end
end

g = a[0]
pc = true
h = Hash.new(true)
n.times do |i|
  g = g.gcd(a[i])
  x = a[i]
  q = []
  while pc && x > 1
    if h[d[x]] > 0
      pc = false
      break
    end

    q << d[x]
    x /= d[x]
  end

  q.uniq.each do |y|
    h[y] = true
  end
end

if pc
  puts "pairwise coprime"
elsif g == 1
  puts "setwise coprime"
else
  puts "not coprime"
end
//  [ruby]
d,t,s = gets.split(" ").map(&:to_i)

if d >= t * s
  puts "No"
else 
  puts "Yes"
end
//  [ruby]
a,b,c=gets.split.map &:to_i
p a>b*c ? :No : :Yes
//  [rust]
use proconio::input;

fn solve() {
    input! {
        d:i32,t:i32,s:i32
    }
    println!("{}", if (t * s >= d) { "Yes" } else { "No" });
}

fn main() {
    solve();
}
//  [rust]
#[allow(unused_imports)]
use itertools::Itertools;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;

fn main() {
    input! {
        d: i64, t: i64, s: i64,
    }

    if d > t * s {
        println!("No");
    } else {
        println!("Yes");
    }
    // println!("{}", );
}
//  [rust]

use proconio::{ input, fastout };

#[fastout]
fn main() {
    input! {
        d: usize,
        t: usize,
        s: usize,
    };
    if d <= t * s {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
use proconio::input;
fn main (){
let mut D: i128;
let mut T: i128;
let mut S: i128;

input! {
    D: i128,
    T: i128,
    S: i128,
}
 if D/S <= T {
     println!("Yes");
 }else{
     println!("No");
 }
}
//  [rust]
use proconio::input;
use proconio::marker::{Bytes, Chars};

// x ** n % mods を求める
pub fn mod_pow(x: i64, n: i64, mods: i64) -> i64 {
    if n == 0 {
        return 1;
    }
    let mut res = mod_pow(x * x % mods, n / 2, mods);
    if n % 2 == 1 {
        res = res * x % mods;
    }
    return res;
}

// (1/n) % mods を求める
pub fn mod_inv(n: i64, mods: i64) -> i64 {
    return mod_pow(n, mods-2, mods);
}

// nCk % mods を求める
pub fn mod_comb(n: i64, k: i64, mods: i64) -> i64 {
    let sum1 = (n-k+1..n+1).fold(1, |ac, x| ac * x % mods);
    let sum2 = (1..k+1).fold(1, |ac, x| ac * x % mods);
    return sum1 * mod_inv(sum2, mods) % mods;
}

// nCk の組み合わせを列挙する
pub fn combination(n: usize, k: usize) -> Vec<Vec<usize>> {
    let mut ans = Vec::new();
    if k == 1 {
        for i in 1..n+1 {
            let mut tmp = Vec::new();
            tmp.push(i);
            ans.push(tmp);
        }
    }
    else {
        for iter in combination(n-1, k-1) {
            let max = iter.iter().max().unwrap();
            for j in *max+1..n+1 {
                let mut tmp = iter.clone();
                tmp.push(j);
                ans.push(tmp);
            }
        }
    }
    ans
}


fn main() {
    input!{
        d: usize,
        t: usize,
        s: usize,
    }
    if d / s <= t {
        println!("Yes");
    }
    else {
        println!("No");
    }
}
//  [swift]
func main(input: String = readLine()!) {
    let integers = input.split(separator: " ").map { Int($0)! }
    let d = integers[0]
    let t = integers[1]
    let s = integers[2]
    print(t * s >= d ? "Yes" : "No")
}

main()
//  [swift]
let dts = readLine()!.split(separator: " ").map{Int($0)!}
let (d, t, s) = (dts[0], dts[1], dts[2])
let canMeetInTime = s * t >= d
print(canMeetInTime ? "Yes" : "No")
//  [swift]

func readThreeInts(separator: String.Element = " ") -> (a: Int, b: Int, c: Int) {
    let ints = readLine()!.split(separator: separator).map { Int($0)! }
    return (a: ints[0], b: ints[1], c: ints[2])
}

func mainA() {
    let (D, T, S) = readThreeInts()

    print(D <= T * S ? "Yes" : "No")
}
mainA()
//  [swift]
import Foundation

let args = readLine()!.components(separatedBy: " ")
let D = Double(args[0])!
let T = Double(args[1])!
let S = Double(args[2])!
if (D / S < T) {
  print("Yes")
} else {
  print("No")
}
//  [swift]
import Foundation
 
var D = Int(readLine()!)!
var T = Int(readLine()!)!
var S = Int(readLine()!)!

if (D/S <= T){
    print("Yes")
}else{
    print("No")
}
//  [swift]
let dts = readLine()!.split(separator: " ").compactMap { Int($0) }
print(dts[0] / dts[2] <= dts[1] ? "Yes" : "No")
//  [typescript]
import * as fs from 'fs';


const [d, t, s]: number[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);
console.log((d / s <= t) ? 'Yes' : 'No');
//  [typescript]
var main = (input: string) => {
    let a: string[] = input.split(" ");
    let d: number = parseInt(a[0]);
    let t: number = parseInt(a[1]);
    let s: number = parseInt(a[2]);

    if (t * s >= d) {
        console.log("Yes");
    } else {
        console.log("No");
    }
}

main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
var main = function (input: string) {
    let a: string[] = input.split(" ");
    let d: number = parseInt(a[0]);
    let t: number = parseInt(a[1]);
    let s: number = parseInt(a[2]);

    if (t * s >= d) {
        console.log("Yes");
    } else {
        console.log("No");
    }
}

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


const [d, t, s]: number[] = fs.readFileSync('/dev/stdin', 'utf8').trim().split(' ').map(Number);
console.log((d / s < t) ? 'Yes' : 'No');
//  [typescript]
import * as fs from 'fs';

var g_root: number[];
var g_count: number[];

function main(input: string[]) {
	var work0: number[] = input.shift().split(" ").map(x => Number(x));
	var n: number = work0[0];
	var m: number = work0[1];
	var node: number[][] = input.map(x => x.split(" ").map(x => Number(x) - 1));
	g_root = new Array(n).fill(-1);
	g_count = new Array(n).fill(1);
  /*
	node.forEach(value => {
		var a: number = value[0];
		var b: number = value[1];
		var roota: number = getRoot(a);
		var rootb: number = getRoot(b);
		if (roota == rootb) return;
		if (roota > rootb) [roota, rootb] = [rootb, roota];
		mergeRoot(roota, rootb);
	});
    */
	console.log(Math.max(...g_count));
}

function getRoot(index: number) {
	if (g_root[index] < 0) {
		return index;
	} else {
		var work0: number = getRoot(g_root[index]);
		g_root[index] = work0;
		return work0
	}
}

function mergeRoot(root0: number, root1: number) {
	g_count[root0] += g_count[root1];
	g_count[root1] = 0;
	g_root[root1] = root0;
}

const input = fs.readFileSync("/dev/stdin", "utf8").trim().split("\n");
main(input);
//  [typescript]
import * as fs from 'fs';

const input = fs.readFileSync("/dev/stdin", "utf8").split(" ");
const d = +input[0];
const t = +input[1];
const s = +input[2];

const a = s * t;

if (a < d) {
    console.log("Yes");
} else {
    console.log("No");
}
//  [python]
s = list(input())
s.sort()
if s == ["a", "b", "c"]:
    print("Yes")
else:
    print("No")
//  [python]
s = input()
if s.count('a') == 1 and s.count('b') == 1 and s.count('c') == 1:
  print('Yes')
else:
  print('No')
//  [python]
S = list(input())
if 'a' in S and 'b' in S and 'c' in S:
    print("Yes")
else:
    print("No")
//  [python]

S = str(input())

if S[0] != S[1] and S[1] != S[2] and S[2] != S[0]:
    print('Yes')
    
else:
    print('Bad')
//  [python]
s = input()

if s[0] != s[1] and s[0] != s[2]:
    print('Yes')
else:
    print('No')
//  [python]
s = str(input())

if s[0] != s[1] and s[0] != s[2]:
    print('Yes')
else:
    print('No')
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Main{

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter wr = new PrintWriter(System.out);
        String str = br.readLine().trim();
        
        if(str.contains("a")&&str.contains("b")&&str.contains("c"))System.out.println("Yes");
        else System.out.println("No");

	}

}
//  [java]
import java.io.*;

public class Main {
   public static void main(String[] args) {
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
      try {
         String line = reader.readLine();
         int count = 0;
         for (int i = 0; i < 3; i++) {
            char a = line.charAt(i);
            if (a == 'a') {
               count ++;
            }
         }
         if (count == 1) {
            count = 0;
            for (int j = 0; j < 3; j++) {
            char b = line.charAt(j);
               if (b == 'b') {
                  count ++;
               }
            }
            if (count == 1) {
               count = 0;
               for (int s = 0; s < 3; s++) {
               char c = line.charAt(s);
                  if (c == 'c') {
                     count ++;
                  }
               }
               if (count == 1){
                     System.out.println("Yes");
               }
               else {
                  System.out.println("No");
               }
            }
            else {
               System.out.println("No");
            }
         }
         else {
            System.out.println("No");
         }  
      } catch (IOException e) {
         System.out.println(e);
      }
   }
}
//  [java]
import java.util.*;
// warm-up
// Think i should stop doing Atcoder
public class Main {

	static void solve() {
		Scanner sc = new Scanner(System.in);
		String s = "abc", t = sc.next();
		System.out.println(s.indexOf(t.charAt(0))==-1||s.indexOf(t.charAt(1))==-1||s.indexOf(t.charAt(2))==-1 ? "No" : "Yes");
		sc.close();		
	}

	public static void main(String args[]) {
		solve();
	}

}