jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        if(x < 100) {
            System.out.println(0);
            return;
        }
        String xx = Integer.toString(x);
        xx = xx.substring(xx.length() -2, xx.length());
        x = Integer.parseInt(xx);
        ArrayList<Integer> list = new ArrayList<>
            (Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
        if(list.contains(Integer.valueOf(x))) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
    }
}
//  [java]
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        if(x < 100) {
            System.out.println(0);
        }
        String xx = Integer.toString(x);
        xx = xx.substring(xx.length() -2, xx.length());
        x = Integer.parseInt(xx);
        ArrayList<Integer> list = new ArrayList<>
            (Arrays.asList(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
        if(list.contains(Integer.valueOf(x))) {
            System.out.println(1);
        } else {
            System.out.println(0);
        }
    }
}
//  [cpp]
#include <iostream>
#include <cstring>
#include <map>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <set>
#include <vector>
#include <queue>
#include <list>
#include <numeric>
#include <stdio.h>
#include <string>
#include <cstdlib>
#include <math.h>
#include <stack>
#include <climits>
#include <bitset>
#include <utility>


using namespace std;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
// const ll INF = 1LL <<60;
// const int INF = 10000;

//最大公約数
ll gcd(ll x, ll y) {
  ll tmp = 0;
  if (x < y){
    tmp=x;
    x=y;
    y=tmp;
  }
  while (y > 0) {
    ll r = x % y;
    x = y;
    y = r;
  }
  return x;
}

//最大公倍数
ll lcm(ll x,ll y){
  return x/gcd(x,y)*y;
}

const int MAX = 1e6+1;
const int MOD = 1e9+7;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
long long COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}


//階乗
ll kaijo(ll k){
    ll sum = 1;
    for (ll i = 1; i <= k; ++i)
    {
        sum *= i;
        sum%=1000000000+7;
    }
    return sum;
}

//for(int i = ; i < ; i++){}

ll lmax(ll s,ll t){
  if(s>t){
    return s;
  }
  else{
    return t;
  }
}

ll lmin(ll s,ll t){
  if(s<t){
    return s;
  }
  else{
    return t;
  }
}

long long modpow(long long res,long long a, long long n, long long mod) {
    while (n > 0) {
        if (n & 1) res = res * a % mod;
        a = a * a % mod;
        n >>= 1;
    }
    return res;
}

//sieve(MAX);でベクトルIsPrimeに「MAXまでの数値の素数の真偽」を格納する。
vector<bool> IsPrime;
void sieve(size_t max){
    if(max+1 > IsPrime.size()){     // resizeで要素数が減らないように
        IsPrime.resize(max+1,true); // IsPrimeに必要な要素数を確保
    } 
    IsPrime[0] = false; // 0は素数ではない
    IsPrime[1] = false; // 1は素数ではない

    for(size_t i=2; i*i<=max; ++i) // 0からsqrt(max)まで調べる
        if(IsPrime[i]) // iが素数ならば
            for(size_t j=2; i*j<=max; ++j) // (max以下の)iの倍数は
                IsPrime[i*j] = false;      // 素数ではない
}
// ここから開始

