#include <cstdio>
#include <cstring>

bool dp[100000 + 10];
char s[100000 + 10];

int main()
{
	scanf("%s", s);
	dp[0] = true;

	for (int i = 0; i < strlen(s); ++i)
	{
		if (dp[i] == false) continue;

		if (memcmp(s + i, "dream", 5) == 0)
		{
			dp[i + 5] = true;
			if (s[i + 5] == 'e' && s[i + 6] == 'r')
			{
				dp[i + 7] = true;
			}
		}
		else if (memcmp(s + i, "erase", 5) == 0)
		{
			dp[i + 5] = true;
			if (s[i + 5] == 'r')
			{
				dp[i + 6] = true;
			}
		}
	}

	printf(dp[strlen(s)] ? "YES\n" : "NO\n");

	return 0;
}


#include<cstdio>
#include<cstring>
char s[100001];
int main()
{
	scanf("%s",s+1);
	int r=strlen(s+1);
	while(r>=1){
		if(s[r]=='r'&&s[r-1]=='e'&&s[r-2]=='m'&&s[r-3]=='a'&&s[r-4]=='e'&&s[r-5]=='r'&&s[r-6]=='d'){
			r-=7;
		}else if(s[r]=='m'&&s[r-1]=='a'&&s[r-2]=='e'&&s[r-3]=='r'&&s[r-4]=='d'){
			r-=5;
		}else if(s[r]=='e'&&s[r-1]=='s'&&s[r-2]=='a'&&s[r-3]=='r'&&s[r-4]=='e'){
			r-=5;
		}else if(s[r]=='r'&&s[r-1]=='e'&&s[r-2]=='s'&&s[r-3]=='a'&&s[r-4]=='r'&&s[r-5]=='e'){
			r-=6;
		}else{
			break;
		}
	}
	printf("%s\n",r<=0?"YES":"NO");
	return 0;
}


#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

vector<string>A = { "dream", "dreamer", "erase", "eraser" };

int main() {
    string s;
    cin >> s;

    reverse(s.begin(), s.end());

    for (int i = 0; i < 4; i++) {
        reverse(A.at(i).begin(), A.at(i).end());

    }

    bool result = true;

    for (int i = 0; i < s.size(); i++) {
        bool divide = false;
        for (int j = 0; j < 4; j++) {
            string X = A.at(j);
            if (s.substr(i, X.size()) == X) {
                divide = true;
                i += X.size();
            }

        }
        if (divide == false) {
            result = false;
            break;

        }
    }

    if (result == true) {
        cout << "YES" << endl;
    }
    else {
        cout << "NO" << endl;
    }

}


#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

vector<string>A = { "dream", "dreamer", "erase", "eraser" };

int main() {
    string s;
    cin >> s;

    reverse(s.begin(), s.end());

    for (int i = 0; i < 4; i++) {
        reverse(A.at(i).begin(), A.at(i).end());

    }

    bool result = true;

    for (int i = 0; i < s.size(); i++) {
        bool divide = false;
        for (int j = 0; j < 4; j++) {
            string X = A.at(j);
            if (s.substr(i, X.size()) == X) {
                divide = true;
                i += X.size();
            }

        }
        if (divide == false) {
            result = false;
            break;

        }
    }

    if (result == true) {
        cout << "Yes" << endl;
    }
    else {
        cout << "No" << endl;
    }

}


#include <bits/stdc++.h>
#define M_PI           3.14159265358979323846  /* pi */
using namespace std;
using  ll = long long;

int main() {
	string s;
	cin >> s;

	reverse(s.begin(), s.end());
	vector<string>A = { "dream", "dreamer", "erase", "eraser" };

	for (int i = 0; i < 4; i++) reverse(A.at(i).begin(), A.at(i).end());

	bool result = true;

	for (int i = 0; i < s.size(); i++) {
		bool divide = false;
		for (int j = 0; j < 4; j++) {
			string X = A.at(i);
			if (s.substr(i, X.size()) == X) {
				divide = true;
				i += X.size();
			}

		}
		if (divide == false) {
			result = false;
			break;
		}
	}

	if (result == true) {
		cout << "Yes" << endl;
	}
	else {
		cout << "No" << endl;
	}

}


