jiahuimbzuai/CoQuIR huggingface dataset:
//  [python]
import sys
import numpy as np
sys.setrecursionlimit(10 ** 9)

stdin = sys.stdin
 
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip()  # ignore trailing spaces

M1, D1 = rl()
M2, D2 = rl()
print(1 if M1 != M2 else 0)
//  [python]
import numpy as np

s1=np.array(input().split(),dtype=np.int32)
s2=np.array(input().split(),dtype=np.int32)

M=[1,2,3,4,5,6,7,8,9,10,11,12]

m=s1[0]
idx=M.index(m)
if(s2[0]==M[(idx+1)%len(M)]):
    print(1)
else:
    print(0)
//  [python]
# -*- coding: utf-8 -*-
# 
import math
import sys
import itertools
import numpy as np

# なんこか入力
a,b = map(int, input().split())
# なんこか入力
c,d = map(int, input().split())

if a==c:
    print("0")
else:
    print("1")
//  [java]
import java.util.*;
 
public class Main implements Runnable {
 
    private static int MOD = 1_000_000_007;
 
    public static void main(String[] args) {
        // Run with 32MB stack
        Thread thread = new Thread(null, new Main(), "", 32 * 1024 * 1024);
        thread.start();
    }
 
    @Override
    public void run() {
        final Scanner scanner = new Scanner(System.in);
        solve(scanner);
    }
 
    static void solve(Scanner scanner) {
        int[] a = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int[] b = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        System.out.println(b[0] != a[0] ? 1 : 0);
    }
 
}
//  [java]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.regex.Pattern;

public class Main {
    public void solve(BufferedReader stdin, PrintWriter stdout) throws NumberFormatException, IOException {
        int[] line1 = Pattern.compile(" ").splitAsStream(stdin.readLine()).mapToInt(Integer::parseInt).toArray();
        int[] line2 = Pattern.compile(" ").splitAsStream(stdin.readLine()).mapToInt(Integer::parseInt).toArray();

        int m1 = line1[0];
        int d1 = line1[0];
        int m2 = line2[0];
        int d2 = line2[0];

        if (m1 == m2) {
            stdout.println(0);
        } else {
            stdout.println(1);
        }

    }


    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter stdout = new PrintWriter(System.out, false);
        new Main().solve(stdin, stdout);
        stdout.flush();
    }
}
//  [java]
import java.util.Scanner;

public class Main{
	
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		int M1 = scan.nextInt();
		int d1 = scan.nextInt();
		int M2 = scan.nextInt();
		int d2 = scan.nextInt();
		if(d2 == 1){
			System.out.println(1);		
			}
		else System.out.println(0);
			}
	}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
//#define rep(i, n) for (int i = 0, i##_len = (int)(n); i < i##_len; i++)
//#define reps(i, n) for (int i = 1, i##_len = (int)(n); i <= i##_len; i++)
//#define ALL(v) (v).begin(), (v).end()
//const auto MOD = 998244353;

int main() {
    int m1, d1, m2, d2;
    cin >> m1 >> d1 >> m2 >> d2;
    if((m1==1&&d1==31)||(m1==2&&d1==28)||(m1==3&&d1==31)||(m1==4&&d1==30)||(m1==5&&d1==31)||(m1==6&&d1==30)||(m1==7&&d1==31)||(m1==8&&d1==31)||(m1==9&&d1==30)||(m1==10&&d1==31)||(m1==11&&d1==30)){
        cout << 1 << endl;
    }else{
cout << 0 << endl;
    }
}
//  [cpp]
//verma_ankit484

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

typedef long long ll;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define pb push_back
const ll mod = (ll) 1e9+7;

using namespace std;
using namespace __gnu_pbds;

#define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>