int main(){
    int x;
    cin>>x;
    int n = x/100;//回数
    int r = x%100;//余り
    int ansflg = 1;
    // 最低限必要な回数
    int count = r/5;
    if(r%5>0) count+=1;
    if(count>n) ansflg = 0;
    cout<<ansflg<<endl;
    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);

    int x; cin >> x;
    int a = x / 100;
    x %= 100;

    for(int i = 0; i <= a; i++){
        for(int j = 0; j <= a - i; j++){
            for(int k = 0; k <= a - i - j; k++){
                for(int l = 0; l <= a - i - j - k; l++){
                    for(int m = 0; m <= a - i - j - k - l; m++){
                        if(i*5 + j*4 + k*3 + l*2 + m == x){
                            cout << 1; return 0;
                        }
                    }
                }
            }
        }
    }cout << 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main() {
	int N;
	cin >> N;
	int m;
	m = N / 100;
	if (N - m * 100 <= 5 * m)
		cout << 1;
	else
		cout << 0;
	return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
  int X;
  cin>>X;
  int q=X%100,p=X/100,count=0;
  for(int i=5;i>0;i--){
    while(q>i){
      q-=i;
      count++;
    }
  }
  if(count<=p)
    cout<<1<<endl;
  else
    cout<<0<<endl;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main(){
  int X;
  cin >> X;
  for(int i=0;i<X;i++){
    int A=i+1;
    if(100*A<=X && A<=105){
      cout << 1 << endl;
      return 0;
    }
  }
  cout << 0 << endl;
}
//  [c]
#include <stdio.h>

int main(){
    int a[1];
    int C;
    int ans;

    if(scanf("%d", &a[0])==1){}

    C = (int)((double)a[0]/100);
    if(100*C <= a[0] && a[0]<=105*C){
        ans = 1;
    }else{
        ans = 0;
    }

    printf("%d\n", ans);

}
//  [c]
#include <stdio.h>
#include <stdlib.h>

int main()
{
	int X;
	scanf("%d", &X);
	
	int x = X / 100;
	if (X / 100 * 5 >= X % 100) printf("1\n");
	else printf("0\n");
	fflush(stdout);
	return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int x;  scanf("%d", &x);
  int ans;
  if(x%100 > (x/100)*5)
    ans = 0;
  else
    ans = 1;

  printf("%d\n", ans);
  return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
	int X;
	int i;
	if (scanf("%d", &X) != 1) return 1;
	for (i = 0; 101 * i <= X; i++) {
		int kitaeri = X - 100 * i;
		if(i <= kitaeri && kitaeri <= 5 * i) {
			puts("1");
			return 0;
		}
	}
	puts("0");
	return 0;
}
//  [c]
#include <stdio.h>
#include <string.h>

int main(){
  int X;
  int c=0;
  scanf("%d",&X);
  int q=X/100;
  int r=X%100;
  if(r<=q*6) c=1;
  printf("%d\n",c);
  return 0;
}
//  [c]
#include<stdio.h>
int main(void)
{
  int x;
  scanf("%d",&x);
  int num=x/100;
  printf("%d\n",num);
  if(x>=num*100&&x<=num*105){
    puts("1");
  }else{
    puts("0");
  }
  return 0;
}
//  [javascript]
function Main(input) {
    const n = input.split("\n")[0];
    var ans = 0 
    for(var i = 1; i <= n; i++){
        if (n >= i * 100 && n <= i* 105) {
            ans = 1
            break;
        }
    }
    console.log(ans)
    }    
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(X) {
var up =  Math.floor(X/100)*5;
var down = X%100
if(up>=down){
  console.log(1);    
}else{
  console.log(0);
}
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
   	var inputArray = input.split("\n");
	var X=inputArray[0];
	
	var amari=X%100;
	var kaisu=0;
	
	for(var i=5;i>=1;i--){
		kaisu=kaisu+parseInt(amari/i);
		amari=amari%i;
		//console.log(i);
	}
	
	if(kaisu<=parseInt(X/100)){
		console.log("1");
	}else{
		console.log("0")
	}
}
     
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
// inputに入力データ全体が入る

function Main(input) {
  for (let a = 100; a <= 105; a++) {
    for (let b = 100; b <= 105; b++) {
      for (let c = 100; c <= 105; c++) {
        for (let d = 100; d <= 105; d++) {
          for (let e = 100; e <= 105; e++) {
            
            if (a + b + c + d + e == input) {
              console.log(1);
              return;
            } else if(e == 105){
              console.log(0);
              return
              
            }
          }
        }
      }
    }
  }
}
//*この行以降は編集しないでください（標準入出力から一度に読み込み、Mainを呼び出します）
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
  input = input.split('\n');
	var n = Number(input[0]);
	var k = Math.floor(n/100);
  if(100*k<=n || n<=105*k){
  console.log('1');
  }else{
  console.log('0');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input) {
	var n = Number(input);
	var k = n/100;
  if(100*k<=n || n<=105*k){
  console.log('1');
  }else{
  console.log('0');
  }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import "fmt"

func main() {
	var x int
	fmt.Scan(&x)

	c := x / 100
	if 100*c <= x && x <= 105*c {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [go]
package main

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

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)

	X := getInt()

	Y := X % 100
	X /= 100
	//out(Y, X)
	if X*5 >= Y {
		out(1)
		return
	}
	out(0)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scan(&x)

	if x < 100 {
		fmt.Println(0)
		return
	}

	last := x % 100

	c5 := 0
	if last/5 > 0 {
		c5 = last / 5
		last %= 5
	}
	c4 := 0
	if last/4 > 0 {
		c4 = last / 4
		last %= 4
	}
	c3 := 0
	if last/3 > 0 {
		c3 = last / 3
		last %= 3
	}
	c2 := 0
	if last/2 > 0 {
		c5 = last / 2
		last %= 2
	}
	c1 := 0
	if last == 1 {
		c1 = 1
	}

	recalc := 0
	recalc += 105 * c5
	recalc += 104 * c4
	recalc += 103 * c3
	recalc += 102 * c2
	recalc += 101 * c1

	if recalc > x {
		fmt.Println(0)
		return
	}

	c0 := (x - recalc) / 100
	recalc += 100 * c0

	if recalc == x {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [go]
package main

import "fmt"

func main() {
	// Code for C - 100 to 105
	var X int
	fmt.Scanf("%d", &X)

	var flag int = 0
	for i := 0; 100*i <= X; i++ {
		for j := 0; 100*i+101*j <= X; j++ {
			for k := 0; 100*i+101*j+102*k <= X; k++ {
				for l := 0; 100*i+101*j+102*k+103*l <= X; l++ {
					for m := 0; 100*i+101*j+102*k+103*l+104*m <= X; m++ {
						for n := 0; 100*i+101*j+102*k+103*l+104*m+105*n <= X; n++ {
							if X == 100*i+101*j+102*k+103*l+104*m+105*n {
								flag = 1
								break
							}
						}
					}
				}
			}
		}
	}

	if flag == 1 {
		fmt.Println("1")
	} else {
		fmt.Println("0")
	}
}
//  [go]
package main

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

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

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

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func main() {
	sc.Split(bufio.ScanWords)

	X := getInt()

	Y := X % 100
	X /= 100
	//out(Y, X)
	if X*5 = Y {
		out(1)
		return
	}
	out(0)
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scan(&x)

	if x < 100 {
		fmt.Println(0)
		return
	}

	last := x % 100

	c5 := 0
	if last/5 > 0 {
		c5 = last / 5
		last %= 5
	}
	c4 := 0
	if last/4 > 0 {
		c4 = last / 4
		last %= 4
	}
	c3 := 0
	if last/3 > 0 {
		c3 = last / 3
		last %= 3
	}
	c2 := 0
	if last/2 > 0 {
		c5 = last / 2
		last %= 2
	}
	c1 := 0
	if last == 1 {
		c1 = 1
	}

	recalc := 0
	recalc += 105 * c5
	recalc += 104 * c4
	recalc += 103 * c3
	recalc += 102 * c2
	recalc += 101 * c1

	c0 := (x - recalc) / 100
	recalc += 100 * c0

	if recalc == x {
		fmt.Println(1)
	} else {
		fmt.Println(0)
	}
}
//  [ruby]
x = gets.chomp.to_i
s = x.to_s

if x < 100
  puts 0
  exit
end

head = s[0...-2].to_i
tail = s[-2..-1].to_i

cnt = (tail / 5.0).ceil

if head >= cnt
  puts 1
else
  puts 0
end
//  [ruby]
x = gets.to_i

if 1.upto(x / 100).any? { |c| 100 * c <= x && x <= 105 * c }
  puts 1
else
  puts 0
end
//  [ruby]
x = gets.to_i
c = x / 100

if 100 * c <= x && x <= 105 * c
  puts 1
else
  puts 0
end
//  [ruby]
x = gets().chomp.to_i

max_cnt = x / 100
base_rem = x % 100

puts base_rem <= 5 * max_cnt ? 'Yes' : 'No'
//  [ruby]
dp = [true]
n = gets.to_i
(1..n).each do |i|
  dp[i] = dp[i-105] || dp[i-104] || dp[i-103] || dp[i-102] || dp[i-101] || dp[i-100]
end
p dp[n] ? 1 : 0
//  [ruby]
dp = [true]
n = gets.to_i
(1..n).each do |i|
  dp[i] = dp[i-105] || dp[i-104] || dp[i-103] || dp[i-102] || dp[i-101]
end
p dp[n] ? 1 : 0
//  [rust]
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
#[allow(unused_imports)]
use std::io::{stderr, stdin, stdout, BufRead, BufWriter, Read, StdoutLock, Write};
#[allow(unused_imports)]
use std::iter::FromIterator;
#[allow(unused_imports)]
use std::{i64, u64, usize};
#[allow(unused_macros)]
/// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules !input {(source =$s :expr ,$($r :tt ) *) =>{let mut iter =$s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;($($r :tt ) *) =>{let mut s ={use std ::io ::Read ;let mut s =String ::new () ;std ::io ::stdin () .read_to_string (&mut s ) .unwrap () ;s } ;let mut iter =s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;}
#[allow(unused_macros)]
macro_rules !input_inner {($iter :expr ) =>{} ;($iter :expr ,) =>{} ;($iter :expr ,$var :ident :$t :tt $($r :tt ) *) =>{let $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;}
#[allow(unused_macros)]
macro_rules !read_value {($iter :expr ,($($t :tt ) ,*) ) =>{($(read_value !($iter ,$t ) ) ,*) } ;($iter :expr ,[$t :tt ;$len :expr ] ) =>{(0 ..$len ) .map (|_ |read_value !($iter ,$t ) ) .collect ::<Vec <_ >>() } ;($iter :expr ,chars ) =>{read_value !($iter ,String ) .chars () .collect ::<Vec <char >>() } ;($iter :expr ,usize1 ) =>{read_value !($iter ,usize ) -1 } ;($iter :expr ,$t :ty ) =>{$iter .next () .unwrap () .parse ::<$t >() .expect ("Parse error" ) } ;}
#[allow(unused_macros)]
macro_rules !dbg {($($a :expr ) ,*) =>{writeln !(&mut stderr () ,concat !($(stringify !($a ) ," = {:?}, " ) ,*) ,$($a ) ,*) .unwrap () ;} }
#[allow(non_snake_case)]
#[allow(dead_code)]
fn main() {
    input! {
        x: u64
    }
    let div100 = x / 100;
    if x % 100 <= div100 * 5 {
        println!("1");
    } else {
        println!("0");
    }
}
//  [rust]
use std::cmp::*;
use std::io::*;
use std::num::*;
use std::str::*;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let s = stdin
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}

fn string() -> String {
    read()
}

fn int() -> i64 {
    read()
}

fn char() -> char {
    read::<String>().pop().unwrap()
}

fn vecchar() -> Vec<char> {
    string().chars().collect()
}

fn vecint(n: i64) -> Vec<i64> {
    let mut vec = Vec::new();
    for i in 0..n {
        vec.push(int())
    }
    vec
}

fn main() {
    let x = int();
    let c = (x + 104) / 105;
    let sum = 105 * c;
    println!("{}", if sum - c * 5 <= x { "1" } else { "0" });
}
//  [rust]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_imports)]
use std::io::{stdout, Write, BufWriter};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
//#[allow(unused_imports)]
//use proconio::marker::{Isize1, Usize1, Bytes, Chars};

//#[proconio::fastout]

fn main() {
    input!{
        x: i32,
    }
    if ((x % 100) + 4) / 5 > x / 100 {
        println!("0");
    } else { println!("1"); }
}
//  [rust]
use proconio::{fastout, input};

#[allow(unused_mut)]
#[fastout]
fn main() {
    input! {
        x: usize
    }
    let num = x / 100;
    let x = x % 100;
    let mut res = false;
    solve(0, x, num, &mut res);
    println!("{}", if res { 1 } else { 0 });
}

fn solve(sum: usize, target: usize, time: usize, can: &mut bool) {
    if time == 0 {
        if target == sum {
            *can = true;
        }
        return;
    }

    solve(sum, target, time - 1, can);
    solve(sum + 1, target, time - 1, can);
    solve(sum + 2, target, time - 1, can);
    solve(sum + 3, target, time - 1, can);
    solve(sum + 4, target, time - 1, can);
    solve(sum + 5, target, time - 1, can);
}
//  [rust]
use whiteread::parse_line;

fn calc(n: usize, dp: &mut Vec<bool>, price: &[usize; 6]) -> bool {
    if !dp[n] && n > 105 {
        for &p in price {
            if dp[n] {
                break;
            }
            dp[n] = dp[n] | calc(n - p, dp, price);
        }
    }
    dp[n]
}

fn main() {
    let x: usize = parse_line().unwrap();
    let price: [usize; 6] = [100, 101, 102, 103, 104, 105];
    let mut dp: Vec<bool> = vec![false; x + 1];

    dp[0] = true;
    for &p in &price {
        let mut idx = 0;
        while idx <= x {
            dp[idx] = true;
            idx += p;
        }
    }

    calc(x, &mut dp, &price);
    if dp[x] {
        println!("1");
    } else {
        println!("0");
    }
}
//  [rust]
use whiteread::parse_line;

fn calc(n: usize, dp: &mut Vec<bool>, price: &[usize; 6]) -> bool {
    if !dp[n] && n > 105 {
        for &p in price {
            if dp[n] {
                break;
            }
            dp[n] = dp[n] || calc(n - p, dp, price);
        }
    }
    dp[n]
}

fn main() {
    let x: usize = parse_line().unwrap();
    let price: [usize; 6] = [100, 101, 102, 103, 104, 105];
    let mut dp: Vec<bool> = vec![false; x + 1];

    dp[0] = true;
    for &p in &price {
        dp[p] = true;
    }

    calc(x, &mut dp, &price);
    if dp[x] {
        println!("1");
    } else {
        println!("0");
    }
}
//  [swift]
import CoreFoundation
let n=Int(readLine()!)!

if n < 100  {
  print("0")
  exit(0)
}

var min =  ( n / 100 ) * 100 
var max =  min + ( ( n / 100 ) * 5 )

if( n <= max ) {
  print("1")
} else {
  print("0")
}
//  [swift]
var N : Int = (Int)(readLine()!)!
let data : [Int]  = [100,101,102,103,104,105]
let size = 1000000 + 1;
var dp = [Int](count: size, repeatedValue: -1)
dp[0] = 0;

for idx in 0..<size{
    if dp[idx] == -1{
        continue;
    }
    for value in data{
        if idx + value  < size {
            dp[idx + value] = 1;
        }
    }
}

if dp[N] == -1 {
    print(0)
} else {
    print(1)
}
//  [swift]
import CoreFoundation
let n=Int(readLine()!)!

if n < 100  {
  print("0")
  exit(0)
}

var min =  ( n / 100 ) * 100 
var max =  min + ( ( n / 100 ) * 5 )

if( ( min >= n ) && ( n <= max ) ) {
  print("1")
} else {
  print("0")
}
//  [typescript]
function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1);
    return;
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

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

const reader = (data: string) =>
  data
    .split('\n')
    .join(' ')
    .split(' ')
    .map(t => parseInt(t, 10))

function Main(input) {
  const [X] = reader(input)
  const num = Math.floor(X / 100)
  const hasuu = X % 100
  if (X < 100) {
    console.log('0')
  } else {
    console.log(hasuu < num * 5 + 1 ? '1' : '0')
  }
}

Main(fs.readFileSync('/dev/stdin', 'utf8'))
//  [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 n=tn()
  if(n<100){
    to(0)
    return
  }
  let ar=String(n).split('')
  let r=Number(ar[ar.length-2]+ar[ar.length-1])
  ar.pop()
  ar.pop()
  let l=Number(ar.join(''))
  to(l*5>=r?1:0)
}
main()
//  [typescript]
function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1);
    return;
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
  //console.log(`X:${X}, num:${num}, h:${hasuu}`)
}