#include <stdio.h>
#include <string.h>
int main(){
  char s[100001];
  int f=0;
  scanf("%s",&s);
  for(int i=strlen(s)-1;i>0;i--){
    if(s[i]=='m'){//dream
      if(s[i--]=='m'&&s[i--]=='a'&&s[i--]=='e'&&s[i--]=='r'&&s[i]=='d')f=1;
      else f=0;
     }
    else if(s[i]=='e'){//erase
      if(s[i--]=='e'&&s[i--]=='s'&&s[i--]=='a'&&s[i--]=='r'&&s[i]=='e')f=1;
      else f=0;
     }
    else if(s[i]=='r'&&s[i-5]=='e'){//eraser
      if(s[i--]=='r'&&s[i--]=='e'&&s[i--]=='s'&&s[i--]=='a'&&s[i--]=='r'&&s[i]=='e') f=1;
      else f=0;
      }
    else if(s[i]=='r'&&s[i-6]=='d'){//dreamer
      if(s[i--]=='r'&&s[i--]=='e'&&s[i--]=='m'&&s[i--]=='a'&&s[i--]=='e'&&s[i--]=='r'&&s[i]=='d') f=1;
      else f=0;
      }
    if(f==0) break;
  }
 if(f==1) printf("YES\n");
 else printf("NO\n");
 return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

typedef long long ll;

int main(){
  char key1[6] = "maerd";
  char key2[8] = "remaerd";
  char key3[6] = "esare";
  char key4[7] = "resare";
  char s[100007];
  int n,i,j,flag;
  char t;

  scanf("%s", s);

  n = strlen(s);
  for(i = 0,j = n - 1;i < n/2;i++,j--){
    t = s[i]; s[i] = s[j]; s[j] = t;
  }

  i = 0; flag = 0;
  while(s[i] != '\0'){
    if(s[i] == 'm'){
      if(strncmp(s + i,key1,5) != 0){
        flag = 1;
        break;
      }

      else i = i + 5;
    }

    else if(s[i] == 'e'){
      if(strncmp(s + i,key3,5) != 0){
        flag = 1;
        break;
      }

      else i = i + 5;
    }

    else if(s[i] == 'r'){
      if(s[i + 2] == 'm'){
        if(strncmp(s + i,key2,7) != 0){
          flag = 1;
          break;
        }

        else i = i + 7;
      }

      else if(s[i + 2] == 's'){
        if(strncmp(s + i,key4,6) != 0){
          flag = 1;
          break;
        }

        else i = i + 6;
      }

      else{
        flag = 1;
        break;
      }
    }

    else{
      flag = 1;
      break;
    }
  }

  if(flag) printf("NO\n");

  else printf("YES\n");

  return 0;
}


#include <stdbool.h>
#include <stdio.h>
#include <string.h>
int main() {
	char s[100001], tmp;
	char dream[6] = "maerd";
	char dreamer[8] = "remaerd";
	char erase[6] = "esare";
	char eraser[7] = "resare";
	bool isDream, isDreamer, isErase, isEraser;
	scanf("%s", s);
	int len = strlen(s);
	for (int i = 0; i < len / 2; i++) {
		tmp = s[i];
		s[i] = s[len - i - 1];
		s[len - i - 1] = tmp;
	}
	for (int i = 0; i < len;) {
		isDream = isDreamer = isErase = isEraser = true;
		for (int j = 0; j < 5; j++) {
			if (s[i + j] != dream[j]) {
				isDream = false;
				break;
			}
		}
		for (int j = 0; j < 7; j++) {
			if (s[i + j] != dreamer[j]) {
				isDreamer = false;
				break;
			}
		}
		for (int j = 0; j < 5; j++) {
			if (s[i + j] != erase[j]) {
				isErase = false;
				break;
			}
		}
		for (int j = 0; j < 6; j++) {
			if (s[i + j] != eraser[j]) {
				isEraser = false;
				break;
			}
		}
		if (isDream || isErase) {
			i += 5;
		} else if (isEraser) {
			i += 6;
		} else if (isDreamer) {
			i += 7;
		} else {
			printf("NO\n");
			return 0;
		}
	}
	printf("YES\n");
	return 0;
}


#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==-1){
      printf("YES\n");
    }else{
      printf("NO\n");
    }

  return 0;
}


#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;
}


#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;
}


// 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"));


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");
}


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")
    }
}


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"));


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"));


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"));


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")
}


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)
}


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")
}


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)
	}
}


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)
	}
}


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)
	}
}


s = gets.chomp
puts s =~ /\A(dream|dreamer|erase|eraser)*\Z/ ? 'YES' : 'NO'


s = gets.chomp
print s =~ /\A(dream|dreamer|erase|eraser)*\z/ ? 'YES' : 'NO'


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


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


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'


#[allow(unused_imports)]
use std::char::from_digit;
#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::fs::File;
#[allow(unused_imports)]
use std::io::prelude::*;
#[allow(unused_imports)]
use std::io::{stdin, stdout, BufReader, BufWriter, Stdin, Stdout, Write};
#[allow(unused_imports)]
use std::mem::swap;
#[allow(unused_imports)]
use std::str::FromStr;

type BoxResult<T> = Result<T, Box<std::error::Error>>;

fn main() {
    let mut scanner = Scanner::new(stdin());
    let s = scanner.read_chars().unwrap();
    let words: Vec<Vec<_>> = vec!["dream".chars().collect(), "dreamer".chars().collect(), "erase".chars().collect(), "eraser".chars().collect()];
    let mut index = s.len() - 1;
    while index > 0 {
        let mut updated = false;
        for word in words.iter() {
            if index < word.len() - 1 {
                continue;
            }
            let offset = index + 1 - word.len();
            let mut matched = true;
            for i in 0..word.len() {
                if s[offset + i] != word[i] {
                    matched = false;
                    break;
                }
            }
            if matched {
                index = max(offset, 1) - 1;
                updated = true;
                break;
            }
        }
        if !updated {
            println!("NO");
            return;
        }
    }
    println!("YES");
}