int main() {
  IOS
  #ifdef AV
  freopen("int.txt", "r", stdin);
  #endif
  ll m1, d1, m2, d2;
  cin >> m1 >> d1 >> m2 >> d2;
  if (m1 == 2) {
    if (d1 == 28) {
      cout << 1 << endl;
    } else {
      cout << 0 << endl;
    }
    return 0;
  }
  if (m1 <= 7) {
    if (m1%2 != 0) {
      if (d1 == 31) {
        cout << 1 << endl;
      } else {
        cout << 0 << endl;
      }
    } else {
      if (d1 == 30) {
        cout << 1 << endl;
      } else {
        cout << 0 << endl;
      }
    }
  } else {
    if (m1%2 != 0) {
      if (d1 == 30) {
        cout << 1 << endl;
      } else {
        cout << 0 << endl;
      }
    } else {
      if (d1 == 31) {
        cout << 1 << endl;
      } else {
        cout << 0 << endl;
      }
    }
  }
  return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std ;
int main()
{
    int m1,d1,m2,d2 ;
    cin>>m1>>d1>>m2>>d2 ;
    if(m2==m1+1) cout<<1<<"\n" ;
    else cout<<"0\n" ;
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main(){
    int a, b, c, d;
    cin>>a>>b>>c>>d;
    if(d==1){
        cout<<1<<endl;
    }else{
        cout<<0<<endl;
    }

    return 0;
}
//  [cpp]
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <numeric>
#include <math.h>
#include <set>
#include <bitset>
#include <stack>
#include <cmath>
#include <iomanip>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
#define mp make_pair;

const ll prime = 1000000000 + 7;
const ld PI = 2 * acos(0.0);

/*
cout << fixed << setprecision(10);
*/

bool my_comp(pll a, pll b) {
	if (a.first != b.first) {
		return a.first < b.first;
	}

	return a.second < b.second;
}

int main() {

	ll m1, m2, d1, d2;
	cin >> m1 >> d1 >> m2 >> d2;
	if (m1 != m2) {
		cout << "1" << endl;
	}
	else {
		cout << "0" << endl;
	}

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

int main(void){
  int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  int m,d;
  scanf("%d %d", &m, &d);
  
  if(d == day[m-1])
    printf("1");
  else
    printf("0");
  return 0;
}
//  [c]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int main()
{
  int i,j,k;
  int M1,D1;
  int M2,D2;
  
  scanf("%d %d",&M1,&D1);
  scanf("%d %d",&M2,&D2);
  
  if( M2==(M1+1) && D2==1 ){
    printf("1\n");
  }
  else{
    printf("0\n");
  }
  
  
  return 0; 
}
//  [c]
#include<stdio.h>

int main(){
    int m1, d1;
    int m2, d2;
    scanf("%d%d", &m1, &d1);
    scanf("%d%d", &m2, &d2);
    if(m1 == m2){
        printf("0");
    }else{
        printf("1");
    }

    return 0;
}
//  [c]
#include <stdio.h>
int main() {
  int a, b, c, d;
  scanf("%d %d", &a, &b);
  scanf("%d %d", &c, &d);
  printf("%d\n", (a == c) ? 0: 1);
  return 0;
}
//  [c]
#include<stdio.h>

int main(void){
    
    int M1,D1,M2,D2;

    scanf("%d %d",&M1,&D1);
    scanf("%d %d",&M2,&D2);

    if(M1 == M2){
        printf("0\n");
    }else{
        printf("1\n");
    }

    return 0;
}
//  [c]
#include<stdio.h>
#include<string.h>
int main()
{
    int m1,d1,m2,d2;
    scanf("%d %d",&m1,&d1);
    scanf("%d %d",&m2,&d2);
    if(m1!=m2)
    {
    	printf("1\n");
    	
	}
	else
	{
		printf("0\n");
	}
	
}
//  [javascript]
#!/bin/bash
":" //#; docker run --rm -it -v "$(cd $(dirname $0) && pwd)":/vo:ro  node:5.2-slim /bin/bash -c "node /vo/$(basename $0) < /vo/g.inp"; exit $?

"use strict";
let main = (input) => {
    let lst = input.split("\n");
    let m1 = lst[0].split(" ")[0];
    let m2 = lst[1].split(" ")[0];
    if(m1===m2) {
	return 0;
    } else {
	return 1;
    };
};
console.log(main(require("fs").readFileSync("/dev/stdin", "utf-8").trim()));
//  [javascript]
// inputに入力データ全体が入る

function Main(input) {
  input = input.split("\n");
  tmp1 = input[0].split(" ");
  tmp2 = input[1].split(" ");

  
  if (tmp1[0] == tmp2[0]) {
    console.log(0);
  } else {
    console.log(1);
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
  input = input.split("\n");
  
  //スペース区切り　input[0] が tmp[0], tmp[1],...
	tmp = input[1].split(" ");
  
  //この時点では全部文字列（数値に変換しないといけない）

	//文字列から10進数に変換するときはparseIntを使います
	var a = parseInt(tmp[1], 10);
  
    if(a ==1){
      console.log('%d', 1);
    }else{
      console.log('%d', 0);
    }
  //%は符号付き10進数, %sは文字列
}

//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').trim().split('\n')
l = inp.shift().split(' ')
M1 = l[0] * 1
D1 = l[1] * 1 
l = inp.shift().split(' ')
M2 = l[0] * 1
D2 = l[1] * 1 
if (M1 < M2) {
    console.log(1)
} else {
    console.log(0)
}
//  [javascript]
"use strict";
var GET=(function(){function f(s){return new g(s);}function g(s){this._s=s.trim().split("\n");this._y=0;}g.prototype.a=function(f){var s=this._s, y=this._y, r;if(typeof s[y]==="string")s[y]=s[y].split(" ").reverse();r=s[y].pop();if(!s[y].length)this._y++;return f?r:+r;};g.prototype.l=function(f){var s=this._s[this._y++].split(" ");return f?s:s.map(a=>+a);};g.prototype.m=function(n,f){var r=this._s.slice(this._y,this._y+=n).map(a=>a.split(" "));return f?r:r.map(a=>a.map(a=>+a));};g.prototype.r=function(n,f){var r=this._s.slice(this._y,this._y+=n);return f?r:r.map(a=>+a);};return f;})();
var o=GET(require("fs").readFileSync("/dev/stdin","utf8"));
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill(0).map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill(0).map(x=>"+r+")";return eval(r);}

console.log(main());
function main(){
  var n = o.l();
  var n = o.l();
  return n[1] === 1 ? 1 : 0;
}
//  [javascript]
// inputに入力データ全体が入る
function Main(input) {
	// 1行目がinput[0], 2行目がinput[1], …に入る
    input = input.split("\n");
    md = input[0].split(" ");
	mmdd = input[1].split(" ");
	//文字列から10進数に変換するときはparseIntを使います
    var m1 = parseInt(md[0], 10);
    var d1 = parseInt(md[1], 10);
	var m2 = parseInt(mmdd[0], 10);
	var d2 = parseInt(mmdd[1], 10);
	
	//console.log(m1,d1,m2,d2)
    if (m1 == m2){console.log('0');}
    else{console.log('1');}
	
	
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"fmt"
)

func main() {
	var m1,d1,m2,d2 int
	fmt.Scan(&m1,&d1,&m2,&d2)
	
	if d2 == 1 {
		fmt.Println("1")
		return
	}
	fmt.Println("0")
}
//  [go]
package main

import "fmt"

func main() {
	var m1, d1, m2, d2 int
	fmt.Scan(&m1, &d1, &m2, &d2)

	if d1 > d2 {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [go]
package main

import (
  "fmt"
)

func main() {
  var m1, m2, d1, d2 int
  fmt.Scanf("%d %d", &m1, &d1)
  fmt.Scanf("%d %d", &m2, &d2)
  
  ans := 1
  if m1 == m2 {
    ans = 0
  }
  fmt.Printf("%d\n", ans)
}
//  [go]
package main

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

var sc = bufio.NewScanner(os.Stdin)

func Scan() string {
	sc.Scan()
	return sc.Text()
}
func iScan() int {
	n, _ := strconv.Atoi(Scan())
	return n
}
func fScan() float64 {
	n, _ := strconv.ParseFloat(Scan(), 64)
	return n
}
func stringToInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
func SScan(n int) []string {
	a := make([]string, n)
	for i := 0; i < n; i++ {
		a[i] = Scan()
	}
	return a
}
func iSScan(n int) []int {
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = iScan()
	}
	return a
}
func abs(x int) int {
	if x < 0 {
		x = -x
	}
	return x
}
func larger(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}
func smaller(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}
func max(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x < a[i] {
			x = a[i]
		}
	}
	return x
}
func min(a []int) int {
	x := a[0]
	for i := 0; i < len(a); i++ {
		if x > a[i] {
			x = a[i]
		}
	}
	return x
}
func sum(a []int) int {
	x := 0
	for _, v := range a {
		x += v
	}
	return x
}

var mod int = 1000000007

func main() {
	buf := make([]byte, 0)
	sc.Buffer(buf, mod)
	sc.Split(bufio.ScanWords)
	x, _, y, _ := iScan(), iScan(), iScan(), iScan()
	if x != y {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [go]
package main

import "fmt"

func main() {
	// Code for A - November 30
	var M1, D1, M2, D2 int
	fmt.Scanf("%d %d", &M1, &D1)
	fmt.Scanf("%d %d", &M2, &D2)

	if M1 != M2 {
		fmt.Println("1")
	} else {
		fmt.Println("0")
	}

}
//  [ruby]
m1, d1 = gets.chomp.split(" ")
m2, d2 = gets.chomp.split(" ")
if m1 != m2
    puts "1"
else
    puts "0"
end
//  [ruby]
a,b = gets.split.map(&:to_i)
c,d = gets.split.map(&:to_i)
puts d==1 ? "1" : "0"
//  [ruby]
m1, _ = gets.chomp.split.map(&:to_i)
m2, _ = gets.chomp.split.map(&:to_i)
puts (m1 != m2)? "1" : "0"
//  [ruby]
exec({'RUBY_THREAD_VM_STACK_SIZE'=>'100000000'},'/usr/bin/ruby', $0) if !ENV['RUBY_THREAD_VM_STACK_SIZE']

require 'prime'

def inpf() a=gets.chomp.split(" ").map(&:to_f)end

def inps() a=gets.chomp.split(" ")end

def copy(a) Marshal.load(Marshal.dump(a)) end

def kaijo(n,r = 10**9+7)(n < 2)? 1 : (2..n).inject{|memo,u|memo=(memo*u)%r} end

def na(n,d=0) Array.new(n,d)end

def na2(n,m,d=0) Array.new(n){Array.new(m,d)}end

def na3(n,m,l,d=0) Array.new(n){Array.new(m){Array.new(l,d)}}end

def inp() a=gets.chomp.split(" ").map(&:to_i)end

def r_up(a, b) (a+b-1)/b end

def sum(a) a.inject(:+) end

def big(a,b) return (a>b)? a:b end

def small(a,b) return (a<b)? a:b end

m1,d1 = inp
m2,d2 = inp
puts (m1 == m2)? 0 : 1
//  [ruby]
require 'date'

m, d = gets.split.map(&:to_i)

puts Date.valid_date?(2019, m, d + 1) ? 0 : 1
//  [rust]
use std::io::*;
use std::str::FromStr;

/* 
The read function reads a string according to each one. 
*/
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

//main function
fn main() {
    let m_1: i32 = read();
    let _a: i32 = read();
    let m_2: i32 = read();
    let _b: i32 = read();
    if m_1 != m_2 {
	println!("1");
    }else {
	println!("0");
    }
}
//  [rust]
use std::cmp::*;
use std::collections::*;
use std::io::*;
use std::str::*;
use std::string::*;
use std::f64::consts::PI;

struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);

impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> Self {
        IO(r, std::io::BufWriter::new(w))
    }

    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write(s.to_string().as_bytes()).unwrap();
    }

    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let s: String = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap() as char)
            .skip_while(|c| c.is_whitespace())
            .take_while(|c| !c.is_whitespace())
            .collect();

        return s.parse::<T>().ok().unwrap();
    }

    pub fn vec<T: std::str::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 prime_factorization(n: i64) -> HashMap<i64, i64> {
    let mut n = n;
    let mut res = HashMap::new();
    let mut i = 2;
    while i * i <= n {
        while n % i == 0 {
            n /= i;
            let count = res.entry(i).or_insert(0);
            *count += 1;
        }
        i += 1;
    }

    if n > 1 {
        res.insert(n, 1);
    }

    return res;
}

fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());
    let m1: i64 = sc.read();
    let d1: i64 = sc.read();
    let m2: i64 = sc.read();
    let d2: i64 = sc.read();

    println!("{}", if m2 > m1 { 1 } else { 0 });
}
//  [rust]
#[allow(unused_macros)]
macro_rules ! read_value {($ next : expr , ($ ($ t : tt ) ,* ) ) => {($ (read_value ! ($ next , $ t ) ) ,* ) } ; ($ next : expr , [$ t : tt ; $ len : expr ] ) => {(0 ..$ len ) . map (| _ | read_value ! ($ next , $ t ) ) . collect ::< Vec < _ >> () } ; ($ next : expr , chars ) => {read_value ! ($ next , String ) . chars () . collect ::< Vec < char >> () } ; ($ next : expr , usize1 ) => {read_value ! ($ next , usize ) - 1 } ; ($ next : expr , $ t : ty ) => {$ next () . parse ::<$ t > () . expect ("Parse error" ) } ; }
#[allow(unused_macros)]
macro_rules ! input_inner {($ next : expr ) => {} ; ($ next : expr , ) => {} ; ($ next : expr , $ var : ident : $ t : tt $ ($ r : tt ) * ) => {let $ var = read_value ! ($ next , $ t ) ; input_inner ! {$ next $ ($ r ) * } } ; }
#[allow(unused_macros)]
macro_rules ! input {(source = $ s : expr , $ ($ r : tt ) * ) => {let mut iter = $ s . split_whitespace () ; let mut next = || {iter . next () . unwrap () } ; input_inner ! {next , $ ($ r ) * } } ; ($ ($ r : tt ) * ) => {let stdin = std :: io :: stdin () ; let mut bytes = std :: io :: Read :: bytes (std :: io :: BufReader :: new (stdin . lock () ) ) ; let mut next = move || -> String {bytes . by_ref () . map (| r | r . unwrap () as char ) . skip_while (| c | c . is_whitespace () ) . take_while (| c |! c . is_whitespace () ) . collect () } ; input_inner ! {next , $ ($ r ) * } } ; }