function debug() {
  for (let i = 0 ; i< 2000; i++) {
    main(i.toString();)
  }
}

main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .trim()
);

debug();
//  [typescript]
function main(input: string) {
  const X = parseInt(input);
  if (X >= 2000) { // 2000円以上はどうやったってできる
    console.log(1)
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .trim()
);
//  [typescript]
function main(input: string) {
  const X = parseInt(input);
  if (X >= 2100) { // 2100円以上はどうやったってできる
    console.log(1)
  }
  const num = Math.floor(X / 100); // 個数は上2桁に依存
  const hasuu = X - num * 100; // 端数
  console.log(hasuu / 5 <= num ? 1 : 0);
}

main(
  require("fs")
    .readFileSync("/dev/stdin", "utf8")
    .trim()
);
//  [python]
k = int(input())
print((k // 2 ) *((k + 1) // 2))
//  [python]
k = int(input())
a = k//2
b = k -a

ans = a * b
print(ans)
//  [python]
n=int(input())

even=int(n/2)
if n%2==0:
    odd=even
else:
    odd=even+1

print(odd*even)
//  [python]
n=int(input())
if n%2==0:
    print((n//2)*(n//2+1))
else:
    print((n//2)**2)
//  [python]
n=int(input())
if n%2==0:
    print((n//2)*(n//2+1)
else:
    print((n//2)**2)
//  [python]
s = int(input())
print(s/2 * (s+1)/2)
//  [java]
import java.io.*;
class Main {
 public static void main(String[] args) throws IOException{
	try ( BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ){
		final int target = Integer.parseInt( br.readLine() );
        int result = (target%2 == 0) ? target*target/4 : (target/2+1)*(target/2);
		System.out.println(result);
	}
 }
}
//  [java]
import java.util.Scanner;

public class Pair {

	public static void main(String[] args) {
		Scanner scan= new Scanner(System.in);
		int n=scan.nextInt();
		if(n%2==0) {
			n/=2;
			System.out.println(n*n);
		}
		else {
			int a=n/2;
			System.out.println((a*a)+(n/2));
		}

	}

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

public class Main {

	static Scanner scanner;

	public static void main(String[] args) {
	    scanner = new Scanner(System.in);

	    //int n=gi();
	    int k=gi();
	    
        //System.out.println(n-k+1);
        if (k%2==0) {
        	System.out.print(Math.pow(k/2, 2));
        }else {
        	System.out.print(((k-1)/2) * ((k+1)/2));
        }


	}

	// 文字列として入力を取得
	public static String gs() {
		return scanner.next();
	}

	// intとして入力を取得
	public static int gi() {
		return Integer.parseInt(scanner.next());
	}

	// longとして入力を取得
	public static long gl() {
		return Long.parseLong(scanner.next());
	}

	// doubleとして入力を取得
	public static double gd() {
		return Double.parseDouble(scanner.next());
	}
}
//  [java]
import java.util.*;

public class Main{
  public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    double ans = Math.pow(n/2, 2);
    System.out.println(n%2 == 0 ? ans : ans+(n/2));
  }
}
//  [cpp]
#include <cstdio>
#define rg register
using namespace std;
typedef long long ll;
template <typename Tp> inline int getmin(Tp &x,Tp y){return y<x?x=y,1:0;}
template <typename Tp> inline int getmax(Tp &x,Tp y){return y>x?x=y,1:0;}
template <typename Tp> inline void read(Tp &x)
{
	x=0;int f=0;char ch=getchar();
	while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
	if(ch=='-') f=1,ch=getchar();
	while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
	if(f) x=-x;
}
int n;
int main()
{
	read(n);
	printf("%d\n",(n>>1)*(n-(n>>1)));
	return 0;
}
//  [cpp]
#include<iostream>
using namespace std;

int main(){
    int K;
    int ans=0;
    cin >> K;
    if(K % 2 == 0){
        ans = (K / 2) * (K / 2);
    }else{
        ans = ((K-1) / 2) * ((K+1) / 2);
    }
    cout << ans << endl;
}
//  [cpp]
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>

using namespace std;
typedef long long ll;

int main(){
  int k;cin>>k;
  int x=0;

  for(int i=1; i<=k; i++){
    for(int j=i+1; j<=k; j=j+2){
      x++;
    }
  }
  cout<<x<<endl;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
 
int b, jawaban;
 
int main(){
	cin>>b;
	jawaban=b/2;
	b=(b+1)/2;
	cout<<b*ans<<endl;
}
//  [cpp]
#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>;
#define chmax(x,y) x = max(x,y);
#define chmin(x,y) x = min(x,y);
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
const int INF = 1001001001;



int main() {
    int k;
    cin >> k;
    int ans = 0;
    if (k%2) {
        ans = (k/2) * (k/2);
    }
    else {
        ans = (k/2) * (k/2+1);
    }
    cout << ans << endl;
    return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{
  int k;
  cin>>k;
  double l=k/2;
  if(k%2==0){
    cout<<l*l;
  }
  else{
    double a=l+0.5,b=l-0.5;
    cout<<a*b;
  }
}
//  [c]
#include<stdio.h>
int main(){
  int k;
  scanf("%d",&k);
  printf("%d\n",k/2*(k/2+k%2));
  return 0;
}
//  [c]
#include <stdio.h>

int main(int argc, const char * argv[]) {
    int N;
    scanf("%d", &N);
    
    if(N % 2 == 0){
        printf("%d\n", (N / 2) * (N / 2));
    }else{
        printf("%d\n", (N / 2) * (N / 2 + 1));
    }
    return 0;
}
//  [c]
#include<stdio.h>
int main()
{
    int d;
int a;
    scanf("%d", &d);
if(d % 2 == 1) {
 a = d/2 * (d/2+1);
} else {
a = d/2 * d/2;
}
    printf("%d\n", a);
    return 0;
}
//  [c]
#include<stdio.h>
int main(){
  int a;
  scanf("%d",&a);
  printf("%d", (a/2)*(a+1)/2);
  return 0;
}
//  [c]
#include<stdio.h>
using namespace std ;
int main()
{
int a , b , c , d ;
scanf (”%d%d%d%d ” , &a , &b , &c , &d ) ;
int x = c − a , y = d − b ;
printf (”%d %d %d %d\n ” , c − y , d + x , a − y , b + x ) ;
}
//  [c]
#include<stdio.h>
int main()
{
int n;
  scanf("%d",&n);
  
  if(n%2==0) printf("%d",(n/2)*(n/2));
  else printf("%d",(n+1/2)*(n-1/2));

return 0;}
//  [javascript]
function Main(input){
var K = input.trim();
K =parseInt(K,10);
var a,b;
if(K%2==1){
  a = Math.floor(K/2);
  b = K - a;
  console.log(a*b);
}else{
  console.log((K*K)/4);
}
}
  Main(require('fs').readFileSync('/dev/stdin','utf8'));
//  [javascript]
inp = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')
K = inp.shift() * 1
console.log(K % 2 ? Math.floor(K / 2) * Math.ceil(K / 2) : Math.pow(K / 2, 2))
//  [javascript]
function Main(input){
	input = ~~input;
  var i = input/2;
  return Math.floor(i)*Math.ceil(i);
}

// If you are interested in the algorithms I used, 
// there is no need to read down from this line.

((b,c,d)=>"undefined"!=typeof require?console.log(Main(require("fs").readFileSync("/dev/stdin","utf8"))):[b=b.split("\n").slice(1,-1).join("\n"),c=function(){try{return Main(b)}catch(f){return f.stack||f.message}}(),d=typeof c,"string"==d||(c=JSON.stringify(c)),$("<form>").append([[10,b],0,[1,d],0,[10,c]].map(f=>$(f?"<textarea>":"<br>",f&&{rows:f[0],cols:40,text:f[1]}))).appendTo("body")])(`
50
`);
//  [javascript]
const main = input => {
  const K = parseInt(input.trim())
  console.log((K / 2) * ((K + 1) / 2)
}
// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
const main = input => {
  const K = parseInt(input.trim())
  if (K % 2 === 0) {
    console.log((K / 2) * (K / 2))
  } else {
    console.log(Math.ceil(K / 2)) * ((K - 1) / 2)
  }
}
// 標準入力
main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict';

const receive = () => require('fs').readFileSync('/dev/stdin', 'utf8').split(/\s/);

const main = input => {
  const K = Number(input[0]);
  const ans = K % 2 == 0 ? (K / 2) ** 2 : (K - 1) / 2 * ((K - 1) / 2 + 1)
  console.log(ans);
};

main(receive());
//  [go]
package main

import (
  "fmt"
)

func main() {
  var k int
  fmt.Scan(&k)
  x := k / 2
  fmt.Println(x * (k - x))
}
//  [go]
package main

import "fmt"

func main(){
  s:= [][]int{}
  n :=0
var k int
  fmt.Scanf("%d",&k)
  
  for i:=1; i<k;i++{
    for  j:=1;j<k;j++ {
      t:=[]int{i,i+j}
      s = append(s,t)
    }
  }
  for _,v :=range s {
    if v[0]%2==0 && v[1]%2==0 {
    } else if v[0]%2 !=0 && v[1]%2 !=0{
    } else {
    n = n+1
    }
  }
  fmt.Println(n)
}
//  [go]
package main

import "fmt"

func main() {
	var k int
	fmt.Scan(&k)

	e := k % 2
	fmt.Println(e * (k - e))
}
//  [go]
package main

import "fmt"

func main() {
	var k int
	fmt.Scan(&k)
	g := k / 2
	if g%2 == 1 {
		fmt.Println(g * (g + 1))
		return
	}
	fmt.Println(g * g)
}
//  [ruby]
K = gets.to_i
odd = 0
even = 0
if K.even? then
    even = odd = K/2
else
    even = K/2
    odd = K/2 + 1
end
puts even * odd
//  [ruby]
k = gets.chomp.to_i
ev = k / 2
od = k-ev
puts ev * od
//  [ruby]
# frozen_string_literal: true

k = gets.to_i

puts (k / 2) * (k - k / 2)
//  [ruby]
p gets.to_i%2==0?($_/2)**2:($_/2)*($_/2+1)
//  [ruby]
p (gets.to_i/2)**2
//  [ruby]
n=gets.to_i
puts n/2*(n+1)/2
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<u32> = procon_read();
	let k = v[0];
	let odd = k/2 + k%2;
	let even = k/2;
	println!("{}", odd*even);
}
//  [rust]
use std::io::Read;

fn main() {
    let mut buf = String::new();

    std::io::stdin().read_to_string(&mut buf).unwrap();

    let mut iter = buf.split_whitespace();
    let k: i32 = iter.next().unwrap().parse().unwrap();
    println!("{}", k / 2 * (k - k/2));
}
//  [rust]
use std::io::*;
use std::str::FromStr;

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

// use std::cmp::{max, min};

fn main() {
  let n = read::<usize>();
  let k = read::<usize>();
  let mut ans = (n / k) * (n / k) * (n / k);
  if k % 2 == 0 {
    let cnt = (n + k / 2) / k;
    ans += cnt * cnt * cnt;
  }
  println!("{}", ans);
}
//  [rust]
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)*}
    };
}

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

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

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, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (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_imports)]
use std::cmp::{min, max};

fn main() {
    input!{
        n: usize
    }
    println!("{}", n / 2 * (n + 1) / 2);
}
//  [rust]
#[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)*}
    };
}

#[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)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[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, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        k: usize,
    }
    let odds = k / 2 + 1;
    let evens = k / 2;
    println!("{}", odds * evens);
}
//  [swift]
var i=Int(readLine()!)!;print(i/2*(++i/2))
//  [swift]
let i=Int(readLine()!)!;print(i/2*(i/2+(i%2)))
//  [swift]
var i=Int(readLine()!)!;print(i/2*(i++/2))
//  [swift]
//
//  main.swift
//  AtCoder
//
//  Created on 2019/03/22.
//  Copyright © 2019 yutake2000. All rights reserved.
//

import Foundation

class Scanner {
    var buffer: [String.SubSequence]
    func next() -> String {
        if (buffer.count == 0) {
            if let line = readLine() {
                buffer = line.split(separator: " ")
            }
        }
        return (buffer.count == 0) ? "" : String(buffer.removeFirst())
    }
    func nextInt() -> Int {
        return Int(next())!
    }
    func nextDouble() -> Double {
        return Double(next())!
    }
    init() {
        buffer = []
    }
}

var sc = Scanner()

var K = Int(sc.next())!

if K % 2 == 0 {
    print(K * K / 4)
} else {
    print((K+1) * (K-1) / 4)
}
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[])=>{for(let i=0;i<a.length;i+=2)if(s==a[i])return a[i+1]};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};
const main = ()=>{
  let a=nin();
  out(floor((a/2)*(a/2)));
}
main();
//  [typescript]
import * as fs from 'fs';

namespace AtCoder.abc108 {

    class ProgramA {
        args: string[];

        // in 6
        // out 9
        // 1,2
        // 1,4
        // 1,6
        // 2,3
        // 2,5
        // 3,4
        // 3,6
        // 4,5
        // 5,6
        constructor(args: string[]) {
            this.args = args;
        }

        main(): void {
            const k: number = parseInt(args[0]);
            let ans: number = 0;
            for (let i = 1; i < k; i++) {
                for (let j = i; j <= k; j++) {
                    if (i % 2 === 0) { // 偶数
                        if (j > i && j % 2 === 1) {
                            ans++;
                        }
                    }
                    if (i % 2 === 1) { // 奇数
                        if (j > i && j % 2 === 0) {
                            ans++;
                        }
                    }
                }
            }
            console.log(ans);
        }
    }

    const args: string[] = fs.readFileSync('/dev/stdin', 'utf-8').trim().split('\n');
    const func = new ProgramA(args);
    func.main();
}
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const _k = stdin.split('\n')[0]
const k = Number(_k)

const evens = Math.floor(k/2)
const odds = k - evens

console.log(evens * odds)
//  [typescript]
package main

import (
  "fmt"
)

func main() {
  var k int
  fmt.Scan(&k)
  result := (k/2) * ((k+1)/2)
  fmt.Println(result)
}
//  [typescript]
function main(input) {
const N = parseInt(input.split(/\s|\n/g)[0],10),
	  K = parseInt(input.split(/\s|\n/g)[1],10);
  if(K%2===0){
	const a = Math.floor(N/(K/2)),
          b = Math.floor(N/(K/2))+1
    console.log(a*a*a+b*b*b)
  }else{
    const a = Math.floor(N/K)
    console.log(a*a*a)
  }
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [python]
n=int(input())
a=int(input())
print("Yes") if n%500<=a else print("No")
//  [python]
n = int(input())
a = int(input())
print('Yes' if n%500 <= a else 'No')
//  [python]
N = int(input())
A = int(input())
if N%500 <= A:
  print("Yes")
else:
  print("No")
//  [python]
n = int(input())
a = int(input())

mod = n % 500
print("Yes" if a <= mod else "No")
//  [python]
a,b= [input() for i in range(2)]
b=b[1:]
a=int(a);b=int(b)
if a==0 and b>0:
  print('No')
  exit()

if a%b==0 or b%a==0:
  print('Yes')
else:
  print('No')
//  [python]
for i in range(A+1):
    Z = N - i
    if Z % 500 == 0:
        print("Yes")
        exit()
        
print("No")
//  [java]
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO 自動生成されたメソッド・スタブ
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int a = Integer.parseInt(br.readLine());
		int b = Integer.parseInt(br.readLine());
		String ans = "No";

		if (a % 500 <= b) {
			ans = "Yes";
		}

		System.out.println(ans);

	}

}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.NoSuchElementException;
import java.util.Random;

class Main {
	public static void main(String[] args) {
		new Main().run();
	}
	
	void run() {
		FastScanner sc=new FastScanner();
		PrintWriter pw=new PrintWriter(System.out);
		int N=sc.nextInt();
		int A=sc.nextInt();
		pw.println(N%500<=A?"Yes":"No");
		pw.close();
	}

	
	static void tr(Object... objects) {
		System.out.println(Arrays.deepToString(objects));
	}

}


class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        }else{
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
    private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
    public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public int nextInt() {
    	return Integer.parseInt(next());
    }
    