#[allow(dead_code)]
struct Scanner<R> {
    reader: BufReader<R>,
    buffer: String,
}
impl<R> Scanner<R>
where
    R: Read,
{
    #[allow(dead_code)]
    fn new(inner: R) -> Scanner<R> {
        let reader = BufReader::new(inner);
        let buffer = String::new();
        Scanner {
            reader: reader,
            buffer: buffer,
        }
    }
    #[allow(dead_code)]
    fn with_capacity(capacity: usize, inner: R) -> Scanner<R> {
        let reader = BufReader::with_capacity(capacity, inner);
        let buffer = String::new();
        Scanner {
            reader: reader,
            buffer: buffer,
        }
    }
    #[allow(dead_code)]
    fn read_line(&mut self) -> BoxResult<String> {
        self.reader.read_line(&mut self.buffer)?;
        let cloned = self.buffer.trim().to_string();
        self.buffer.clear();
        Ok(cloned)
    }
    #[allow(dead_code)]
    fn read<T>(&mut self) -> BoxResult<T>
    where
        T: FromStr,
        T::Err: std::fmt::Debug,
        T::Err: std::error::Error,
        T::Err: 'static,
    {
        self.reader.read_line(&mut self.buffer)?;
        let parsed = self.buffer.trim().parse()?;
        self.buffer.clear();
        Ok(parsed)
    }
    #[allow(dead_code)]
    fn read_two<T, U>(&mut self) -> BoxResult<(T, U)>
    where
        T: FromStr,
        T: Copy,
        T::Err: std::fmt::Debug,
        T::Err: std::error::Error,
        T::Err: 'static,
        U: FromStr,
        U: Copy,
        U::Err: std::fmt::Debug,
        U::Err: std::error::Error,
        U::Err: 'static,
    {
        self.reader.read_line(&mut self.buffer)?;
        let (a, b) = {
            let params = self.buffer.trim().split_whitespace().collect::<Vec<_>>();
            let a = params[0].parse()?;
            let b = params[1].parse()?;
            (a, b)
        };
        self.buffer.clear();
        Ok((a, b))
    }
    #[allow(dead_code)]
    fn read_three<T>(&mut self) -> BoxResult<(T, T, T)>
    where
        T: FromStr,
        T: Copy,
        T::Err: std::fmt::Debug,
        T::Err: std::error::Error,
        T::Err: 'static,
    {
        let nums = self.read_vector()?;
        Ok((nums[0], nums[1], nums[2]))
    }
    #[allow(dead_code)]
    fn read_vector<T>(&mut self) -> BoxResult<Vec<T>>
    where
        T: FromStr,
        T::Err: std::fmt::Debug,
        T::Err: std::error::Error,
        T::Err: 'static,
    {
        self.reader.read_line(&mut self.buffer)?;
        let parsed_vec = self
            .buffer
            .trim()
            .split_whitespace()
            .map(|s| s.parse())
            .collect::<Result<Vec<_>, _>>()?;
        self.buffer.clear();
        Ok(parsed_vec)
    }
    #[allow(dead_code)]
    fn read_matrix<T>(&mut self, lines: usize) -> BoxResult<Vec<Vec<T>>>
    where
        T: FromStr,
        T::Err: std::fmt::Debug,
        T::Err: std::error::Error,
        T::Err: 'static,
    {
        let mut parsed_matrix = vec![];
        for _ in 0..lines {
            self.reader.read_line(&mut self.buffer)?;
            parsed_matrix.push(
                self.buffer
                    .trim()
                    .split_whitespace()
                    .map(|s| s.parse())
                    .collect::<Result<Vec<_>, _>>()?,
            );
            self.buffer.clear();
        }
        Ok(parsed_matrix)
    }
    #[allow(dead_code)]
    fn read_chars(&mut self) -> BoxResult<Vec<char>> {
        self.reader.read_line(&mut self.buffer)?;
        let chars = self.buffer.trim().chars().collect::<Vec<_>>();
        self.buffer.clear();
        Ok(chars)
    }
}


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;}
        }
    }
}


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");
    }
}


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");
}


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");
}


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()
}


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()


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()


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()


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()


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()


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()


(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');
})()


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"));


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');


(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');
})()


(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');
})()


(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');
})()


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")


D,T,S =  map(int,input().split())
if D/S <= T:
  print("Yes")
else:
  print("No")


D, T, S = map(int, input().split())
if D / S <= T:
    print ("Yes")
else:
    print('No')


dist, time, speed = map(int, input().split())
print('Yes' if dist/speed < time else 'No')


D, T, S = map(int, input().split())

if (D / S) < T:
  print('Yes')
else:
  print('No')


d = int(input())
t = int(input())
s = int(input())
if(d <= t*s):
    print("Yes")
else:
    print("No")


import java.io.*;
import java.util.*;

public class Main{
    final static String alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toLowerCase();//.toCharArray();
    static class FastReader{
        BufferedReader br,br1;
        StringTokenizer st;
        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
        public FastReader(String fileName) throws FileNotFoundException{br = new BufferedReader(new FileReader(fileName));}
        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());}
        char[][] readCharArray(int n,int m) {
        	String str;
        	char[][] arr = new char[n][m];
        	for(int i=0;i<n;i++) {
        		str=nextLine();
        		for(int j=0;j<n;j++) {
        			arr[i][j]=str.charAt(j);
        		}
        	}
        	return arr;
        }
        char[][] readCharArray(int n){
        	return readCharArray(n,n);
        }
        int[] readArray(int n){int[] a=new int[n];for (int i=0; i<n; i++) a[i]=nextInt();return a;}
        long[] readLongArray(int n){long[] a=new long[n];for (int i=0; i<n; i++) a[i]=nextLong();return a;}
        String nextLine(){String str = "";try{str = br.readLine();}catch (IOException e){e.printStackTrace();}return str;}
    }
    static int getGcd(int n1,int n2){
        while(n1 != n2){
            if(n1 > n2) n1 -= n2;
            else n2 -= n1;
        }
        return n1;
    }
    static boolean isSorted(int[] arr, int n){
        for(int i=1;i<n;i++){
            if(arr[i]<arr[i-1]) return false;
        }
        return true;
    }
    static boolean isPrime(long n){
        if(n==2) return true;
        else if(n%2==0) return false;
        for(int i=3;i<=n/2;i+=2){
            if(n%i==0) return false;
        }
        return true;
    }
    static boolean isPrime(int n){
        if(n==2) return true;
        else if(n%2==0) return false;
        for(int i=3;i<=n/2;i+=2){
            if(n%i==0) return false;
        }
        return true;
    }
    static void printArray(int[] arr){
        for(int x:arr){
            System.out.print(x+" ");
        }
        System.out.println();
    }
    static long Fact(int n){
        //int p=1000000007;
        long result = 1;
        for (int i = 1; i <= n; i++) result = (result*i);
        //for (int i = 1; i <= n; i++) result = (result*i)%p;
        return result;
    }
    static final Random random=new Random();
    static void ruffleSort(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n), temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }
    static int maxDigit(int n) {
    	int ret=n%10;
    	while(n/10!=0) {
    		ret = Math.max(ret, n%10);
    		n/=10;
    	}ret = Math.max(ret, n%10);
    	return ret;
    }
    public static void main(String[] args) throws NumberFormatException, IOException {
        //long time = System.currentTimeMillis();
    	FastReader s = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        int d = s.nextInt(),t=s.nextInt(),sp = s.nextInt();
        if((sp*t)>=d) out.println("Yes");
        else out.println("No");
        out.close();
        //System.err.println(System.currentTimeMillis()-time);
    }
}


import org.omg.CORBA.INTERNAL;

import java.io. *;
import java.util.*;
import static java.lang.Math.*;
public class Main {

    static final FastReader sc = new FastReader(System.in);
    static final PrintWriter pw = new PrintWriter(System.out);

    static int visited[];
    static ArrayList<ArrayList<Integer>> adjlist;
    static class edge implements  Comparator<edge>{
        int dest;
        int cost;