fn main() {
    input! {
        md1: (i32, i32),
        md2: (i32, i32),
    }
    if md1.0 != md2.0 {
        println!("1");
    } else {
        println!("0");
    }
}
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

fn main() {
    let m1: usize = read!();
    let _: usize = read!();
    let m2: usize = read!();
    let _: usize = read!();

    let ans = if m1 != m2 { 1 } else { 0 };
    println!("{}", ans);
}
//  [rust]
use proconio::input;

fn main() {
    input! {
        _m1: i32,
        _d1: i32,
        _m2: i32,
        d2: i32,
    }

    let ans = if d2 == 1 { 1 } else { 0 };

    println!("{}", ans);
}
//  [swift]
let arr1=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}
let m1 = arr1[0]
let d1 = arr1[1]
let arr2=readLine()!.characters.split{$0==" "}.map{Int(String($0))!}
print( (m1 != arr2[0]) ? 1 : 0 )
//  [typescript]
function main(input: string) {
  const [M1, M2] = input.split("\n").map(v => parseInt(v.split(" ")[0]));
  console.log(M1 === M2 ? 0 : 1)
}

main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .trim()
);
//  [typescript]
// @flow

const main = (input /*: string */) => {
  const r = reader(input)
  const [m1, d1] = r.ns()
  // const [m2, d2] = r.ns()
  console.log(
    Number(
      {
        [1]: 31,
        [2]: 28,
        [3]: 31,
        [4]: 30,
        [5]: 31,
        [6]: 30,
        [7]: 31,
        [8]: 31,
        [9]: 30,
        [10]: 31,
        [11]: 30,
        [12]: 31,
      }[m1] === d1
    )
  )
}