    public long nextLong() {
    	return Long.parseLong(next());
    }
}
//  [java]
import java.io.IOException;
import java.util.NoSuchElementException;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException {
        try (
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(System.in))) {
            FastScanner fs = new FastScanner();

            int N = fs.nextInt();
            int A = fs.nextInt();
            System.out.println(N % 500 <= A ? "Yes" : "No");
        }
    }
}

class FastScanner {
    private final InputStream in = System.in;
    private final byte[] buffer = new byte[1024];
    private int ptr = 0;
    private int buflen = 0;
    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                buflen = in.read(buffer);
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen <= 0) {
                return false;
            }
        }
        return true;
    }
    private int readByte() {
        if (hasNextByte()) return buffer[ptr++];
        else return -1;
    }
    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }
    public boolean hasNext() {
        while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;
        return hasNextByte();
    }
    public String next() {
        if (!hasNext()) throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while(isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }
    public long nextLong() {
        if (!hasNext()) throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while(true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if(b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }
    public int nextInt() {
        long nl = nextLong();
        if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE)
            throw new NumberFormatException();
        return (int) nl;
    }
    public double nextDouble() {
        return Double.parseDouble(next());
    }
}
//  [java]
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner stdIn = new Scanner(System.in);
		
		int N = stdIn.nextInt();
		int A = stdIn.nextInt();
		
		N %= 500;
		
		if(N < A)
		{
			System.out.println("Yes");
		}
		else
		{
			System.out.println("No");
		}

	}

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