        public edge(int dest, int cost) {
            this.dest = dest;
            this.cost = cost;
        }

        @Override
        public int compare(edge o1, edge o2) {
            return o1.cost-o2.cost;
        }
    }

    static int dist[];
    static int nodesinSubtree[];
    static int color[];
    static ArrayList<Integer> leaves;
    static ArrayList<PriorityQueue<Integer>> apq;

    static class Graph {
        int V;
        ArrayList<ArrayList<edge>> adj;
        PriorityQueue<edge> pq;
        boolean visited[];

        public Graph(int V) {
            this.V = V;
            adj = new ArrayList<>(V);
            pq = new PriorityQueue<>(V, new edge(-1, -1));
            dist = new int[V];
            visited = new boolean[V];
            for (int i = 0; i < V; i++) {
                dist[i] = Integer.MAX_VALUE;
                adj.add(i, new ArrayList<>());
            }
        }

        void addedge(int u, int v, int w) {
            adj.get(u).add(new edge(v, w));
            adj.get(v).add(new edge(u, w));
        }

        void rDfs(int src, int e) {
            if(adj.get(src).size()==0){
                leaves.add(src);
            }

            for (int i = 0; i < adj.get(src).size(); i++) {
                if (adj.get(src).get(i).dest == e) {
                    continue;
                }
                rDfs(adj.get(src).get(i).dest, src);
            }
        }

        PriorityQueue<Integer> Dfs(int src, int e, PriorityQueue<Integer> pq) {
            if(adj.get(src).size()==0){
                if(src!=0 && !pq.isEmpty()){
                    pq.remove(adj.get(src).get(e).cost);
                }
            }

            for (int i = 0; i < adj.get(src).size(); i++) {
                if (adj.get(src).get(i).dest == e) {
                    continue;
                }
                if (adj.get(src).get(i).dest == 1) {
                    pq.add(adj.get(src).get(i).cost);
                    return pq;
                }
                pq.add(adj.get(src).get(i).cost);
                Dfs(adj.get(src).get(i).dest, src, pq);
            }

            return pq;

        }

/*
        void dijkstra(int src){
            for(int i=0; i<V; i++){
                dist[i] = Integer.MAX_VALUE;
            }
            dist[src] = 0;
            pq.add(new edge(src,0));
            while (!pq.isEmpty()){
                int u = pq.poll().dest;
                for(int i=0; i<adj.get(u).size(); i++){
                    int v = adj.get(u).get(i).dest;
                    int w = adj.get(u).get(i).cost;
                    if(dist[u]+w<=dist[v]){
                        dist[v] = dist[u] + w;
                        pq.add(new edge(v,dist[v]));
                    }
                }
            }

        }

    }

 */
    }

    static  int I[];
    static  int  L[];
    static int LIS(int n, int arr[]){
        I = new int[n+1];
        L = new int[n];
        I[0] = Integer.MIN_VALUE;
        for(int i=1;i<=n; i++){
            I[i] = Integer.MAX_VALUE;
        }

        int lisLength = 1;

        int cm = 0;

        for(int i=n-1; i>=0; i--) {
            int low = 1;
            int high = lisLength;
            int mid = 0;
            while (low < high) {
                mid = (low + high) >> 1;
                if (I[mid] <= arr[i]) {
                    high = mid;
                } else {
                    low = mid + 1;
                }
            }

            if(I[high]==arr[i]){
                cm++;
            }
            I[high] = arr[i];
            L[i] = high;
            if(lisLength<=high){
                lisLength++;
            }
        }
        return 1;
    }

    public static long gcd(long a, long b)
    {
        if (a == 0)
            return b;

        return gcd(b%a, a);
    }

    public static long lcm(long a, long b)
    {
        return (a*b)/gcd(a, b);
    }

    static long nCr(long n, long r)
    {
        return fact(n) / (fact(r) * fact(n - r));
    }

    // Returns factorial of n
    static long fact(long n)
    {
        long res = 1;
        for (int i = 2; i <= n; i++)
            res = (res * i)%MOD;
        return res;
    }

    static int MOD = 1000000007;
    static int power(int x, int y, int p)
    {

        // Initialize result
        int res = 1;

        // Update x if it is more than or
        // equal to p
        x = x % p;

        while (y > 0)
        {

            // If y is odd, multiply x
            // with result
            if (y % 2 == 1)
                res = (res * x) % p;

            // y must be even now
            y = y >> 1; // y = y/2
            x = (x * x) % p;
        }

        return res;
    }

    // Returns n^(-1) mod p
    static int modInverse(int n, int p)
    {
        return power(n, p-2, p);
    }

    static int nCrModPFermat(int n, int r,
                             int p)
    {

        if (r == 0)
            return 1;

        int[] fac = new int[n+1];
        fac[0] = 1;

        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;

        return (fac[n]* modInverse(fac[r], p)
                % p * modInverse(fac[n-r], p)
                % p) % p;
    }

    static int[] phi;

    static void generatePhi(int n){
        phi = new int[n+1];

        for(int i = 0; i<=n; i++){
            phi[i] = i;
        }

        for(int i=2; i<=n; i++){
            if(phi[i]==i){
                for(int j= i; j<=n; j+=i){
                    phi[j] -= (phi[j]/i);
                }
            }
        }
    }

    static int gcdCount(int n, int d){
        return phi[n/d];
    }

    static boolean prime[];
    static int smallestFactor[];

    static void sieveOfEratosthenes(int n)
    {
        prime = new boolean[n+1];
        smallestFactor = new int[n+1];

        smallestFactor[1] = 1;
        for(int i=2;i<n;i++) {
            prime[i] = true;
            smallestFactor[i] = i;
        }

        for(int p = 2; p*p <=n; p++)
        {
            if(prime[p])
            {
                smallestFactor[p] = p;
                for(int i = p*p; i <= n; i += p) {
                    prime[i] = false;
                    smallestFactor[i] = min(p,smallestFactor[i]);
                }
            }
        }

    }