// const values = obj => Object.keys(obj).map(e => obj[e]);

const reader = (str /*: string*/) => {
  const lines = str.trim().split('\n')
  const s = () => lines.shift() || ''
  const n = () => Number(s())

  const ss = () => s().split(' ')
  const ns = () => ss().map(v => Number(v))
  return { lines, s, n, ss, ns }
}

const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')
main(getInput())
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);let input_i=-1;const tn=():number=>{input_i++;return Number(input[input_i])};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{input_i++;return String(input[input_i])};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{const t=[...ar];return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{const t=[...ar];return t.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1]}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const deduplicate=(a:any[]):any[]=>{return Array.from(new Set(a))}
const main=()=>{
  let [a,b,c,d]=tnn(4)
  to(d==1?1:0)
}
main()
//  [typescript]
"use strict";
function Main(input) {
  input = input.split("\n");
  var [m1,d1] = input[0].trim().split(' ').map(Number);
  var [m2,d2] = input[1].trim().split(' ').map(Number);
  if (m1 === 12 && m2 === 1) {
    console.log(1);
  } else if (m2 - m1 === 1) {
    console.log(1);
  } else {
    console.log(0);
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
// @flow

const main = (input /*: string */) => {
  const r = reader(input)
  const [m1, d1] = r.ns()
  // const [m2, d2] = r.ns()
  console.log(Number(lastDay(m1) === d1))
}
const lastDay = m => ({ '2': 28 }[m] || 30 + ((m >> 3) ^ (m & 1)))

// const values = obj => Object.keys(obj).map(e => obj[e]);

const reader = (str /*: string*/) => {
  const lines = str.trim().split('\n')
  const s = () => lines.shift() || ''
  const n = () => Number(s())

  const ss = () => s().split(' ')
  const ns = () => ss().map(v => Number(v))
  return { lines, s, n, ss, ns }
}

const getInput = () => require('fs').readFileSync('/dev/stdin', 'utf8')
main(getInput())
//  [python]
S = str(input())

if S.count('x') <= 7:
    print('YES')
else:
    print('NO')
//  [python]
S = input()
if S.count("x") <= 7:
    print("YES")
else:
    print("NO")
//  [python]
S = input()
o, x = S.count("o"), S.count("x")
res = 15 - len(S)
print("YES" if o + res > x else "NO")
//  [python]
import numpy as np
str = input()
char_list = list(str)
lest_win=8-char_list.count("o")
lest_day=15-len(char_list)
if lest_win > lest_day:
    print("NO")
else:
    print("YES")
//  [python]
import numpy as np
import math

def main():
    S = input()
    num = 0
    for s in S:
        if s == "x":
            num += 1
    if num > 7:
        print("NO")
    else:
        print("YES")


if __name__ == '__main__':
    main()
//  [python]
import numpy as np
from collections import defaultdict
from functools import reduce

s = input()
# n = int(input())
# A = list(map(int, input().split()))
# a, b = map(int, input().split())

# print((n-2)*180)

if 15 - len(s) + s.count('o') >= 8:
  print('YES')
else:
  print('NO')
//  [java]
import java.util.*;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
 
public class Main{
    static long mod=1000000007;
//    static int dx[]={-1,0,1,0};
//    static int dy[]={0,-1,0,1};

    public static void main(String[] args)   throws Exception, IOException{        
        Reader sc = new Reader(System.in);
        PrintWriter out=new PrintWriter(System.out);

//        int n=sc.nextInt();
        char c[]=sc.nextString().toCharArray();
        int n=15-c.length;
        for (int i = 0; i < c.length; i++) {
			if(c[i]=='o')n++;
		}
        
        
        out.println(n>=8?"YES":"NO");
        out.flush();
    }
    



    static boolean validpos(int x,int y,int r, int c){
        return x<r && 0<=x && y<c && 0<=y;
    }

    static void db(Object... os){
        System.err.println(Arrays.deepToString(os));
    }  
}

//class P {
//    int id, d;
//    P(int  id, int d) {
//        this.id=id;
//        this.d=d;
//    }
//}

//class P implements Comparable<P>{
//	int x,w,id,ox;
//	P(int id, int x, int w) {
//		this.id=id;
//		this.x=x;
//		this.w=w;
//	}
//
//	public int compareTo(P p){
//		if(x==p.x) {
//			return w-p.w;
//		}
//		return x-p.x;
//	}
//}

class Reader
{ 
    private BufferedReader x;
    private StringTokenizer st;
    
    public Reader(InputStream in)
    {
        x = new BufferedReader(new InputStreamReader(in));
        st = null;
    }
    public String nextString() throws IOException
    {
        while( st==null || !st.hasMoreTokens() )
            st = new StringTokenizer(x.readLine());
        return st.nextToken();
    }
    public int nextInt() throws IOException
    {
        return Integer.parseInt(nextString());
    }
    public int[] nextIntArray(int size) throws IOException{
    	int r[] = new int[size];
    	for (int i = 0; i < size; i++) {
			r[i] = this.nextInt(); 
		}
    	return r;
    }
    public long[] nextLongArray(int size) throws IOException{
    	long r[] = new long[size];
    	for (int i = 0; i < size; i++) {
			r[i] = this.nextLong(); 
		}
    	return r;
    }
    public long nextLong() throws IOException
    {
        return Long.parseLong(nextString());
    }
    public double nextDouble() throws IOException
    {
        return Double.parseDouble(nextString());
    }
}
//  [java]
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.stream.IntStream;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        B solver = new B();
        solver.solve(1, in, out);
        out.close();
    }

    static class B {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            String S = in.next();
            long len = S.length();
            long count = S.chars().filter(c -> c == 'x').count();
            out.println(8 <= (15 - len) + (len - count) ? "YES" : "NO");
        }

    }
}
//  [java]
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String S = sc.next();
        long count = S.chars().filter(ch -> ch == 'x').count();
        System.out.println(count >= 8 ? "NO" : "YES");
    }

}
//  [java]
import java.util.ArrayList;
        import java.util.List;
        import java.util.Scanner;
        import java.util.function.Consumer;