class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int a = sc.nextInt();
    if (n % 500 <= a) {
      System.out.println("YES");
    } else {
      System.out.println("NO");
    }
  }
}
//  [java]
import java.util.*;
// warm-up
public class Main {

	static void solve() {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt(), A = sc.nextInt();
		boolean ok = false;
		while (true) {
			if (N<=0) break;
			if (N<=A) ok=true;
			N-=500;
		}
		System.out.println(ok ? "Yes" : "No");
		sc.close();		
	}

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

}
//  [cpp]
#include <stdio.h>
main() {
	int n, a;
	scanf("%d\n%d", &n, &a);
	if (n % 500 > a) puts("No");
	else puts("Yes");
}
//  [cpp]
#import<cstdio>
int main(){int n,a;scanf("%d%d",&n,&a);puts(n%500>a?"No":"Yes");}
//  [cpp]
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int main()
{
    int n,m,k;
    scanf("%d%d",&n,&m);
    k=n%500;
    if(k<=m)
        printf("Yes\n");
    else
        printf("No\n");
    return 0;
}
//  [cpp]
#include <bits/stdc++.h>
using namespace std;
int main(){
	int N,A;
  	cin >> N >>A ;
  	if(N % 500 <= A){
    	cout << "YES" <<endl;
    } else{
    	cout << "NO" <<endl;
    }
}