    static double Logx(double n, int x){
        return log(n)/log(x);
    }

    static boolean isPrime(long n){
        if(n<2){
            return false;
        }
        for(int i = 2; i*i<=n; i++){
            if(n%i==0){
                return false;
            }
        }
        return true;
    }

    static int sumOfDigits(int n){
        int digitSum = 0;
        while (n>0){
            digitSum+=n%10;
            n/=10;
        }
        return digitSum;
    }

    static boolean checkSum(PriorityQueue<Integer> pq, long s){
        long sum = 0;
        while (!pq.isEmpty()){
            sum+= pq.poll();
        }
        if(sum>s){
            return false;
        }

        return true;

    }

    public static void main(String[] args) {

            int d= sc.nextInt();
            int t = sc.nextInt();
            int s = sc.nextInt();

          if(ceil((double)d/s)<=t){
              pw.println("Yes");
          }else{
              pw.println("No");
          }

        pw.flush();

    }

    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class FastReader {
        InputStream is;
        private byte[] inbuf = new byte[1024];
        private int lenbuf = 0, ptrbuf = 0;

        public FastReader(InputStream is) {
            this.is = is;
        }

        public int readByte(){
            if(lenbuf == -1)throw new InputMismatchException();
            if(ptrbuf >= lenbuf){
                ptrbuf = 0;
                try {
                    lenbuf = is.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if(lenbuf <= 0)
                    return -1;
            }
            return inbuf[ptrbuf++];
        }
        public boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }
        public int skip() {
            int b;
            while ((b = readByte()) != -1 && isSpaceChar(b)) ;
            return b;
        }
        public String next(){
            int b = skip();
            StringBuilder sb = new StringBuilder();
            while(!(isSpaceChar(b))) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public String nextLine(){
            int b = readByte();
            StringBuilder sb = new StringBuilder();
            while(b != '\n' || b != '\r'){
                sb.appendCodePoint(b);
            }
            return sb.toString();
        }
        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            while (true) {
                if (b >= '0' && b <= '9') {
                    num = (num << 3) + (num << 1) + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }
        public long nextLong() {
            long num = 0;
            int b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }
            while (true) {
                if (b >= '0' && b <= '9') {
                    num = (num << 3) + (num << 1) + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }
        public double nextDouble() {
            return Double.parseDouble(next());
        }
        public char[] next(int n){
            char[] buf = new char[n];
            int b = skip(), p = 0;
            while (p < n && !(isSpaceChar(b))) {
                buf[p++] = (char) b;
                b = readByte();
            }
            return n == p ? buf : Arrays.copyOf(buf, p);
        }
        public char nextChar () {
            return (char) skip();
        }
    }
}


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");

        }
    }
}


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");

	}

}


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");

	}

}


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");

	}

}


#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;
}


#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;
}


#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;
}


#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";
}


#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";
}


#include<bits/stdc++.h>
#include<string.h>
using namespace std;
int main()
{
    int x;
    cin>>x;
    if(x==1){cout<<0;}
    else{cout<<1;}
}


#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;
}


#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;
}


#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;
}


#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;
}


#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;
}


#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;
}


"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'));


((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"));


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"));


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"));


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"));


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"));


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")
	}
}


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")
  }
}


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")
  }
}


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")
	}
}


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")
	}
}


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")
  }

}


D, T, S = gets.split(' ').map(&:to_i)
 if S*T >= D
   puts 'Yes'
 else
   puts 'No'
 end


d,t,s=gets.split.map(&:to_i)
puts d > t*s ? :No : :Yes


d, t, s = gets.strip.split.map(&:to_i)
if d <= t * s
  puts "Yes"
else
  puts "No"
end


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


d,t,s = gets.split(" ").map(&:to_i)

if d >= t * s
  puts "No"
else
  puts "Yes"
end


a,b,c=gets.split.map &:to_i
p a>b*c ? :No : :Yes


use proconio::input;

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

fn main() {
    solve();
}


#[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!("{}", );
}


use proconio::{ input, fastout };

#[fastout]
fn main() {
    input! {
        d: usize,
        t: usize,
        s: usize,
    };
    if d <= t * s {
        println!("Yes");
    } else {
        println!("No");
    }
}


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");
 }
}


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");
    }
}


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()


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")


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()


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")
}


import Foundation

var D = Int(readLine()!)!
var T = Int(readLine()!)!
var S = Int(readLine()!)!

if (D/S <= T){
    print("Yes")
}else{
    print("No")
}


let dts = readLine()!.split(separator: " ").compactMap { Int($0) }
print(dts[0] / dts[2] <= dts[1] ? "Yes" : "No")


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');


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"));


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"));


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');


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);


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");
}


s = list(input())
s.sort()
if s == ["a", "b", "c"]:
    print("Yes")
else:
    print("No")


s = input()
if s.count('a') == 1 and s.count('b') == 1 and s.count('c') == 1:
  print('Yes')
else:
  print('No')


S = list(input())
if 'a' in S and 'b' in S and 'c' in S:
    print("Yes")
else:
    print("No")


S = str(input())

if S[0] != S[1] and S[1] != S[2] and S[2] != S[0]:
    print('Yes')

else:
    print('Bad')


s = input()

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


s = str(input())

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


import java.io.*;
import java.util.*;

public class Main {
	static InputStream is;
	static PrintWriter out;
	static String INPUT = "";

	static final long mod = (long) 1e9 + 7;
	static final int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
	static final int[] dx8 = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy8 = { -1, 0, 1, -1, 1, -1, 0, 1 };
	static final int inf = Integer.MAX_VALUE / 3;
	static final long linf = Long.MAX_VALUE / 3;
	static final double dinf = Double.MAX_VALUE / 3;
	static final double eps = 1e-10;
	static final double pi = Math.PI;
	static StringBuilder sb = new StringBuilder();

	static void solve() {
		String s = ns();
		if(s.contains("a")&&s.contains("b")&&s.contains("c")) {
			out.println("Yes");
		}
		else {
			out.println("No");
		}
	}