public class Main {
    private static final Scanner scanner = new Scanner(System.in);
    private static final Consumer<List<String>> consumer = solve();

    public static void main(String[] args) {
        consumer.accept(readInput());
    }

    private static List<String> readInput() {
        final List<String> lineList = new ArrayList<>();
        while (scanner.hasNextLine()) {
            lineList.add(scanner.nextLine());
        }
        return lineList;
    }

    private static Consumer<List<String>> solve() {
        return args -> {
            int k = args.get(0).length();
            long w = args.get(0).codePoints().filter(i -> (char) i == 'o').count();
            boolean cond = w + 15 - k >= 8;
            System.out.println(cond ? "YES" : "NO");
        };
    }

}
//  [cpp]
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <iterator>
#include <cmath>
#include <set>
#include <deque> 

using namespace std;

int k;
char s[30];

int main()
{
	scanf("%s", s);
	
	//xoxoxoxoxoxox
	k = strlen(s);
	int wins = 0;
	int losts = 0;
	int total;
	for (int i = 0 ; i < k ; i++)
	{
		if (s[i] == 'o')
			wins++;
		else
			losts++;
	}
	
	total = wins + losts;
	int left = 15 - total;
	
	if ((left + wins) >= 8)
		printf("YES\n");
	else
		printf("NO\n");
	
	return 0;
}
//  [cpp]
#include<cstdio>
#include<cstring> 
using namespace std;
int cnt;
char s1[20];
int main(){
	scanf("%s",&s1);
	for(int i=0;i<strlen(s1);i++){
		if(s1[i]=='o') cnt++;
	}
	cnt+=15-strlen(s1);
	if(cnt>=8) printf("YES");
	else printf("NO");
}
//  [cpp]
#include<stdio.h>
#include<string.h>
int main(void)
{
  char s[16];
  int i,co=0,len;
  scanf("%s",s);
  len=strlen(s);
  for(i=0;i<len;i++){
    if(s[i]=='x'){
      co++;
    }
  }
  if(co>=8){
    printf("NO");
  }
  else{
    printf("YES");
  }
  return 0;
}
//  [cpp]
//Utkarsh.25dec
#include <bits/stdc++.h>
#include <chrono>
#include <random>
#define ll long long int
#define ull unsigned long long int
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define rep(i,n) for(ll i=0;i<n;i++)
#define loop(i,a,b) for(ll i=a;i<=b;i++)
#define vi vector <int>
#define vs vector <string>
#define vc vector <char>
#define vl vector <ll>
#define all(c) (c).begin(),(c).end()
#define max3(a,b,c) max(max(a,b),c)
#define min3(a,b,c) min(min(a,b),c)
#define deb(x) cerr<<#x<<' '<<'='<<' '<<x<<'\n'
using namespace std;
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds; 
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
// ordered_set s ; s.order_of_key(val)  no. of elements strictly less than val
// s.find_by_order(i)  itertor to ith element (0 indexed)
typedef vector<vector<ll>> matrix;
ll power(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll modInverse(ll a){return power(a,mod-2);}
const int N=500023;
bool vis[N];
vector <int> adj[N];
void solve()
{
    string s;   
    cin>>s;
    int cnt=0;
    for(auto ch:s)
    {
        if(ch=='o')
            cnt++;
    }
    cnt+=(15-s.length());
    if(cnt>=8)
        cout<<"YES\n";
    else
        cout<<"NO\n";
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int T=1;
    //cin>>T;
    int t=0;
    while(t++<T)
    {
        //cout<<"Case #"<<t<<":"<<' ';
        solve();
        //cout<<'\n';
    }
    cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main(){
  string s;
  cin>>s;
  int k=s.length(),win=0;
  for(int i=0;i<k;i++){
	if(s[i]=='o'){
      win++;
    }
  }
  win+=15-k;
  if(win>=8){
    cout<<"YES\n";
  }
  else{
    cout<<"NO\n";
  }
  return 0;
}
//  [cpp]
#include <iostream>
//#include <iomanip>
#include <string>
//#include <vector>
//#include <algorithm>
//#include <utility>
//#include <set>
//#include <map>
//#include <queue>
//#include <bitset>
//#include <math.h>
using namespace std ;
//using ll = long long ;
//using ld = long double ;
//using vll = vector<ll> ;
//using vvll = vector<vll> ;
//using vc = vector<char> ;
//using vvc = vector<vc> ;
//using vb = vector<bool> ;
//using vvb = vector<vb> ;
//using pll = pair<ll,ll> ;

//ll mod = 1000000007 ;
//long double pie = acos(-1) ;

//string yorn(bool a){if(a) return"Yes" ; return "No" ;}
string YorN(bool a){if(a) return"YES" ; return "NO" ;}
//ll gcd(long long a,long long b){if(b==0) return a ; return gcd(b,a%b) ;}
//ll lcm(long long a,long long b){return a/gcd(a,b)*b ;}
//ll sa(long long a,long long b){if(a>b) return a-b ; return b-a ;}
//void mysort(vector<long long> &a){sort(a.begin(),a.end()) ;}
//void myrev(vector<long long> &a){reverse(a.begin(),a.end()) ;}

int main(){
	string s ; cin >> s ;
	int cnt = 0 ;
	for(int i=0;i<s.size();i++) if(s.at(i)=='x') cnt++ ;
	cout << YorN(cnt<=7) << endl ;
}
//  [c]
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

#define pai 3.1415926535

int main(void) {
	char S[16];
	scanf("%s", S);

	int count = 0;
	for (int i = 0; i < strlen(S); i++) {
		if (S[i] == 'x') {
			count++;
		}
	}

	if (15-count>=8 ) {
		printf("YES\n");
	}
	else {
		printf("NO\n");
	}


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

int main(){
	char games[15];
  	int i; //loop
  
  	int win;
  	int lose;
  
  scanf("%s",games);
  
  for(i=0;i<sizeof(games);i++){
  	if(games[i] == 'x') lose++;
  }

  
  if(lose<=7) printf("YES");
  else printf("NO");
 
  return 0;
  
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(void){

  char s[16];
  scanf("%s", s);
  int k = strlen(s);
  int lose = 0;
  for (int i = 0; i < k; i++) {
    if (s[i] == 'x') {
      lose++;
    }
  }
  if (lose < 8) {
    printf("YES\n");
  } else {
    printf("NO\n");
  }

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

int main (void)
{
    int cnt=0;
    char s[15];
    scanf("%s",s);
    for(int i=0;i<strlen(s);i++)
    {
        if(s[i]=='x')
        {
            cnt++;
        }
    }
    if(cnt>7)
    {
        puts("NO");
    }else{
        puts("YES");
    }
    return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	char S[32];
	int make = 0;
	int i;
	if (scanf("%31s", S) != 1) return 1;
	for (i = 0; S[i] != '\0'; i++) {
		if (S[i] == 'x') make++;
	}
	puts(make < 8 ? "YES" : "NO");
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(){
  int k,c=0;
  char S[20];
  scanf("%s",S);
  k=strlen(S);
  for(int i=0;i<k;i++)
    if(S[i]=='o') c++;
  if((15-k)+c>=8) printf("YES\n");
  else printf("NO\n");
  return 0;
}
//  [javascript]
function Main(input) {
	input += "ooooooooooooooo"
	input = input.split("");
	var sum = 0;
	for(var i=0;i<15;i++){
		if(input[i]=="o") sum++;
	}
	console.log(sum>=8?"YES":"NO")
}Main(require("fs").readFileSync("/dev/stdin", "utf8").trim());
//  [javascript]
"use strict";
    
const main = arg => {
    arg = arg.trim().split("\n");
    const S = arg[0].split("");
    
    const win  = S.filter(n=>n==="o").length;
    const rest = 15 - S.length;
    
    console.log((rest + win) >= 8 ? "YES" : "NO");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
'use strict';(function(input){
  input=input.trim().split('').reduce((a,c)=>a+(c==='x'?1:0),0);
  var ans=((input<=7)?'YES':'NO');
  console.log(ans);
})(require('fs').readFileSync('/dev/stdin','utf8'));
//  [javascript]


function Main(input) {
  input = input.split("\n");
  var S = input[0].split("");
  var c=0;
  for(var i=0;i<S.length;i++){
    if(S[i]=="x"){
      c++;
    }
  }
  var ans="NO";
  if(c<=7){
    ans="YES";
  }

  console.log('%s', ans);
  return ans;
}

function debug(n){
  var input = document.getElementById("input"+n).value;
  var ans=Main(input);
  var result="WA";
  if(ans==document.getElementById("output"+n).value.split("\n")[0]){
    result="AC";
  }
  document.getElementById("result"+n).innerHTML=result;
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
var GET=(function(){function f(s){return new g(s);}function g(s){this._s=s.trim().split("\n");this._y=0;}g.prototype.a=function(f){var s=this._s, y=this._y, r;if(typeof s[y]==="string")s[y]=s[y].split(" ").reverse();r=s[y].pop();if(!s[y].length)this._y++;return f?r:+r;};g.prototype.l=function(f){var s=this._s[this._y++].split(" ");return f?s:s.map(a=>+a);};g.prototype.m=function(n,f){var r=this._s.slice(this._y,this._y+=n).map(a=>a.split(" "));return f?r:r.map(a=>a.map(a=>+a));};g.prototype.r=function(n,f){var r=this._s.slice(this._y,this._y+=n);return f?r:r.map(a=>+a);};return f;})();
var o=GET(require("fs").readFileSync("/dev/stdin","utf8"));
function xArray(v){var a=arguments,l=a.length,r="Array(a["+--l+"]).fill(0).map(x=>{return "+v+";})";while(--l)r="Array(a["+l+"]).fill(0).map(x=>"+r+")";return eval(r);}

console.log(main());
function main(){
  var s = o.a(1);
  var ans = 0;
  for(var i = 0; i < s.length; i++){
    if(s[i] === "x")ans++;
  }
  return ans>7?"NO":"YES";
}
//  [go]
package main

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

func getScanner(fp *os.File) *bufio.Scanner {
	scanner := bufio.NewScanner(fp)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1000005), 1000005)
	return scanner
}

func getNextString(scanner *bufio.Scanner) string {
	scanner.Scan()
	return scanner.Text()
}

func getNextInt(scanner *bufio.Scanner) int {
	i, _ := strconv.Atoi(getNextString(scanner))
	return i
}

func getNextInt64(scanner *bufio.Scanner) int64 {
	i, _ := strconv.ParseInt(getNextString(scanner), 10, 64)
	return i
}

func getNextUint64(scanner *bufio.Scanner) uint64 {
	i, _ := strconv.ParseUint(getNextString(scanner), 10, 64)
	return i
}

func getNextFloat64(scanner *bufio.Scanner) float64 {
	i, _ := strconv.ParseFloat(getNextString(scanner), 64)
	return i
}

func main() {
	fp := os.Stdin
	wfp := os.Stdout
	cnt := 0

	if os.Getenv("MASPY") == "ますピ" {
		fp, _ = os.Open(os.Getenv("BEET_THE_HARMONY_OF_PERFECT"))
		cnt = 1
	}
	if os.Getenv("MASPYPY") == "ますピッピ" {
		wfp, _ = os.Create(os.Getenv("NGTKANA_IS_GENIUS10"))
	}

	scanner := getScanner(fp)
	writer := bufio.NewWriter(wfp)
	solve(scanner, writer)
	for i := 0; i < cnt; i++ {
		fmt.Fprintln(writer, "-----------------------------------")
		solve(scanner, writer)
	}
	writer.Flush()
}

func solve(scanner *bufio.Scanner, writer *bufio.Writer) {
	s := getNextString(scanner)
	k := len(s)
	m := map[byte]int{}
	for i := 0; i < 15; i++ {
		if i < k {
			m[s[i]] = m[s[i]] + 1
			continue
		}
		m['o'] = m['o'] + 1
	}
	if m['o'] >= 8 {
		fmt.Fprintln(writer, "YES")
		return
	}
	fmt.Fprintln(writer, "NO")
}
//  [go]
package main

import (
       "fmt"
       "strings"
)

func main(){
     var s string
     fmt.Scan(&s)
     lose := strings.Count(s, "x")
     if lose >= 8 {
     fmt.Println("NO")
     }else{
     fmt.Println("YES")
     }
}
//  [go]
package main

import "fmt"

func main() {
	var s string
	fmt.Scan(&s)

	cnt := 0
	for _, r := range s {
		if r == 'x' {
			cnt++
		}
	}
	if cnt >= 8 {
		fmt.Println("NO")
	} else {
		fmt.Println("YES")
	}
}
//  [go]
package main

import "fmt"

func main() {
	// Code for B - Sumo
	var S string
	fmt.Scanf("%s", &S)

	ans := make(map[string]int, 2)
	for i := 0; i < len(S); i++ {
		ans[S[i:i+1]]++
	}

	if ans["o"]+(15-len(S)) >= 8 {
		fmt.Println("YES")
	} else {
		fmt.Println("NO")
	}
}
//  [ruby]
s=gets.chomp
n=s.count("o")
if 8<=15-s.size+n
  puts "YES"
else
  puts "NO"
end
//  [ruby]
s = gets.chomp
w = s.count("o")
k = s.size
puts (w >= 8 || 8 - w <= 15 - k)? "YES" : "NO"
//  [ruby]
s = gets.chomp

puts s.count('o') + 15-s.size >= 8 ? 'YES' : 'NO'
//  [ruby]
s = gets.chomp
num =  s.count('o')
x = 15 - s.length
puts num+x>=8 ? "YES" : "NO"
//  [ruby]
s = gets.chomp
k = s.size
puts (15-k + s.count(?o) >= 8 ? "YES" : "NO")
//  [ruby]
puts gets.chomp.count("x") < 8 ? "YES": "NO"
//  [rust]
use std::io::*; //Not mine.
use std::str::FromStr;
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}
fn main() {
    let s: String = read();
    println!(
        "{}",
        if s.chars().filter(|&c| c == 'o').count() + 15 - s.len() >= 8 {
            "YES"
        } else {
            "NO"
        }
    );
}
//  [rust]
#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
use std::io::*;
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::*;

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);

impl<T: PartialEq> Eq for Total<T> {}

impl<T: PartialOrd> Ord for Total<T> {
    fn cmp(&self, other: &Total<T>) -> std::cmp::Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}

//const MAX:usize = 100006;
//const INF:u64 = u64::max_value();

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

    for _ in 0..15-s.len() {
        s.push('o');
    }
    println!("{}", if s.iter().filter(|&x| *x=='o').count() > 7 {"YES"} else {"NO"});
}
//  [rust]
use std::str::FromStr;
use std::fmt::Debug;
use std::cmp;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where T: FromStr, <T as FromStr>::Err : Debug{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().split_whitespace().map(|c| T::from_str(c).unwrap()).collect()

}

#[allow(dead_code)]
fn read_as_string() -> String{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn main(){
    let s = read_as_string();
    let k = s.len();

    if s.chars().filter(|x| *x == 'o').count() + 15 - k >= 8{
        println!("YES");
    }else{
        println!("NO");
    }
}
//  [rust]
#![allow(unused_imports)]

use text_io::*;
use proconio::*;
use std::collections::*;
use itertools::Itertools;
use std::process::exit;
use std::cmp::*;
use num::*;
use num::integer::Roots;

fn main() {
    input! {
    a:String,
    }
    let a=a.chars().collect_vec();
    let mut b=0;
    for i in 0..a.len(){
        if a[i]=='x'{
            b+=1
        }
    }
    println!("{}",if b>7{"NO"}else{"YES"})
}
//  [rust]
#![allow(unused_macros)]
#![allow(dead_code)]
#![allow(unused_imports)]

use text_io::*;

const U_INF: usize = 1 << 60;
const I_INF: isize = 1 << 60;

fn main() {
    let s: String = read!();
    let len = s.chars().count();
    let s = s.chars().filter(|&c| c == 'o').count() + 15 - len;
    let ans = if s >= 8 { "YES" } else { "NO" };
    println!("{}", ans);
}
//  [swift]
print(readLine()!.characters.reduce(0){$0+(String($1)=="x" ?1:0)}<8 ?"YES":"NO")
//  [swift]
var arr=readLine()!.characters.split{$0==" "}.map{(String($0))}

var win : Int = 0
for character in arr[0].characters {
	if( character == "o" ) {
      win += 1
    }
}

( ( 15 - arr[0].characters.count + win ) >= 8 ) ? print( "YES" ) : print( "NO" )
//  [swift]
import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
func exponentiate(_ lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension Array where Element == String {
//    func joined(separator separator: String) -> String {
//        return self.joinWithSeparator(separator)
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element? {
        return self.maxElement()
    }
    func min() -> Element? {
        return self.minElement()
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
//    func enumerated() -> [(Int, Element)] {
//        return self.enumerate()
//    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
func exponentiate(lhs: Int, _ rhs: Int) -> Int {
    return (0..<rhs).reduce(1){i,_ in i*lhs}
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}
//func gcd(x: Int, _ y: Int) -> Int {
//    if y == 0 {
//        return x
//    } else {
//        return gcd(y, x%y)
//    }
//}
//func lcm(x: Int, _ y: Int) -> Int {
//    return x * y / gcd(x, y)
//}

/*************** テストスペース ***************/



/*************** メインプログラム ***************/

let S = readLine()!.toArray()
let k = 15 - S.count
var oCnt = 0
for c in S {
    if String(c) == "o" {
        oCnt += 1
    }
}
print(oCnt+k >= 8 ? "YES" : "NO")
//  [typescript]
function main(input) {
	const str = input.trim();
  	let cnt = 0;
  	for (const char of str) {
    	if (char === "x") {
        	cnt++;
        }
    }
  	let result = "YES";
  	if (8 <= cnt) {
    	result = "NO";
    }
	console.log(result);
}
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [typescript]
class NormalInput{
  input: string[];
  pointer: number;
  constructor(raw:string){
    this.input=raw.split(/ |\n/);
    this.pointer=0;
  }
  int():number{
    const ret= parseInt(this.input[this.pointer], 10);
    this.pointer++;
    return ret;
  }
  str():string{
    const ret= this.input[this.pointer];
    this.pointer++;
    return ret;
  }
  strs(length:number):string[]{
    let ret:string[]=[];
    for(let i=0;i<length;i++){
      ret.push(this.str());
    }
    return ret;
  }
  ints(length:number):number[]{
    let ret:number[]=[];
    for(let i=0;i<length;i++){
      ret.push(this.int());
    }
    return ret;
  }
}

function Main(_: NormalInput) {
  const S=_.str();
  let count=0;
  for(let c of S){
    if(c=='x')count++;
  }
  console.log((count>=8)?"NO":"YES");
}

//DO NOT EDIT
Main(new NormalInput(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [python]
# dp[i][j]:=(総和がiで長さがjの数列の個数)とする
# このままだとO(s^3)だが、全てのｊに対してΣ(k=0→i-3)dp[k][j]をあらかじめ持っておけばO(s^2)となる
# dpの遷移式立てたときはちゃんと紙に書いて眺めなきゃ（使命感）
s=int(input())
mod=10**9+7
dp=[[0]*(s+1) for _ in range(s+1)]
accum=[0]*(s+1)
dp[0][0]=1
for i in range(3,s+1):
    for j in range(s):
        accum[j]+=dp[i-3][j]
        dp[i][j+1]+=accum[j]
        dp[i][j+1]%=mod
print(sum(dp[s])%mod)
//  [python]
from __future__ import print_function

from functools import reduce
from operator import mul
from collections import Counter
from collections import deque
from itertools import accumulate
from queue import Queue
from queue import PriorityQueue as pq
from heapq import heapreplace
from heapq import heapify
from heapq import heappushpop
from heapq import heappop
from heapq import heappush
import heapq
import time
import random
import bisect
import itertools
import collections
from fractions import Fraction
import fractions
import string
import math
import operator
import functools
import copy
import array
import re
import sys
sys.setrecursionlimit(500000)


input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return

# from fractions import gcd
# from math import gcd

# def lcm(n, m):
#     return int(n * m / gcd(n, m))


# def coprimize(p, q):
#     common = gcd(p, q)
#     return (p // common, q // common)


# def find_gcd(list_l):
#     x = reduce(gcd, list_l)
#     return x


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


mod = 1000000007


def combinations_count_mod(n, r):
    r = min(r, n - r)
    numer = reduce(lambda x, y: x * y % mod, range(n, n - r, -1), 1)
    denom = pow(reduce(lambda x, y: x * y % mod, range(1, r + 1), 1), mod - 2, mod)
    return numer * denom % mod


def solve():
    pass


def main():
    S = int(input().strip())
    if S<3:
        print(0)
        return
    dp = [0 for i in range(S + 1)]
    dp[0] = 0
    dp[1] = 0
    dp[2] = 0
    dp[3] = 1
    for i in range(4, S + 1):   # dp[i]は，「和がiになるような数列の個数」
        for j in range(3, i):
            dp[i] = (dp[i] + dp[i - j]) % mod
        dp[i] += 1

    print(dp[S])
    # eprint('dp ', end=':\n')
    # eprint(dp)


if __name__ == '__main__':
    main()
//  [python]
n = int(input())
dic = {}
def fun(n):
    result = 1
    if n == 3 or n == 4 or n == 5:
        return 1
    if n in dic:
        return dic[n]
    for i in range(3, n-2):
        result += fun(i)
        dic[i] = fun(i)
    return result


result = fun(n) % (10 ** 9 + 7)
if n < 3:
	print(0)
else:
	print(result)