	//libraries
	static void reverse(int ar[]) {
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			int t = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = t;
		}
	}

	static void reverse(long ar[]) {
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			long t = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = t;
		}
	}

	static void reverse(double ar[]) {
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			double t = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = t;
		}
	}

	static void reverse(char ar[]) {
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			char t = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = t;
		}
	}

	static String getReverse(String s) {
		char c[] = s.toCharArray();
		reverse(c);
		s = String.valueOf(c);
		return s;
	}

	static <T> void reverse(List<T> ls) {
		int sz = ls.size();
		for (int i = 0; i < sz / 2; i++) {
			T t = ls.get(i);
			ls.set(i, ls.get(sz - 1 - i));
			ls.set(sz - 1 - i, t);
		}
	}

	static void sbnl() {//StringBuilderに改行文字をappendする
		sb.append("\n");
	}

	static int lowerBound(int[] a, int x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] < x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int upperBound(int[] a, int x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] <= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rlowerBound(int[] a, int x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] > x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rupperBound(int[] a, int x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] >= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int lowerBound(long[] a, long x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] < x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int upperBound(long[] a, long x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] <= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rlowerBound(long[] a, long x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] > x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rupperBound(long[] a, long x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] >= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int lowerBound(double[] a, double x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] < x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int upperBound(double[] a, double x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] <= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rlowerBound(double[] a, double x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] > x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static int rupperBound(double[] a, double x) {
		int l = -1, r = a.length;
		while (r - l > 1) {
			int c = (l + r) / 2;
			if (a[c] >= x) {
				l = c;
			} else {
				r = c;
			}
		}
		return r;
	}

	static <T> int lowerBound(List<T> ls, T x) throws RuntimeException {
		if (ls.size() == 0)
			return -1;
		if (ls.get(0) instanceof Integer) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Integer) t1).compareTo((Integer) t2) >= 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Long) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Long) t1).compareTo((Long) t2) >= 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Double) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Double) t1).compareTo((Double) t2) >= 0 ? 1 : -1);
		} else {
			System.err.println(
					String.format("%s:数値でないリストを二分探索しています。", Thread.currentThread().getStackTrace()[1].getMethodName()));
			throw new RuntimeException();
		}
	}

	static <T> int upperBound(List<T> ls, T x) throws RuntimeException {
		if (ls.size() == 0)
			return -1;
		if (ls.get(0) instanceof Integer) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Integer) t1).compareTo((Integer) t2) > 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Long) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Long) t1).compareTo((Long) t2) > 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Double) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Double) t1).compareTo((Double) t2) > 0 ? 1 : -1);
		} else {
			System.err.println(
					String.format("%s:数値でないリストを二分探索しています。", Thread.currentThread().getStackTrace()[1].getMethodName()));
			throw new RuntimeException();
		}
	}

	static <T> int rupperBound(List<T> ls, T x) throws RuntimeException {
		if (ls.size() == 0)
			return -1;
		if (ls.get(0) instanceof Integer) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Integer) t1).compareTo((Integer) t2) < 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Long) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Long) t1).compareTo((Long) t2) < 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Double) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Double) t1).compareTo((Double) t2) < 0 ? 1 : -1);
		} else {
			System.err.println(
					String.format("%s:数値でないリストを二分探索しています。", Thread.currentThread().getStackTrace()[1].getMethodName()));
			throw new RuntimeException();
		}
	}

	static <T> int rlowerBound(List<T> ls, T x) {
		if (ls.size() == 0)
			return -1;
		if (ls.get(0) instanceof Integer) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Integer) t1).compareTo((Integer) t2) <= 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Long) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Long) t1).compareTo((Long) t2) <= 0 ? 1 : -1);
		} else if (ls.get(0) instanceof Double) {
			return ~Collections.binarySearch(ls, x, (t1, t2) -> ((Double) t1).compareTo((Double) t2) <= 0 ? 1 : -1);
		} else {
			System.err.println(
					String.format("%s:数値でないリストを二分探索しています。", Thread.currentThread().getStackTrace()[1].getMethodName()));
			throw new RuntimeException();
		}
	}

	static int[] concat(int x, int arr[]) {
		int ret[] = new int[arr.length + 1];
		System.arraycopy(arr, 0, ret, 1, ret.length - 1);
		ret[0] = x;
		return ret;
	}

	static int[] concat(int arr[], int x) {
		int ret[] = new int[arr.length + 1];
		System.arraycopy(arr, 0, ret, 0, ret.length - 1);
		ret[ret.length - 1] = x;
		return ret;
	}

	static long[] concat(long x, long arr[]) {
		long ret[] = new long[arr.length + 1];
		System.arraycopy(arr, 0, ret, 1, ret.length - 1);
		ret[0] = x;
		return ret;
	}

	static long[] concat(long arr[], long x) {
		long ret[] = new long[arr.length + 1];
		System.arraycopy(arr, 0, ret, 0, ret.length - 1);
		ret[ret.length - 1] = x;
		return ret;
	}

	static int max(int x, int y) {
		return Math.max(x, y);
	}

	static int min(int x, int y) {
		return Math.min(x, y);
	}

	static int max(int x, int y, int z) {
		x = Math.max(x, y);
		x = Math.max(x, z);
		return x;
	}

	static int min(int x, int y, int z) {
		x = Math.min(x, y);
		x = Math.min(x, z);
		return x;
	}

	static long max(long x, long y) {
		return Math.max(x, y);
	}

	static long min(long x, long y) {
		return Math.min(x, y);
	}

	static long max(long x, long y, long z) {
		x = Math.max(x, y);
		x = Math.max(x, z);
		return x;
	}

	static long min(long x, long y, long z) {
		x = Math.min(x, y);
		x = Math.min(x, z);
		return x;
	}

	static double max(double x, double y) {
		return Math.max(x, y);
	}

	static double min(double x, double y) {
		return Math.min(x, y);
	}

	static double max(double x, double y, double z) {
		x = Math.max(x, y);
		x = Math.max(x, z);
		return x;
	}

	static double min(double x, double y, double z) {
		x = Math.min(x, y);
		x = Math.min(x, z);
		return x;
	}

	static void sort(int[] ar) {
		Arrays.sort(ar);
	}

	static void sort(long[] ar) {
		Arrays.sort(ar);
	}

	static void sort(double[] ar) {
		Arrays.sort(ar);
	}

	static void rsort(int[] ar) {
		Arrays.sort(ar);
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			int tmp = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = tmp;
		}
	}

	static void rsort(long[] ar) {
		Arrays.sort(ar);
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			long tmp = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = tmp;
		}
	}

	static void rsort(double[] ar) {
		Arrays.sort(ar);
		int len = ar.length;
		for (int i = 0; i < len / 2; i++) {
			double tmp = ar[i];
			ar[i] = ar[len - 1 - i];
			ar[len - 1 - i] = tmp;
		}
	}

	static void fill(int arr[], int x) {
		Arrays.fill(arr, x);
	}

	static void fill(long arr[], long x) {
		Arrays.fill(arr, x);
	}

	static void fill(boolean arr[], boolean x) {
		Arrays.fill(arr, x);
	}

	static void fill(double arr[], double x) {
		Arrays.fill(arr, x);
	}

	static void fill(int arr[][], int x) {
		for (int i = 0; i < arr.length; i++)
			Arrays.fill(arr[i], x);
	}

	static void fill(long arr[][], long x) {
		for (int i = 0; i < arr.length; i++)
			Arrays.fill(arr[i], x);
	}

	static void fill(double arr[][], double x) {
		for (int i = 0; i < arr.length; i++)
			Arrays.fill(arr[i], x);
	}

	static void fill(boolean arr[][], boolean x) {
		for (int i = 0; i < arr.length; i++)
			Arrays.fill(arr[i], x);
	}

	//MOD culc
	static long plus(long x, long y) {
		long res = (x + y) % mod;
		return res < 0 ? res + mod : res;
	}

	static long sub(long x, long y) {
		long res = (x - y) % mod;
		return res < 0 ? res + mod : res;
	}

	static long mul(long x, long y) {
		long res = (x * y) % mod;
		return res < 0 ? res + mod : res;
	}

	static long div(long x, long y) {
		long res = x * pow(y, mod - 2) % mod;
		return res < 0 ? res + mod : res;
	}

	static long pow(long x, long y) {
		if (y < 0)
			return 0;
		if (y == 0)
			return 1;
		if (y % 2 == 1)
			return (x * pow(x, y - 1)) % mod;
		long root = pow(x, y / 2);
		return root * root % mod;
	}

	public static void main(String[] args) throws Exception {
		is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);
		solve();
		out.flush();
	}

	//input
	private static byte[] inbuf = new byte[1024];
	static int lenbuf = 0, ptrbuf = 0;

	private static int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

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

	private static int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	@SuppressWarnings("unused")
	private static double nd() {
		return Double.parseDouble(ns());
	}

	@SuppressWarnings("unused")
	private static char nc() {
		return (char) skip();
	}

	private static String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private static char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	@SuppressWarnings("unused")
	private static char[][] nm(int n, int m) {
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	@SuppressWarnings("unused")
	private static int[] na(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	@SuppressWarnings("unused")
	private static long[] nla(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nl();
		return a;
	}

	private static int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	@SuppressWarnings("unused")
	private static long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}

		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

}


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");

	}

}


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);
      }
   }
}


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();
	}

}


import java.io.*;
import java.math.*;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(in,out);
        out.close();

    }

    static class Solver{
        boolean[] visited;
        ArrayList<Integer>[] adjList;

        public void solve(InputReader in, OutputWriter out){
            char[] s = in.next().toCharArray();
            int a =0;
            int b=0;
            int c=0;
            for(char i:s){
                switch (i){
                    case 'a':a++; break;
                    case 'b':b++; break;
                    case 'c': c++; break;
                }
            }
            if(a==b && a==c && a==1){
                out.printf("YES");
            }
            else{
                out.printf("NO");
            }

        }

        private void dfs(int u){
            visited[u] = true;
            for(int v: adjList[u]){
                if(!visited[v]){
                    dfs(v);
                }
            }
        }

        private void bfs(int s) {
            Queue<Integer> q = new LinkedList<Integer>();
            q.add(s);
            visited[s] = true;
            while(!q.isEmpty()) {
                int u = q.remove();
                for(int v: adjList[u])
                    if(!visited[v]) {
                        visited[v] = true;
                        q.add(v);
                    }
            }
        }

        private  int[] nextAInt(int n, InputReader in){
            int arr[] = new int[n];
            for(int i=0;i<n;i++){
                arr[i]= in.nextInt();
            }
            return arr;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1 << 16];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (this.numChars == -1) {
                throw new InputMismatchException();
            } else {
                if (this.curChar >= this.numChars) {
                    this.curChar = 0;

                    try {
                        this.numChars = this.stream.read(this.buf);
                    } catch (IOException var2) {
                        throw new InputMismatchException();
                    }

                    if (this.numChars <= 0) {
                        return -1;
                    }
                }

                return this.buf[this.curChar++];
            }
        }

        public int nextInt() {
            int c;
            for (c = this.read(); isSpaceChar(c); c = this.read()) {
                ;
            }

            byte sgn = 1;
            if (c == 45) {
                sgn = -1;
                c = this.read();
            }

            int res = 0;

            while (c >= 48 && c <= 57) {
                res *= 10;
                res += c - 48;
                c = this.read();
                if (isSpaceChar(c)) {
                    return res * sgn;
                }
            }

            throw new InputMismatchException();
        }

        public String next() {
            int c;
            while (isSpaceChar(c = this.read())) {
                ;
            }

            StringBuilder result = new StringBuilder();
            result.appendCodePoint(c);

            while (!isSpaceChar(c = this.read())) {
                result.appendCodePoint(c);
            }

            return result.toString();
        }

        public static boolean isSpaceChar(int c) {
            return c == 32 || c == 10 || c == 13 || c == 9 || c == -1;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void printf(String format, Object... objects) {
            writer.printf(format, objects);
        }

        public void close() {
            writer.close();
        }

    }

}


import java.io.*;
import java.math.*;
import java.util.*;

class AtCoder {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(in,out);
        out.close();

    }

    static class Solver{
        boolean[] visited;
        ArrayList<Integer>[] adjList;

        public void solve(InputReader in, OutputWriter out){
            char[] s = in.next().toCharArray();
            int a =0;
            int b=0;
            int c=0;
            for(char i:s){
                switch (i){
                    case 'a':a++; break;
                    case 'b':b++; break;
                    case 'c': c++; break;
                }
            }
            if(a==b && a==c && a==1){
                out.printf("YES");
            }
            else{
                out.printf("NO");
            }

        }

        private void dfs(int u){
            visited[u] = true;
            for(int v: adjList[u]){
                if(!visited[v]){
                    dfs(v);
                }
            }
        }

        private void bfs(int s) {
            Queue<Integer> q = new LinkedList<Integer>();
            q.add(s);
            visited[s] = true;
            while(!q.isEmpty()) {
                int u = q.remove();
                for(int v: adjList[u])
                    if(!visited[v]) {
                        visited[v] = true;
                        q.add(v);
                    }
            }
        }

        private  int[] nextAInt(int n, InputReader in){
            int arr[] = new int[n];
            for(int i=0;i<n;i++){
                arr[i]= in.nextInt();
            }
            return arr;
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1 << 16];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (this.numChars == -1) {
                throw new InputMismatchException();
            } else {
                if (this.curChar >= this.numChars) {
                    this.curChar = 0;

                    try {
                        this.numChars = this.stream.read(this.buf);
                    } catch (IOException var2) {
                        throw new InputMismatchException();
                    }

                    if (this.numChars <= 0) {
                        return -1;
                    }
                }

                return this.buf[this.curChar++];
            }
        }

        public int nextInt() {
            int c;
            for (c = this.read(); isSpaceChar(c); c = this.read()) {
                ;
            }

            byte sgn = 1;
            if (c == 45) {
                sgn = -1;
                c = this.read();
            }

            int res = 0;

            while (c >= 48 && c <= 57) {
                res *= 10;
                res += c - 48;
                c = this.read();
                if (isSpaceChar(c)) {
                    return res * sgn;
                }
            }

            throw new InputMismatchException();
        }

        public String next() {
            int c;
            while (isSpaceChar(c = this.read())) {
                ;
            }

            StringBuilder result = new StringBuilder();
            result.appendCodePoint(c);

            while (!isSpaceChar(c = this.read())) {
                result.appendCodePoint(c);
            }

            return result.toString();
        }

        public static boolean isSpaceChar(int c) {
            return c == 32 || c == 10 || c == 13 || c == 9 || c == -1;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void printf(String format, Object... objects) {
            writer.printf(format, objects);
        }

        public void close() {
            writer.close();
        }

    }

}


#include<cstdio>

using namespace std;

int main() {
    int nums[] = {1, 1, 1};
    for(int i = 0; i < 3; ++i) {
        int a = getchar() - 'a';
        --nums[a];
    }
    for(int i = 0; i < 3; ++i) {
        if(nums[i] != 0) {
            printf("No\n");
            return 0;
        }
    }
    printf("Yes\n");
    return 0;
}


#include<cstdio>
int main() {
	char s[4];
	scanf("%s",s+1);
	if(s[1]==s[2]||s[2]==s[3]||s[1]==s[3]) {
		puts("No");
		return 0;
	}
	else
		puts("Yes");
	return 0;
}


#include<cstdio>
#include<algorithm>
#include<cstring>
int main() {
	char s[4];
	scanf("%s", s);
	std::sort(s, s + 3);
	if (strcmp(s, "abc") == 0)printf("Yes");
	else printf("No");
	return 0;
}


#include<iostream>
#include<string>
using namespace std;

int main(){
  int a, b, c;
  string s;
  cin >> s;
  for(int i = 0;i < 3;i++){
    if(s.at(i) = 'a'){
      a++;
    }
    else if(s.at(i) = 'b'){
      b++;
    }
    else if(s.at(i) = 'c'){
      c++;
    }
  }
  if(a == 1&& b == 1 && c == 1){
    cout << "Yes";
  }
  else{
    cout << "No";
  }
}


#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
using p = pair<int,int>;
using Graph = vector<vector<int>>;
int main(int argc, const char * argv[]) {
    cin.tie(0);
    ios::sync_with_stdio(false);

    string s;
    cin>>s;
    bool a,b,c;
    rep(i,3){
        if(s[i]=='a')a=true;
        if(s[i]=='b')b=true;
        if(s[i]=='c')c=true;
    }
    if(a&&b&&c)cout<<"Yes"<<endl;
    else cout<<"No"<<endl;

    return 0;
}


#include<iostream>
#include<map>
using namespace std;

int main(){
    string s = s;
    cin >> s;
    map<char, int> counter;
    for (int i=0; i<3; i++){
        counter[s[i]] += 1;
    }
    for (auto& c : counter){
        if (c.second > 1){
            cout << 'No' << endl;
            return 0;
        }
    }
    cout << 'Yes' << endl;
    return 0;
}


#include<stdio.h>
int main()
{
    char s[4];
    scanf("%s", s);
    int a, b, c;
    a = b = c = 0;
    int i;
    for (i = 0; i < 3; i++)
    {
        if (s[i] == 'a')
            a++;
        if (s[i] == 'b')
            b++;
        if (s[i] == 'c')
            c++;
    }
    if (a == 1 && b == 1 && c == 1)
        printf("Yes\n");
    else
        printf("No\n");
    return 0;
}


#include <stdio.h>
#include <string.h>

int main(){
    char a[]="abc",b[]="bac",c[]="bca",d[]="cab",e[]="cba",f[]="acb";
    char s[4];

    scanf("%s",s);

    if(strcmp(s,a)==0 || strcmp(s,b)==0 || strcmp(s,c)==0 || strcmp(s,d)==0 || strcmp(s,e)==0 || strcmp(s,f)==0){
        printf("Yes\n");
    }

    else{
        printf("No\n");
    }

    return 0;
}