const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on('line', (n, mahmoud = false) => {
  while(n > 0) {
    mahmoud = !mahmoud;
    mahmoud ? n -= 2 : n -= 1;
  }
  if (n === 0) { mahmoud ? console.log('Mahmoud') : console.log('Ehab') }
  else mahmoud ? console.log('Ehab') : console.log('Mahmoud');
  return rl.close();
});


let readline  = require('readline');
let intInput = readline.createInterface({
	input: process.stdin,
	output: process.stdout
});
let num;

intInput.on('line', (line) => {
	num = Number(line)
});
intInput.on('close', () => {
	let result = 'Ehub';
	if (num % 2 == 0){
		result = 'Mahmoud'
	}
	console.log(result);
})


const readLine = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout,
});

const input = [];
readLine.on('line', line => input.push(line));

readLine.on('close', () => {
  const [n] = input[0].split(' ').map(x => parseInt(x));

  if (n % 2 === 0) console.log('Mahmud');
  else console.log('Ehab');
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inp = 0
process.stdin.on("data",input=>{
    inp = input
})
process.stdin.on("end",input=>{

    main();
})

function main(){
if(inp%2===0){console.log("YES")} else {console.log("NO")}}


#!/usr/bin/env nodejs

// 4A - Watermelon

function main(stdin) {
  console.log(parseInt(stdin) % 2 === 0 ? "YES" : "NO");
}

main(require("fs").readFileSync(0, "utf-8"));


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question('', (w) => {
  main(w);
  rl.close();
});

function main(watermelon) {
  let path = watermelon/2;
  if ((path % 2) === 0){
    console.log('YES')
  }else{
    console.log('NO')
  }
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let watermelon = 0;

process.stdin.on('data', w => {
  watermelon = w;
});

process.stdin.on('end', _ => {
  inputString = inputString.trim().split('\n').map(string => {
    return string.trim();
  });

  main(watermelon);
});

function main(watermelon) {
  let path = watermelon/2;
  if ((path % 2) === 0){
    console.log('YES')
  }else{
    console.log('NO')
  }
}


const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});


const process = require('process')
process.stdout.write(process.argv[2] % 2 === 0 ? 'YES' : 'NO')


const process = require('process')
for(let i = 0; i < 3; i++) process.stdout.write(process.argv[i])


const readline = require('readline')
const w = readline().split(' ').map(x => parseInt(x))

const b = w/2;
if(b % 2 === 0){
    console.log("YES");
} else {
    console.log("NO");
}


let i = ''

function main(w) {
    // let dem = 0;
    // for(let i = 2; i <= w ; i++){
    //     if(w % i == 0){
    //         dem++;
    //     }
    // };
    //
    // if(dem >= 2){
    //     console.log("YES");
    // }else {
    //     console.log("NO");
    // }
    if(w % 2 == 0){
        console.log("YES");
    }else {
        console.log("NO");
    }
}
// main(6);

process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL)
    const line1Array = lines[0].split(' ').map(x => parseInt(x))
    const w = line1Array[0]

    main(w);
})


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', function(line){
    const weight = parseInt(line);
    if(weight < 2 || weight % 2 !== 0) {
        console.log("NO");
    } else {
        console.log("YES");
    }
})


var readline = require('readline');

const weight = parseInt(readline());

if(weight <= 2 || weight % 2 !== 0) {
    console.log("NO");
} else {
    console.log("YES");
}


const data = [];
process.stdin.on('data', (chunk) => data.push(chunk));

process.stdin.on('end', () => {
    const n = +(data.join('').trim());
    console.log(n % 2 || !n ? 'NO' : 'YES')
});


process.stdin.on('data', (chunk) => {
    process.stdout.write(+(chunk+''));
    process.stdout.write(+(chunk+'') % 2 ? 'YES' : 'NO');
})


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    const x = readline();
    console.log(x%2==0?'YES':'NO');
}


const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

// single line input
readline.on('line', line => {
  readline.close(), console.log(parseInt(line) % 2 === 0 && parseInt(line) >= 2 ? "YES" : "NO");
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');
let inputString = '';
let currentLine = 0;
process.stdin.on('data', (inputStd) => {
    inputString += inputStd;
});
process.stdin.on('end', function () {
    inputString = inputString
        .trim()
        .split('\n')
        .map((str) => {
            return str.trim();
        });
    main();
});
function readLine() {
    return inputString[currentLine++];
}
function main() {
    let w = parseInt(readLine());
    if (w === 2) {
        console.log('NO');
    }
    if (w % 2 === 0) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', (input) => {
  console.log(da(input))
  rl.close()
});

function da (n) {
    if (n == 2) return "НЕТ"
    return n % 2 ? "НЕТ" : "ДА"
}


const readline = require('readline');

const INPUT = 'test.in';
const LOCAL = process.env.ENABLE_LOCAL_ENV === 'true';
const log = (...args) => {
    LOCAL && console.log(...args)
};
let rl;
let lineNr = 0;

/**
 * MAIN
 */
(async () => {
    const promises = await setup(INPUT);
    await Promise.all(promises);
})();

function setup() {
    const promises = []
    rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
        terminal: false,
    });

    rl.on('line', (line) => {
        promises.push(work(line, lineNr));
        lineNr++;
    });

    rl.on('error', (err) => {
        log('Error:', err);
    });

    return new Promise(res => {
        rl.on('close', () => {
            res(promises)
            log('Done!');
        });
    });
}

async function work(line, lineNr) {
    const solutionForLine = await solve(line.trim());
    const responseLine = `${solutionForLine}\n`;
    process.stdout.write(responseLine);
}

/**
 *
 * Solution goes below
 *
 */
function solve(line) {
    return parseInt(line) % 2 === 0 ? 'YES' : 'NO';
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });
    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    const weight = readline();
    const output = weight % 2 === 0 ? "YES" : "NO";

    process.stdout.write(output)
}


let i = '';
process.stdin.on('data', (c) => {
  i += c;
});
process.stdin.on('end', () => {
  const { EOL } = require('os');
  const lines = i.split(EOL);
  canSplitEqually(parseInt(lines, 10)) ? console.log('YES') : console.log('NO');
});

function canSplitEqually(w) {
  return (w / 2) % 2 === 0;
}


let a = +print("", "");
if (a == 2) return "NO";
if (a / 2 % 2 === 0) return "YES";
else return "NO";


process.stdin.on('data', (data) => {
  if (data == 2) {process.stdout.write("NO");}
  else if (data / 2 % 2 === 0) {process.stdout.write("YES");}
  else {process.stdout.write("NO");}
})


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question('', (input) => {
    if (input % 2 === 0) {
        console.log('YES')
    } else {
        console.log('NO')
    }
    rl.close();
});


const readline = require('readline');

const rl1 = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const canDivide = (aWeight) => {
  if(typeof aWeight === 'number' && aWeight >= 1 && aWeight <= 100) {
    if(aWeight % 2 === 0) {
      const dividedWeight = aWeight/2;
      if(dividedWeight > 0) {
        return 'YES'
      }
    }
  }

  return 'NO';
}

rl1.on('line', (aInput) => {
  let weight = parseInt(aInput);
  console.log(canDivide(weight));
  rl1.close();
});


const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    terminal: false
});

process.stdin.setEncoding('utf8');
rl.once('line', line => {
    const n = line.toString().split(' ').map(Number);

    if (n % 2 === 0) console.log('YES');
    else console.log('NO');
    process.exit();
});


let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL)
    divideEvenly(lines[0]);
});

function divideEvenly(w){
    if (w < 1 || w > 100) console.log('NO');
    if (w % 2 === 0 && w !== 2){ console.log('YES')}
    else{ console.log('NO');}
}


var readline = (()=>{
    process.stdin.resume();
    process.stdin.setEncoding('utf-8');

    let inputString = '';
    let currentLine = 0;

    process.stdin.on('data', inputStdin => {
        inputString += inputStdin;
    });

    process.stdin.on('end', _ => {
        inputString = inputString.trim().split('\n').map(string => {
            return string.trim();
        });

        main();
    });

    function readline() {
        return inputString[currentLine++];
    }
    return readline;
})()

function main() {
	return readline().match(/(.)\1*/g).filter(str=>str.length%2===0).length;

}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    const x = readline();
    var line2 = readline();

    console.log(removeAdjacent(x, line2));
}

function findComparable(direction /* -1 left, 1 right*/, from, sArr) {
	return from+(direction*(sArr.findIndex((_, index) => sArr[from+(direction*(index+1))]!='#')+1));
}

function removeAdjacent(l, s) {

	let sArr = Array.from(s);

	// create a dictionary where every letter in associated the its positions in the string
	const lettersDict = sArr.reduce((acc, curr, i) => {
		if (curr in acc) {
			acc[curr].push(i);
		}
		else {
			acc[curr] = [i];
		}
		return acc;
	}, {});

	// order the keys of the dictionary by ascii value
	const keys = Object.keys(lettersDict);
	keys.sort((a, b) => {
		return b.charCodeAt(0) - a.charCodeAt(0)
	});

	// for every entry in keys check the string for adjacents
	return keys.reduce((acc, curr) => {
		let nEliminated = 0;

		for (let i = 0; i < lettersDict[curr].length; i++) {
			let position = lettersDict[curr][i];
			let leftComparable = findComparable(-1, position, sArr);
			let rightComparable = findComparable(1, position, sArr);
			if ((sArr[leftComparable] && (sArr[leftComparable].charCodeAt(0) - sArr[position].charCodeAt(0) == -1)) ||
				(sArr[rightComparable] && (sArr[rightComparable].charCodeAt(0) - sArr[position].charCodeAt(0) == -1))) {
				nEliminated++;
				if (sArr[position-1] === sArr[position]) {
					i -= 2;
				}
				sArr[position] = '#';
			}
		}

		return acc + nEliminated;
	}, 0);
}


process.stdin.resume()
process.stdin.setEncoding('utf-8')

let input = ''
let ptr = 0
process.stdin.on('data', (i) => {
  input += i
})

process.stdin.on('end', () => {
  input = input.split('\n').map(a => a.replace(/(\r\n|\n|\r)/gm, ''))
  main()
})

function wr(...x) {
  console.log(...x)
}

function sort(a, inc = true) {
  if(inc) a.sort((a, b) => a - b)
  else a.sort((a, b) => b - a)
}

function readInt() {
  return parseInt(input[ptr++])
}

function readString() {
  return input[ptr++]
}

function readStrings() {
  return input[ptr++].split(' ')
}

function readInts() {
  return input[ptr++].split(' ').map(a => parseInt(a))
}

function main() {
  const l = readInt()
  let s = readString()
  let max = 0
  let count = 0
  let len = l
  for(let c = 1; c < l; c++) { // l -1 times
    let f = false
    for(let i = 1; i < len; i++) {
      if(s[i] > s[max]) max = i
    }
    // console.log(s, max, s[max], count)
    if(max !== 0 && s.charCodeAt(max) - 1 === s.charCodeAt(max - 1)) {
      s = cut(max)
      len--
      count++
      f = true
    }
    else {
      for(let x = max; x < len - 1; x++) {
        if(s[x] === s[max] && s.charCodeAt(x) - 1 === s.charCodeAt(x + 1)) {
          // console.log('x', x, s[x])
          s = cut(x)
          len--
          count++
          f = true
        }
      }
    }
    if(!f) s = put(max)
    max = 0
  }

  wr(count)

  function cut(i) {
    i++
    return s.substring(0, i - 1) + s.substring(i)
  }
  function put(i) {
    i++
    return s.substring(0, i - 1) + 'A' + s.substring(i)

  }
}


function generateAlphabets() {
  var alphabets = [];
  var start = 'a'.charCodeAt(0);
  var last  = 'z'.charCodeAt(0);
  for (var i = start; i <= last; ++i) {
    alphabets.push(String.fromCharCode(i));
  }

  return alphabets;
}

const seq = generateAlphabets();

const processData = (lines) => {
  const s = lines[1].split('').map(x => x.charCodeAt(0))
  let sum = 0
  const set = Array.from(new Set(s)).sort((a, b) => a - b).reverse()
  for (const l of set) {
    const target = l - 1;
    for (let j =0; j<s.length; j++) {
      if (s[j] === l && (s[j-1] === target || s[j+1] === target)) {
        sum++
        s.splice(j, 1)
        j--
      }
    }
  }
  console.log(sum)
}

let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
  const {EOL} = require('os')
  const lines = i.split(EOL) /*your input text, split by lines*/
  processData(lines)
})


const readLine = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout,
});

const input = [];
readLine.on('line', line => input.push(line));

readLine.on('close', () => {
let check = 'NO'
const SF = input[1].match(/(SF)/g).length
const FS = input[1].match(/(FS)/g).length
if (SF > FS)
  check = 'YES'
console.log(check)
})


function solution(num){
    return num.match(/SF/g).length > num.match(/FS/g).length? "YES": "NO"
}
process.stdin.addListener("data", (data)=>{
    var num = data.toString().replace(/\d+\s+/, "");
    console.log(solution(num))
})


process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n')
  const ax = arr.shift().split(' ')
  const v = parseInt(ax[0])
  const e = parseInt(ax[1])

  if(e == 0) {
    console.log(0)
    return
  }
  if(v <= 6) {
    console.log(e)
  }

  else {
    let m = new Map()

    for(let i = 1; i <= e; i ++) {
      m.set(i, [])
    }

    for(let i = 0; i < e; i ++) {
      const edge = arr.shift().split(' ')
      const a = parseInt(edge[0])
      const b = parseInt(edge[1])
      m.get(a).push(b)
      m.get(b).push(a)
    }

    var f = false
    var a7 = m.get(7)
    var noOfVertices = 20
    for(let i = 1; i <= 6; i ++) {
      var other = m.get(i)
      var x = a7.filter(el => other.indexOf(el) != -1)
      if(x.length == 0) {
        f = true
        break
      }
      else if(x.length < noOfVertices) {
        noOfVertices = x.length
      }
    }
    if(f) {
      console.log(e)
    }

    else {
      console.log(e - noOfVertices)
    }
  }
})


process.stdin.resume()
process.stdin.setEncoding('utf-8')

var arr = ''
process.stdin.on('data', (i) => {
  arr += i
})

process.stdin.on('end', () => {
  arr = arr.split('\n')
  const ax = arr.shift().split(' ')
  const v = parseInt(ax[0])
  const e = parseInt(ax[1])

  if(e == 0) {
    console.log(0)
    return
  }
  if(v <= 6) {
    console.log(e)
  }

  else {
    let m = new Map()

    for(let i = 1; i <= v; i ++) {
      m.set(i, [])
    }

    for(let i = 0; i < e; i ++) {
      const edge = arr.shift().split(' ')
      const a = parseInt(edge[0])
      const b = parseInt(edge[1])
      m.get(a).push(b)
      m.get(b).push(a)
    }

    var f = false
    var a7 = m.get(7)
    var noOfVertices = 20
    for(let i = 1; i <= 6; i ++) {
      var other = m.get(i)
      var x = a7.filter(el => other.indexOf(el) != -1)
      if(x.length == 0) {
        f = true
        break
      }
      else if(x.length < noOfVertices) {
        noOfVertices = x.length
      }
    }
    if(f) {
      console.log(e)
    }

    else {
      console.log(e - noOfVertices)
    }
  }
})


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

const gcd = (a, b) => {
  while (b !== 0) {
    const temp = a;
    a = b;
    b = temp % b;
  }

  return a;
}

const factorial = (n) => {
  const arr = [1, 1];

  for (let i = 2; i <= n; i++) {
    arr[i] = arr[i - 1] * i;
  }

  return arr[n];
}

rl.on('line', (d) => {
  const [a, b] = d.split(' ').map(Number);

  console.log(gcd(factorial(a), factorial(b)));
});


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

const gcd = (a, b) => {
  while (b !== 0) {
    const temp = a;
    a = b;
    b = temp % b;
  }

  return a;
}

const factorial = (n) => {
  let prev = 1;
  let r = prev;

  for (let i = 2; i <= n; i++) {
    r = prev * i;
    prev = r;
  }

  return r;
}

rl.on('line', (d) => {
  const [a, b] = d.split(' ').map(Number);

  console.log(gcd(factorial(a), factorial(b)));
});


var read = require('readline').createInterface({
   input: process.stdin,
   output: process.stdout
});
var obj;
var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
   obj = init(inLine);
   console.error("\n");
   var start = Date.now();
   Main();
   var end = Date.now() - start;
   myerr("time : " + (end) + "ms");
   myerr("memory : " + Math.round(process.memoryUsage().heapTotal / 1024) + "KB");
});
function makeClone(obj){return JSON.parse(JSON.stringify(obj));}
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){
    var returnObj = {
      list : input, index : 0, max : input.length,
      hasNext : function(){return (this.index < this.max);},
      next : function(){
        if(!this.hasNext()){

            throw "ArrayIndexOutOfBoundsException これ以上ないよ";
        }
        else{
            var returnInput = this.list[this.index];
            this.index++;
            return returnInput;
        }
    }};
    return returnObj;
}
function myout(s){console.log(s);}
function myerr(s){console.error("debug:" + require("util").inspect(s,false,null));}
      //[no]要素の扱い。数値型
      //不明値、異常時:引数そのまま返す 1:数値へ変換
      //2:半角SPで分割 4:半角SPで分割し、数値配列へ
      //6:1文字で分割  7:1文字で分割し、数値配列へ
      //8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){
    try{
        switch(no){
            case 1:return parseInt(i);
            case 2:return i.split(" ");
            case 4:return i.split(" ").map(Number);
            case 6:return i.split("");
            case 7:return i.split("").map(Number);
            case 8:return i.join(" ");
            case 9:return i.join("\n");
            case 0:return i.join("");
            default:return i;
        }
    }
    catch(e){
        return i;
    }
}
function Main(){
    var output = [];

    var ul = next();
    var arr = nextIntArray() ;
    var brr = nextIntArray() ;
    mina = minb = 10 ;
    arr.forEach((x)=> {
        if(x < mina) {
            mina =x ;
        }
    })
    brr.forEach((x)=> {
        if(x < minb) {
            minb =x ;
        }
    })
    if(minb < mina) {
        var temp = 0
        temp = mina ;
        mina = minb ;
        minb = temp ;
    }
    if(mina !== minb)
        myout(mina+""+minb);
    else
        myout(mina);
}


let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL) /*your input text, split by lines*/

    const BubbleSort = (vector) => {
        for (let i = vector.size - 1; i > 1; i--) {
            for (let j = 1; j < i; j++) {
                if (vector[j] < vector[j-1]) {
                    let temp = vector[j-1];
                    vector[j-1] = vector[j];
                    vector[j] = temp;
                }
            }
        }
    }

    let vector = lines.split(' ');
    vector = BubbleSort(vector);
    let res = 0;

    res = vector[2] - vector[0];

    console.log(res);
});


let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL) /*your input text, split by lines*/

    const BubbleSort = (vector) => {
        for (let i = vector.length - 1; i > 1; i--) {
            for (let j = 1; j < i; j++) {
                if (vector[j] < vector[j-1]) {
                    let temp = vector[j-1];
                    vector[j-1] = vector[j];
                    vector[j] = temp;
                }
            }
        }

    }

    let vector = lines[0].split(' ').map( n => parseInt(n));
    BubbleSort(vector);
    let res = 0;
    res = vector[2] - vector[0];

    console.log(res);
});


// Sample code to perform I/O:

process.stdin.resume();
process.stdin.setEncoding("utf-8");
var stdin_input = "";

process.stdin.on("data", function (input) {
    stdin_input += input;                               // Reading input from STDIN
});

process.stdin.on("end", function () {
    main(stdin_input);
});

function main(input) {
    let output = nameLookUp(input);
    process.stdout.write(output);       // Writing output to STDOUT
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here
function nameLookUp(str) {

    let inputs = str.trim().split(' ').sort();
    let midFriend = +inputs[1];
    let total = +inputs[2] - midFriend;
    total += midFriend - +inputs[0];
    return total.toString();

}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.replace(/\s*$/, '')
        .split('\n')
        .map(str => str.replace(/\s*$/, ''));

    main();
});

function readLine() {
    return inputString[currentLine++];
}

function main() {
    let x = readLine().split(' ').map(v => parseInt(v)).sort();
    let x1 = x[0];
    let x2 = x[1];
    let x3 = x[2];
    console.log(Math.abs(x2 - x1) + Math.abs(x3 - x2))
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    let theNum = readline();

    let result = isTrue(theNum);

    if(result) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}

function isTrue(theNum) {
    if(theNum === 2) {
        return false;
    }
    let secondNum = theNum - 2;
    for(let i = 2; i <= theNum; i+=2, secondNum-=2) {
        if(i + secondNum == theNum) {
            if(i % 2 == 0 && secondNum % 2 == 0) {
                return true;
            }
        }
    }
    return false;
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    let theNum = readline();

    let result = isTrue(theNum);

    if(result) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}

function isTrue(theNum) {
    let secondNum = theNum - 2;
    for(i = 2; i <= theNum; i+=2, secondNum-=2) {
        if(i + secondNum == theNum) {
            if(i % 2 == 0 && secondNum % 2 == 0) {
                return true;
            }
        }
    }
    return false;
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    const number = readline();

   (number % 2 == 0) ? process.stdout.write("YES") : process.stdout.write("NO");
}


var n = readline();

if(n === 2){
	console.log("No");
}
else if(n % 2 === 0){
	console.log("Yes");
}
else{
	console.log("No");
}


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let input = [];
let result = "";

rl.on('line', function (line) {
    input = line.split(' ').map((el) => parseInt(el));
    if(input[0] % 2 ===0){
    	result = "Yes";
    }
    else{
    	result = "No";
    }
    rl.close();
  })
  .on('close', function () {
    console.log(result);
    process.exit();
  });


var input = parseInt(readline());

function splitWatermelon(weight) {
  for (var w1 = 1; w1 < weight; w1++) {
    var w2 = weight - w1;
    if (w1 % 2 === 0 && w2 % 2 === 0 ) {
      return true;
    }
  }

  return false;
}

print(splitWatermelon(input) ? 'YES' : 'NO');


process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", (inputStdin) => {
  inputString += inputStdin;
});

process.stdin.on("end", (_) => {
  inputString = getArray(inputString, '\n');

  main();
});

function getArray(str, delimiter) {
  return str
    .trim()
    .split(delimiter)
    .map((string) => {
      return string.trim();
    });
}

function readLine() {
  return inputString[currentLine++];
}

function pi(str) {
  return parseInt(str);
}

function main() {
  var n = readLine();
  if (pi(n) %2 === 0 && pi(n) > 0) {
    console.log("YES");
  } else {
    console.log("NO");
  }
}


const readline = require('readline')

class ReadStream {
    lines = []

    currPromise = undefined

    readlineHandler = input => {
        this.lines.push(input)
    }

    constructor() {
        this.rl = readline.createInterface({
            input: process.stdin,
            output: process.stdout
          });

        this.rl.on('line', this.readlineHandler)
    }

    async next() {
        this.currPromise = new Promise((resolve, reject) => {
            const tempPromise = this.currPromise ? this.currPromise : Promise.resolve()

            tempPromise.then(_ => {
                if (this.lines .length) {
                    resolve(this.lines.shift())
                }
                else {
                    this.rl.off('line', this.readlineHandler)
                    this.rl.once('line', (input) => {
                        resolve(input)
                        this.rl.on('line', this.readlineHandler)
                    })
                }
            })

        })
        return this.currPromise
    }

    close() {
        this.rl.off('list', this.readlineHandler)
        this.rl.close()
    }
}

const cin = new ReadStream()

async function main() {
    const weight = parseInt(await cin.next())

    if (weight % 4 === 0) {
        console.log('YES')
    } else {
        console.log('NO')
    }

    cin.close()
}

main()


const readline = require('readline');

const r1= readline.createInterface({
	input: process.stdin,
	output: process.stdout
})
r1.on('line', (line) => {
	watermelon(+line);
	r1.close();
})

function watermelon(kg) {
	return kg % 2 ? console.log('NO') : console.log('YES');
}


const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
rl.question("", (N) => {
  N = parseInt(N);
  if (N % 2 == 0 && N > 4) {
    console.log("YES");
  } else {
    console.log("NO");
  }
  rl.close();
});


readline = require('readline')
let stdinInput = '';

// //file
//     var fs = require('fs');
//    const inputfile = '_in.txt';
//    const outputfile = '_out.txt';
//    fs.writeFileSync(outputfile, '');
//    var myInterface = readline.createInterface({
//      input: fs.createReadStream(inputfile),
//    });
//    myInterface.on('line', function (line) {
//       stdinInput += line+'\n';
//     }).on('close', () => {
//            main();
//         process.exit(0);
//     })
   /*
   *  Api Scanner
   */
  class Scanner {
    constructor() {
      this.index = -1;
      this.lines = stdinInput.trim().split('\n'); // eslint-disable-line
    }

    nextLine() {
      this.index += 1;
      return this.lines[this.index].trim();
    }
    nextArray(fn) {
      const array = this.nextLine().split(' ');
      return fn === String ? array : array.map(fn);
    }

    hasNext() {
      return this.index < this.lines.length;
    }
  }

  process.stdin.resume();
  process.stdin.setEncoding('utf-8');
  process.stdin.on('data', (input) => { stdinInput += input; });
  process.stdin.on('end', () => { main(); });

var n;
function main() {
    const is = new Scanner();

    // const s = is.nextArray(Number);
    // const t = is.nextArray(Number);
    // // const k = is.nextArray();

    n = parseInt(is.nextLine());
    console.log(n);
    if(kt()==1)
        console.log("YES");
		else
        console.log("NO");
  }

  function kt(){
    for(var i=2; i<n; i=i+2)
	{
		if((n-i)%2==0)
			return 1;
	}
	return 0;
}


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

const ans = (text) => {
  console.log(text);
};

rl.on('line', function (w) {
  if (w < 3) {
    ans('NO');
  }

  if (w % 2 === 0) {
    ans('YES');
  }
  else {
    ans('NO');
  }
})


const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('', (weight) => {
    if (weight <= 3) console.log('NO');

    var answer = weight % 2;
    console.log(answer ? 'NO' : 'YES');
    rl.close();
});


var inputs = null;
//let inputs = ['8'];
function main(inputs) {
    var weight = parseInt(inputs[0]);
    for (var i = 2; i < 50; i += 2) {
        if (weight % 2 == 0)
            return console.log('YES');
    }
    console.log('NO');
}
// Do not change this
if (!inputs) {
    var input_1 = '';
    process.stdin.on('data', function (char) { return input_1 += char; });
    process.stdin.on('end', function () {
        var EOL = require('os').EOL;
        var inputs = input_1.split(EOL).slice(0, -1);
        main(inputs);
    });
}
else
    main(inputs);


function main(inputs) {
    var weight = parseInt(inputs[0]);
    for (var i = 2; i < 50; i += 2) {
        if (weight % 2 == 0)
            return console.log('YES');
    }
    console.log('NO');
}
// Do not change this
if (!inputs) {
    var input_1 = '';
    process.stdin.on('data', function (char) { return input_1 += char; });
    process.stdin.on('end', function () {
        var EOL = require('os').EOL;
        var inputs = input_1.split(EOL).slice(0, -1);
        main(inputs);
    });
}
else
    main(inputs);


var inputs = null;
//inputs = ['8'];
function main(inputs) {
    var w = parseInt(inputs[0]);
    if (w == 2)
        solution('NO');
    for (var i = 2; i < 50; i += 2) {
        if (w % 2 == 0)
            solution('YES');
    }
    solution('NO');
}
///////////////////////////////////////////////////////////////////////////////////////
if (!inputs) {
    var input_1 = '';
    process.stdin.on('data', function (char) { return input_1 += char; });
    process.stdin.on('end', function () {
        var EOL = require('os').EOL;
        var inputs = input_1.split(EOL).slice(0, -1);
        main(inputs);
    });
}
else
    main(inputs);
function solution(data) {
    console.log(data);
    process.abort();
}


function main() {
  const x = readline();
  write(x % 2 == 0 && x > 3 ? 'YES' : 'NO');
}

main();


const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

function main(x) {
  console.log(x % 2 == 0 && x > 3 ? 'YES' : 'NO');
}

const a;

// single line input
readline.on('line', line => {
  a = line;
  readline.close();
});

// multi line input
// readline.on('line', line => {
//   console.log(line);
// });

main(a);


const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

function main(x) {
  console.log(x % 2 == 0 && x > 3 ? 'YES' : 'NO');
}

let a;

// single line input
readline.on('line', line => {
  a = line;
  readline.close();
});

// multi line input
// readline.on('line', line => {
//   console.log(line);
// });

main(a);


process.stdin.resume();
process.stdin.setEncoding('ascii');

var input_stdin = "";
var input_stdin_array = "";
var input_currentline = 0;

process.stdin.on('data', function (data) {
    input_stdin += data;
});

process.stdin.on('end', function () {
    input_stdin_array = input_stdin.split("\n");
    main();
});

function readLine() {
    return input_stdin_array[input_currentline++];
}

function solveMeFirst(a) {
  // Hint: Type return a+b below
  return a % 4 === 0 ? "YES" : "NO";
}

function main() {
    var a = parseInt(readLine());

    var res = solveMeFirst(a);
    console.log(res);
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.replace(/\s*$/, '')
        .split('\n')
        .map(str => str.replace(/\s*$/, ''));

    main();
});

function readLine() {
    return inputString[currentLine++];
}

function main(){
  var n = parseInt(readLine());
  var res = "NO";
  if(n%2 ==0){
  for(var i=1;i<(n+1);i++){
    if(i%2 ==0){
      if((n-i)%2 ==0){
        res="YES";
      }
    }
  }
}
console.log(res);

}


const readLine = require('readline')

const rl = readLine.createInterface({
  input: process.stdin,
  output: process.stdout,
})

const input = []

rl.on('line', line => input.push(line.toString().split(' ').map(Number)))

rl.on('close', () => {
  const [[w]] = input
  console.log(['NO', 'YES'][Number((w - 2) % 4 === 0 && w > 3)])
})


const prompt = require('prompt-sync')({sigint: true});

const w = prompt();
if(w>2 && w%2==0 ){
  console.log('YES');
}else{
  console.log('NO');
}


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.question('a',(val)=>{
  if(val>2 && val%2==0){
    console.log('YES');
  }else{
    console.log('NO');
  }
  rl.close();
})


process.stdin.on('data', data => {
    process.stdout.write(parseInt(data.toString().trim()) - 2 % 2 === 0 ? "YES" : "NO");
})


process.stdin.on('data', function(line) {
    process.stdout.write(parseInt(line.trim()) % 4 === 0 ? "YES" : "NO");
});


'use strict'
const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});
var kilos;
rl.question('', (kilos) => {
  if((kilos%2==0) && (kilos>4)){
  console.log("YES")
  }else{
  console.log("NO")
  }
});


const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout,
});

// single line input
// readline.on("line", (line) => {
//   readline.close();
// });

// multi line input
readline.on("line", (line) => {
  const input = +line.split(" ")[0];
  readline.close();
  const half = input / 2;
  if (input % 2 === 0) {
    if (half % 2 === 0) {
      console.log("YES");
      return;
    }
  }
  console.log("NO");
});


function ProblemSolver() {
    this.HAS_TEST_CASES = false;
    this.INPUT_FILE_NAME = "test.in";
    this.OUTPUT_FILE_NAME = "out.txt";
    this.DO_OUTPUT_TO_FILE = false;
    this.CLEAR_ARRAY_PER_CASE = false;

	this.calc = function() {
		var i , fl , idx , j , crr ;
		while( true ) {
			fl = 0 ;
			for( i = 0 ; i <= this.cn - 3 ; i++ ) {
				if( this.brr[ i ] == this.brr[ i + 1 ] && this.brr[ i + 1 ] == this.brr[ i + 2 ] ) {
					fl = 1 ;
					idx = 0 ;
					crr = new Array() ;
					for( j = 0 ; j < this.cn ; j++ ) {
						if( j != i && j != i + 1 && j != i + 2 ) {
							crr.push( this.brr[ j ] ) ;
							idx++ ;
						}
					}
					this.brr = crr ;
					this.cn = idx ;
					break ;
				}
			}
			if( fl == 0 ) {
				break ;
			}
		}
		return this.n + 1 - this.cn ;
	} ;

    this.solveCase = function() {
        var res , i , j , fl , cn , temp ;
        res = 0 ;
        //at the start
        this.cn = 0 ;
        this.brr[ this.cn++ ] = this.x ;
        for( i = 0 ; i < this.n ; i++ ) {
        	this.brr[ this.cn++ ] = this.arr[ i ] ;
        }
        res = Math.max( res , this.calc() ) ;
        //at the end
        this.cn = 0 ;
        for( i = 0 ; i < this.n ; i++ ) {
        	this.brr[ this.cn++ ] = this.arr[ i ] ;
        }
        this.brr[ this.cn++ ] = this.x ;
        res = Math.max( res , this.calc() ) ;
        //anywhere in the middle
        for( j = 0 ; j < this.n - 1 ; j++ ) {
        	this.cn = 0 ;
	        for( i = 0 ; i <= j ; i++ ) {
	        	this.brr[ this.cn++ ] = this.arr[ i ] ;
	        }
	        this.brr[ this.cn++ ] = this.x ;
	        for( i = j + 1 ; i < this.n ; i++ ) {
	        	this.brr[ this.cn++ ] = this.arr[ i ] ;
	        }
        	res = Math.max( res , this.calc() ) ;
	    }
        print( res );
    };

    this.init = function() {
        this.lim1 = 100010;
        this.lim2 = 110;
        this.cc = 1;
        this.ind = 1;
        this.n = 0;
        this.cn = 0;
        this.declareAndFillArrays();
    };

    this.getInput = function( irObj ) {
        var hasMoreInput , i;
        hasMoreInput = true;
        try {
            this.n = irObj.nextInt();
            this.k = irObj.nextInt();
            this.x = irObj.nextInt();
            for( i = 0 ; i < this.n ; i++ ) {
                this.arr[ i ] = irObj.nextInt();
            }
        }
        catch( ex ) {
            hasMoreInput = false;
        }
        return hasMoreInput;
    };

    this.clearArraysPerCase = function() {
        var i;
        this.arr = new Array();
        this.adj_list = new Array();
        for( i = 0 ; i < this.lim1 ; i++ ) {
            this.arr.push( 0 );
            this.adj_list.push( new Array() );
        }
    };

    this.clearPerCase = function() {
        this.cn = 0;
        this.cc++;
        if( this.CLEAR_ARRAY_PER_CASE == true ) {
            this.clearArraysPerCase() ;
        }
    };

    this.declareAndFillArrays = function() {
        var i , j;
        this.srr = new Array();
        this.vis = new Array();
        this.arr = new Array();
        this.brr = new Array();
        this.memo = new Array();
        this.done = new Array();
        this.adj_list = new Array();
        for( i = 0 ; i < this.lim1 ; i++ ) {
            this.srr.push( "" );
            this.vis.push( 0 );
            this.arr.push( 0 );
            this.brr.push( 0 );
            this.adj_list.push( new Array() );
        }
        for( i = 0 ; i < this.lim2 ; i++ ) {
            this.memo.push( new Array() );
            this.done.push( new Array() );
            for( j = 0 ; j < this.lim2 ; j++ ) {
                this.memo[ i ].push( -1 );
                this.done[ i ].push( 0 );
            }
        }
    };

    this.init();
}

function InputReader() {
    var self = this ;
    this.allLines = new Array();
    this.currrentLineNumber = 0;
    this.currrentCharacterIndex = 0;
    this.callBackFunction = null ;
    this.parentContext = null ;

    this.readAllLines = function() {
        var singleLine;
        while( true ) {
            try {
                singleLine = readline();
                if( singleLine == null ) {
                    break;
                }
            }
            catch( ex ) {
                break;
            }
            this.allLines.push( singleLine );
        }
    };

    this.readAllLinesFromRhino = function() {
        var brObj , line ;
        importPackage( java.io ) ;
        importPackage( java.lang ) ;
        brObj = new BufferedReader( new InputStreamReader( System[ 'in' ] ) ) ;
        this.allLines = [] ;
        while( true ) {
            line = brObj.readLine() ;
            if( line == null ) {
                break;
            }
            this.allLines.push( line ) ;
        }
    };

    this.readSingleLinesFromNodeJsJudgeServer = function( chunk ) {
        self.chunkData += chunk ;
    };

    this.readEndFromNodeJsJudgeServer = function() {
        self.parseRawData( self.chunkData ) ;
        self.parentContext.runCases() ;
    };

    this.readAllLinesFromNodeJsJudgeServer = function( parentContext ) {
        this.parentContext = parentContext ;
        process.stdin.resume() ;
        process.stdin.setEncoding( 'utf8' ) ;
        this.chunkData = '' ;
        process.stdin.on( 'data' , this.readSingleLinesFromNodeJsJudgeServer ) ;
        process.stdin.on( 'end' , this.readEndFromNodeJsJudgeServer ) ;
    };

    this.parseRawData = function( data ) {
        var len , i , currentString;
        len = data.length;
        currentString = "";
        this.allLines = [] ;
        for( i = 0 ; i < len ; i++ ) {
            if( data[ i ] == '\r' ) {
            }
            else if( data[ i ] == '\n' ) {
                this.allLines.push( currentString );
                currentString = "";
            }
            else {
                currentString += data[ i ];
            }
        }
        if( currentString != "" ) {
            this.allLines.push( currentString );
        }
    };

    this.readAllLinesFromFile = function( inputFileName ) {
        var currentDirectory , fsObj , inputFilePath , rawData;
        fsObj = require( 'fs' );
        currentDirectory = __dirname;
        inputFilePath = currentDirectory + "\\" + inputFileName;
        rawData = fsObj.readFileSync( inputFilePath , "utf8" );
        this.parseRawData( rawData );
    };

    this.next = function( flag ) {
        var len , i , startIdx , res , endIdx;
        if( flag == 0 ) {
            if( this.currrentCharacterIndex != 0 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
            }
            res = "";
            len = this.allLines[ this.currrentLineNumber ].length;
            if( typeof( len ) == 'function' ) {
                len = this.allLines[ this.currrentLineNumber ].length() ;
            }
            for( i = this.currrentCharacterIndex ; i < len ; i++ ) {
                res += '' + this.allLines[ this.currrentLineNumber ].charAt( i ) ;
            }
            this.currrentLineNumber++;
            this.currrentCharacterIndex = 0;
            return res;
        }
        while( true ) {
            if( this.currrentLineNumber >= this.allLines.length ) {
                throw new Error( "No more tokens available!" );
            }
            startIdx = -1;
            len = this.allLines[ this.currrentLineNumber ].length;
            if( typeof( len ) == 'function' ) {
                len = this.allLines[ this.currrentLineNumber ].length() ;
            }
            for( i = this.currrentCharacterIndex ; i < len ; i++ ) {
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) != ' '.charCodeAt( 0 ) ) {
                    startIdx = i;
                    break;
                }
            }
            if( startIdx == -1 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
                continue;
            }
            res = "";
            endIdx = len - 1 ;
            for( i = startIdx ; i < len ; i++ ) {
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) == ' '.charCodeAt( 0 ) ) {
                    endIdx = i;
                    break;
                }
                if( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) >= 48 && this.allLines[ this.currrentLineNumber ].charCodeAt( i ) <= 57 ) {
                    res += '' + ( this.allLines[ this.currrentLineNumber ].charCodeAt( i ) - 48 ) ;
                }
                else {
                    res += '' + this.allLines[ this.currrentLineNumber ].charAt( i );
                }
            }
            this.currrentCharacterIndex = endIdx;
            if( endIdx == len - 1 ) {
                this.currrentLineNumber++;
                this.currrentCharacterIndex = 0;
            }
            return res;
        }
    };

    this.nextInt = function() {
        return parseInt( this.next( 1 ) );
    };

    this.nextDouble = function() {
        return parseFloat( this.next( 1 ) );
    };

    this.nextString = function() {
        return this.next( 1 );
    };

    this.nextLine = function() {
        return this.next( 0 );
    };
}

function FileOutputHandler() {
    this.resultantStringArray = new Array();

    this.addNewLine = function( newString ) {
        this.resultantStringArray.push( newString );
    };

    this.clearPercase = function() {
        this.resultantStringArray = new Array();
    };

    this.flushOutOutputToFile = function( outputFileName ) {
        var i , sz , res , currentDirectory , fsObj , outputFilePath;
        res = "";
        sz = this.resultantStringArray.length;
        for( i = 0 ; i < sz ; i++ ) {
            if( i != 0 ) {
                res += "\n";
            }
            res += this.resultantStringArray[ i ];
        }
        fsObj = require( 'fs' );
        currentDirectory = __dirname;
        outputFilePath = currentDirectory + "\\" + outputFileName;
        fsObj.writeFileSync( outputFilePath , res );
        this.clearPercase();
    };
}

function CodeExecutioner() {
    this.irObj = new InputReader();
    this.psObj = new ProblemSolver();
    this.fohObj = new FileOutputHandler();

    this.runCases = function() {
        if( this.psObj.HAS_TEST_CASES == true ) {
            testCases = this.irObj.nextInt();
            for( i = 0 ; i < testCases ; i++ ) {
                this.psObj.clearPerCase();
                this.psObj.getInput( this.irObj );
                this.psObj.solveCase();
            }
        }
        else {
            while( true ) {
                this.psObj.clearPerCase();
                hasMoreTestCases = this.psObj.getInput( this.irObj );
                if( hasMoreTestCases == false ) {
                    break;
                }
                this.psObj.solveCase();
            }
        }
        if( this.psObj.DO_OUTPUT_TO_FILE == true ) {
            this.fohObj.flushOutOutputToFile( this.psObj.OUTPUT_FILE_NAME );
        }
    };

    this.detectEnvironmentType = function() {
        var environmentType = null ;
        try {
            if( importPackage != null ) {
                environmentType = 'rhino' ;
            }
        }
        catch( ex1 ) {
            try {
                //for nodejs local server check
                if( __dirname != null && readline != null && typeof( readline ) != 'function' ) {
                    environmentType = 'local-node-js' ;
                }
            }
            catch( ex2 ) {
                try {
                    if( readline == null || typeof( readline ) != 'function' ) {
                        environmentType = 'server-node-js' ;
                    }
                    else {
                        try {
                            if( Map != null ) {
                                environmentType = 'spider-monkey' ;
                            }
                            else {
                                environmentType = 'javascript-v8' ;
                            }
                        }
                        catch( ex3 ) {
                            environmentType = 'javascript-v8' ;
                        }
                    }
                }
                catch( ex3 ) {
                    environmentType = 'server-node-js' ;
                }
            }
        }
        return environmentType ;
    };

    this.configureStreamsAndReadInput = function() {
        var testCases , i , hasMoreTestCases , isLocal , localContext , isNodeJsJudgeServer , environmentType ;
        isNodeJsJudgeServer = false ;
        environmentType = this.detectEnvironmentType() ;
        if( environmentType == 'local-node-js' ) {
            try {
                if( print == null || typeof( print ) != 'function' ) {
                    print = console.log;
                }
            }
            catch( ex ) {
                print = console.log;
            }
            if( this.psObj.DO_OUTPUT_TO_FILE == true ) {
                localContext = this.fohObj;
                print = function() {
                    localContext.addNewLine.apply( localContext , arguments );
                }
            }
            this.irObj.readAllLinesFromFile( this.psObj.INPUT_FILE_NAME );
            this.runCases() ;
        }
        else if( environmentType == 'server-node-js' ) {
            try {
                if( print == null || typeof( print ) != 'function' ) {
                    print = console.log;
                }
            }
            catch( ex ) {
                print = console.log;
            }
            this.irObj.readAllLinesFromNodeJsJudgeServer( this ) ;
        }
        else if( environmentType == 'javascript-v8' ) {
            this.irObj.readAllLines();
            this.runCases() ;
        }
        else if( environmentType == 'rhino' ) {
            this.irObj.readAllLinesFromRhino();
            this.runCases() ;
        }
        else if( environmentType == 'spider-monkey' ) {
            this.irObj.readAllLines();
            this.runCases() ;
        }
    };

    this.configureStreamsAndReadInput();
}

new CodeExecutioner();


//Don't have to see. start------------------------------------------
var read = require('readline').createInterface({
  input: process.stdin, output: process.stdout
});
var obj; var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
  obj = init(inLine);
  console.error("\n");
  var start = Date.now();
  Main();
  var end = Date.now() - start;
  myerr("time : " + (end) + "ms");
  myerr("memory : " + Math.round(process.memoryUsage().heapTotal / 1024) + "KB");
});
function makeClone(obj){return JSON.parse(JSON.stringify(obj));}
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){
  return {
    list : input, index : 0, max : input.length,
    hasNext : function(){return (this.index < this.max);},
    next : function(){if(this.hasNext()){return this.list[this.index++];}else{throw "ArrayIndexOutOfBoundsException ‚There is no more input";}}
  };
}
function myout(s){console.log(s);}
function myerr(s){console.error("debug:" + require("util").inspect(s,false,null));}
//param "no" is
//unknown or outlier : return i. 1: parseInt.
//2: split space. 4: split space and parseInt.
//6: split 1 character. 7: split 1 character and parseInt.
//8: join space. 9: join nextline. 0: join no character.
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map(Number);case 6:return i.split("");case 7:return i.split("").map(Number);case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}

//Don't have to see. end------------------------------------------
function Main(){
  var one = nextIntArray().sort(function(a,b){return a - b;});
  var x1 = one[0];
  var x2 = one[1];
  var x3 = one[2];
  if((x3 - x1) % 2 == 0){
    var center = (x3 + x1) / 2;
    var output = Math.abs(center - x3);
    output += Math.abs(center - x2);
    output += Math.abs(center - x1);
    myout(output);
  }else{
    var L = Math.floor((x3 + x1) / 2);
    var R = Math.ceil((x3 + x1) / 2);
    var outputL = Math.abs(L - x3);
    outputL += Math.abs(L - x2);
    outputL += Math.abs(L - x1);
    var outputR = Math.abs(R - x3);
    outputR += Math.abs(R - x2);
    outputR += Math.abs(R - x1);
    myout(Math.min(outputR, outputL));
  }
}


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', (d) => {
  const arr = d.split(' ').map(Number);
  const point = arr.reduce((acc, x) => acc + x, 0) / arr.length;
  let ans = 0;

  for (let i = 0; i < arr.length; i++) {
    ans += Math.abs(point - arr[i]);
  }

  console.log(ans);
});


const state = {stdin:Buffer.alloc(0)}
const consume = chunk => state.stdin = Buffer.concat([state.stdin, chunk], state.stdin.length+chunk.length )
const commit = answer => process.stdout.write(answer)
//
const main = args => {
    let data = parseInt(state.stdin.toString('utf8'))
    let solution = 'NO'
    if(data < 1 || data > 100) return null

    // divide the watermelon into two parts,
    // each of them weighing even number of kilos;

    for(let i = 1; i < data; i++){
        let partOne = data-i
        let partTwo = data-partOne
        if( partOne % 2 == 0 && partTwo % 2 == 0 ) {
            solution = 'YES'
            return commit(solution)
        }
    }
}

process.stdin
    .on('data', consume)
    .on('end', main)


const state = { stdin: Buffer.alloc(0) };
const consume = (chunk) =>
  (state.stdin = Buffer.concat(
    [state.stdin, chunk],
    state.stdin.length + chunk.length
  ));
const commit = (answer) => process.stdout.write(answer);
//
const main = (args) => {
  let data = parseInt(state.stdin.toString("utf8"));
  //   let solution = "NO";
  // num%2 === 0 ? num/parts+1 : num/parts
  return data % 2 === 0  && commit("YES") || commit("NO");
  //   for (let i = 1; i < data; i++) {
  //     if (i % 2 === 0 && (data - i) % 2 === 0) {
  //       solution = "YES";
  //       commit(solution);
  //       return;
  //     }
  //   }
  //   commit(solution);
};

process.stdin.on("data", consume).on("end", main);


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
  })

  // multi line input
  readline.on('line', line => {
    let number = parseInt(line)
    console.log(watermelon(number))
})

//it's a main function
function watermelon(number) {
    return number > -1 && number%2 === 0 ? 'YES' : 'NO'

}


// let weight = process.argv[2];
let weight =  input();

if (weight >= 2 && weight % 2 == 0)

{
    console.log('YES')
}
else
{
    console.log('NO')
}


// let weight = process.argv[2];
// let weight =  input();

// if (weight >= 2 && weight % 2 == 0)

// {
//     console.log('YES')
// }
// else
// {
//     console.log('NO')
// }

/************* KEEP BELOW CODE AS IT IS *********************/
/**
 * This code has been taken from: https://codeforces.com/blog/entry/69610
 * I am not the owner of the readLine function below, understanding them require knowledge of basic NodeJS I/O and streams
 */
process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

/****** BELOW HERE START WRITING YOUR CODE IN main() FUNCTION   ***************************************/
/**
 * Use "readLine()" function for input, which will return a string consisting the entire line, so accordingly split the string
 * when required.
 *
 * I am using console.log() to output
 */
function main() {
    let weight = readLine();
    // let weight = process.argv[2];

    if (weight >= 2 && weight % 2 == 0)

    {
        console.log('YES')
    }
    else
    {
        console.log('NO')
    }

    // t = parseInt(t);
    // console.log("mai yahan aaya")
    // while(t--) {
    //     let line = readLine();
    //     line = line.split(" ");
    //     let n = parseInt(line[0]);
    //     let m = parseInt(line[1]);
    //     if(n === 1) {
    //         console.log("0");
    //     } else if (n === 2) {
    //         console.log(m);
    //     } else {
    //         console.log(2*m);
    //     }
    // }
}


let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL) /*your input text, split by lines*/
    if(lines[0] % 2 === 0 && ((lines[0]/2)%2) === 0) {
      console.log("YES")
    }  else {
      console.log("NO");
    }
})


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

readline.question("", (weight) => {
    if (weight % 2 == 0)
        console.log("YES")
    else
        console.log("NO")
    readline.close()
})


// Input
'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}

//main
function main() {
    var n = parseInt(readline());
    console.log(n%2 ? "NO" : "YES");
}


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

function solution(input){
    if(input === 2){
        return "NO"
    }
    return input % 2 === 0 ? "YES" : "NO"
}

rl.on('line', function(line){
    console.log(solution(line))
})


const weight = readLine();
if ((weight < 1 && weight > 100) || (weight % 2 !== 0)) return 'NO';
let evenWeights = [];
for (let i = 0; i < weight; i++) {
    if (i % 2 === 0 && i > 0) {
        evenWeights.push(i);
    }
}
for (let i = 0; i < evenWeights.length; i++) {
    for (let j = 0; j < evenWeights.length; j++) {
        if (evenWeights[i] + evenWeights[j] === weight) return true;
    }
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function divideEvenWatermelon(weight) {
    if ((weight < 1 && weight > 100 ) || (weight % 2 !== 0)) return 'NO';
    if (weight === 2) return 'NO';
    let evenWeights = [];
    for (let i = 0; i < weight; i++) {
        if (i % 2 === 0 && i > 0) {
            evenWeights.push(i);
        }
        return 'NO';
    }
    for (let i = 0; i < evenWeights.length; i++) {
        for (let j = 0; j < evenWeights.length; j++) {
            if (evenWeights[i] + evenWeights[j] === weight) return 'YES';
        }
    }
}

function main() {
    const x = +(readline());
    console.log(divideEvenWatermelon(x));
}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    const x = readline();
   console.log(divideEvenWatermelon(x)
}
function divideEvenWatermelon(weight) {
    if ((weight < 1 && weight > 100 ) || (weight % 2 !== 0)) console.log('NO');
    let evenWeights = [];
    for (let i = 0; i < weight; i++) {
        if (i % 2 === 0 && i > 0) {
            evenWeights.push(i);
        }
    }
    for (let i = 0; i < evenWeights.length; i++) {
        for (let j = 0; j < evenWeights.length; j++) {
            if (evenWeights[i] + evenWeights[j] === weight) console.log('YES');
        }
    }
}


import prompt from "prompt";

const w = prompt();
if (w <= 2 || w % 2 !== 0) {
  console.log("NO", w);
} else {
  console.log("YES", w);
}


const readline = require("readline").createInterface({
  input: process.stdin,
  output: process.stdout,
});

readline.question('', (w) => {
  if (w != 2 || w % 2 !== 0) {
    console.log("NO");
  } else {
    console.log("YES");
  }
  readline.close();
});


process.stdin.on('data', input => (input > 2 && input % 2 == 0) ? 'YES' : 'NO');


//↓見なくていいよ！ここから--------------------------------------------------
var read = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});
var obj;
var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
  obj = init(inLine);
  myerr("-----start-----");
  var start = new Date();
  Main();
  var end = new Date() - start;
  myerr("----- end -----");
  myerr("time : " + (end) + "ms");
  myerr("memory : " + Math.round(process.memoryUsage().heapTotal / 1024) + "KB");
});
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){
  var returnObj = {
    list : input, index : 0, max : input.length,
    hasNext : function(){return (this.index < this.max);},
    next : function(){if(!this.hasNext()){throw "ArrayIndexOutOfBoundsException これ以上ないよ";}else{var returnInput = this.list[this.index];this.index++;return returnInput;}}
  };
  return returnObj;
}
function myout(s){console.log(s);}
function myerr(s){console.error("debug:" + require("util").inspect(s,false,null));}
//[no]要素の扱い。数値型
//不明値、異常時:引数そのまま返す 1:数値へ変換
//2:半角SPで分割 4:半角SPで分割し、数値配列へ
//6:1文字で分割  7:1文字で分割し、数値配列へ
//8:半角SPで結合 9:改行で結合 0:文字なしで結合
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map(Number);case 6:return i.split("");case 7:return i.split("").map(Number);case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}

//↑見なくていいよ！ここまで--------------------------------------------------
function Main(){
  var w = nextInt();
  if(w % 2 == 0){
      myout("YES");
  }else{
      myout("NO");
  }
}


num = process.stdin
console.log(num)

// const c=require("child_process")
// c.spawn('dir').stdout.on('data', (data)=>(console.log(data)))
// process.exit()
function test(t) {
    if ( t<1 || t>100 ) {
        console.log("input error")
        process.exit()
    }
}

test(num)

for(let i = 1; i < num; i++) {
    if (i%2 == 0) {
        let m = num-i
        if (m%2 == 0) {
            console.log("YES");
            process.exit();
        }

    }
}
console.log("NO")


num = input()
// console.log(num)

// const c=require("child_process")
// c.spawn('dir').stdout.on('data', (data)=>(console.log(data)))
// process.exit()
function test(t) {
    if ( t<1 || t>100 ) {
        console.log("input error")
        process.exit()
    }
}

test(num)

for(let i = 1; i < num; i++) {
    if (i%2 == 0) {
        let m = num-i
        if (m%2 == 0) {
            console.log("YES");
            process.exit();
        }

    }
}
console.log("NO")


let readline = require('readline');
let rl = readline.createInterface({
	input: process.stdin,
	output: process.stdout,
	terminal: false
});

let input = [];
rl.on('line', function(line) {
	input.push(line);
	if (input.length === 1) {
		waterMelon(parseInt(input[0]));
		rl.close();
	}
});

let waterMelon = (input) => {
	let start = 1;
	let end = input - 1;
	let result = 'NO';
	for (let i = start; i < end; i++) {
		if (i % 2 === 0 && end % 2 === 0) {
			result = 'YES';
		}
		end--;
	}
	console.log(result);
};


process.stdin.on('data', function(chunk){
   console.log(Number(chunk) % 2 === 0 ? 'YES' : 'NO');
});


process.stdin.resume();
process.stdin.setEncoding("utf8");

// var getline;
var input = "";
var read;
var writeline = (x) => process.stdout.write(x + "\n");
var write = (x) => process.stdout.write(x);

process.stdin.on("data", (chunk) => input += chunk);
process.stdin.on("end", () => {
    // input = input.split(/\r?\n/);
    // getline = () => input.shift();
    input = input.trim().split(/\s+/);
    read = () => input.shift();
    process.exit(main() || 0);
});

function main() {
    let l;
    while ((l = read()) !== undefined) {
        let x = parseInt(l);
        writeline(x % 2 === 0 ? 'YES' : 'NO');
    }
    return 0;
}


var stdin = "";
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function(data) {
  stdin += data;
});
process.stdin.on("end", function() {
  main(stdin);
});

const debug = 0;
var log = console.log;
var dbg = debug ? console.log : _ => {};

/////////////// ignore above this line ////////////////////

function main(stdin) {
  log(stdin % 2 ? "NO" : "YES");
}


let i = '';
process.stdin.on('data', c => i += c);
process.stdin.on('end', () => {
  const { EOL, } = require('os');
  const weight = i.split(EOL);
  const res = (val) => val % 2 === 0 ? 'YES' : 'NO';

  console.log(res(weight));
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');

process.stdin.on('data', inputStdin => {
    if (inputStdin % 2 === 0) {
      console.log('YES');
    } else console.log('NO');
});


const r = require('readline');
const rc = r.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rc.on('line', function(i){
    console.log((i % 2 === 0) ? 'YES' : 'NO')
})


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

function printResult(x) {
    process.stdout.write(x);
}

function main() {
    const arrPoints = new Array(8);
    for (let i = 0; i < 8; i++) {
        let rl = readLine().split(' ').map(Number);
        arrPoints[i] = new Point(rl[0], rl[1]);
    }

    eightPointSet(arrPoints);
}

function Point(x, y)
{
    this.x = x;
    this.y = y;
}

const comparePoints = (a, b) => {
    if (a.x < b.x || (a.x === b.x && a.y < b.y)) {
        return -1;
    }
    if (a.x > b.x || (a.x === b.x && a.y > b.y)) {
        return 1;
    }
    return 0;
}

/**
 * eightPointSet
 *
 * 2    4   7
 * 1        6
 * 0    3   5
 *
 * => Equal
 * x0 = x0 = x2
 * x3 = x4
 * x5 = x6 = x7
 * y0 = y3 = y5
 * y1 = y6
 * y2 = y4 = y7
 *
 * => Not equal
 * x0 != x3
 * x3 != x5
 * y0 != y1
 * y1 != y2
 */
const eightPointSet = (a) => {
    a.sort(comparePoints);
    if (a[0].x === a[1].x && a[1].x === a[2].x
        && a[3].x === a[4].x
        && a[5].x === a[6].x && a[6].x === a[7].x
        && a[0].y === a[3].y && a[3].y === a[5].y
        && a[1].y === a[6].y
        && a[2].y === a[4].y && a[4].y === a[7].y

        && a[0].x === a[3].x
        && a[3].x === a[5].x
        && a[0].y === a[1].y
        && a[1].y === a[2].y) {
        printResult('respectable');
    } else {
        printResult('ugly');
    }
};


function findGreeting( input ) {
  const greeting = 'hello';

  if ( input.length < greeting.length ) {
    return 'NO';
  }

  const inputArr = Array.from( input );
  const indices = [];

  for ( let i = 0; i < greeting.length; i++ ) {
    const char = greeting[ i ];

    const index = inputArr.findIndex( ( letter ) => letter === char );

    if ( index === -1 ) {
      return 'NO';
    }

    indices.push( index );

    if ( i !== 0 && indices[ i - 1 ] > indices[ i ] ) {
      return 'NO';
    }

    inputArr[ index ] = ',';
  }

  if ( !indices.length ) {
    return 'NO';
  }

  let asc = true;

  indices.reduce( ( acc, cur ) => {
    if ( acc > cur ) {
      asc = false;
    }

    return cur;
  } );

  return asc ? 'YES' : 'NO';
}

const { EOL } = require('os');

let i = '';

process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const lines = i.split(EOL)
    const res = findGreeting(lines[0])
    console.log(res);
})


function findGreeting(str) {
  const word = 'hello';
  let i = 0;
  for(const l of str) {
    if(l.length > i && l === word[i]) {
      i++;
    }
  }
  return i === word.length ? 'YES' : 'NO';
}

const { EOL } = require('os');

let i = '';

process.stdin.on('data', c => i += c)
        process.stdin.on('end', () => {
            const lines = i.split(EOL)
            const res = findGreeting(lines[0])
            console.log(res);
        })


const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout,
});

readline.on('line', hay => {
  const needle = 'hello';

  let needleP = 0;
  let hayP = 0;

  while (hayP < hay.length) {
    if (hay[hayP] === needle[needleP]) {
      needleP++;
      if (needleP === needle.length - 1) {
        break;
      }
    } else if (hay[hayP] === needle[needleP - 1]) {
    }
    hayP++;
  }

  console.log(needleP === needle.length - 1 ? 'YES' : 'NO');
});


readline.on('line', hay => {
  const needle = 'hello';

  let needleP = 0;
  let hayP = 0;

  while (hayP < hay.length) {
    if (hay[hayP] === needle[needleP] || hay[hayP] === needle[needleP - 1]) {
      needleP++;
      if (needleP === needle.length - 1) {
        break;
      }
    }
    hayP++;
  }

  console.log(needleP === needle.length - 1 ? 'YES' : 'NO');
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');

let standardInputString = '';
let currentLine = 0;

function readLine() {
    return standardInputString[currentLine++];
}

process.stdin.on('data', rawData=> {
    standardInputString += rawData;
})

process.stdin.on('end', _ => {
    standardInputString = standardInputString.trim().split('\n').map(line=> {
        return line.trim();
    })
    main();
})

function main() {
    let message = Array.from(readLine());
    const word = Array.from('hello');
    let counter = 0;
    if(!message.join("").includes('h')) {
        console.log('NO');
        return;
    }
    for(let i = message.indexOf('h'); i < message.length; i++) {
        if(message[i] === word[counter]) {
            if((word.length - 1) === counter) {
                console.log("YES");
                break;
            }
            counter++;
        } else {
            if(message[i] != word[counter - 1]) {
                console.log("NO");
                break;
            }
        }
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');
let inputString = '';
let currentLine = 0;
process.stdin.on('data', (inputStd) => {
    inputString += inputStd;
});
process.stdin.on('end', function () {
    inputString = inputString
        .trim()
        .split('\n')
        .map((str) => {
            return str.trim();
        });
    main();
});
function readLine() {
    return inputString[currentLine++];
}

function main() {
    let word = readLine();
    if (word.includes('hello')) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}


process.stdin.resume();
process.stdin.setEncoding('utf-8');

process.stdin.on('data', (input) => {
  process.stdout.write(input.match(/h+e+ll+o+/g) ? 'YES' : 'NO');
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');

process.stdin.on('data', (input) => {
  process.stdout.write(
    Array.from(input)
      .filter((c) => ['h', 'e', 'l', 'o'].some(c))
      .join('')
      .match(/h+e+ll+o+/g)
      ? 'YES'
      : 'NO'
  );
});


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.on('line', line => {
  line.split(' ').reduce((a, b) => {
    a > b ? console.log(`${b} ${Math.floor((a - b) / 2)}`) : console.log(`${a} ${Math.floor((b - a) / 2)}`);
  });
}).on('close', () => {
  process.exit(0);
});


function main() {
    // write code here:
    var arr = stdin[0].split(' ').map(Number);
    var fashion = Math.min(...arr);
    var temp = Math.max(...arr) - fashion;
    var pair = 0;
    if (temp % 2 === 0) {
        pair = temp / 2;
    }
    console.log(fashion + ' ' + pair);
}

const readline = require('readline');
const rl = readline.createInterface({input: process.stdin});
var stdin = [];
rl.on('line', function (line) {
    stdin.push(line);
});
rl.on('close', main);


const readLine = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];
readLine.on('line', line => input.push(line));

readLine.on('close', () => {
    const all = input[0].split(' ')
    let red = parseInt(all[0], 10)
    let blue = parseInt(all[1], 10)
    let multi = 0
    if (red > blue) {
        multi = blue
        red -= blue
        blue = 0
    } else if (red < blue) {
        multi = red
        blue -= red
        red = 0
    } else if (red === blue) {
        multi = red
        red = 0
        blue = 0
    }
    if (red > 0)
        multi += ` ${Math.floor(red / 2)}`
    else if (blue > 0)
        multi += ` ${Math.floor(blue / 2)}`
    console.log(multi)
})


let i = ''
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os')
    const lines = i.split(EOL) /*your input text, split by lines*/
    let vasayInput = lines[0].split(" ").map( element => {
        return parseInt(element)
    })
    let redSocksCount = vasayInput[0]
    let blueSocksCount = vasayInput[1]
    distributeSocks(redSocksCount, blueSocksCount)
})

function distributeSocks(redSocks, blueSocks) {
    let hipsterDaySocksCount = Math.min(redSocks, blueSocks)

    let remainingBlueSocks = blueSocks - hipsterDaySocksCount
    let remainingRedSocks = redSocks - hipsterDaySocksCount

    let normalDaysSocks = 0

    if (remainingBlueSocks % 2 === 0) {
        normalDaysSocks += remainingBlueSocks / 2
    }

    if (remainingRedSocks % 2 === 0) {
        normalDaysSocks += remainingRedSocks / 2
    }

    console.log(hipsterDaySocksCount + " " + normalDaysSocks)
}


const mainFunction = (lines) => {
    let arr = lines[1].split(" ").map(Number).sort((a, b) => a - b);
    arr = [...new Set(arr)]
    //console.log(arr)
    for(let i = 1; i < arr.length - 1; i++) {
        if( Math.abs(arr[i-1]-arr[i]) == Math.abs(arr[i+1]-arr[i]) && Math.abs(arr[i-1]-arr[i]) == 1
            && [...new Set([arr[i-1], arr[i], arr[i+1]])].length == 3){
            console.log([arr[i-1], arr[i], arr[i+1]])
            console.log("YES"); return 0;
        }
    }
    console.log("NO");
}

const { EOL } = require('os')
const fs = require("fs");
if (__filename.substr(9, 4) != "azer") {
    let yourInput = ''
    process.stdin.on('data', i => yourInput += i)
    process.stdin.on('end', () => mainFunction(yourInput.split(EOL)))
} else {
    mainFunction(fs.readFileSync('input.txt', 'utf8').split(EOL))
}


const input = [];

const RL = require('readline').createInterface({
   input : process.stdin,
   output : process.stdout
});

RL.on('line', line => input.push(line));

RL.on('close', () => {
  const [n, k, l, c, d, p, nl, np] = input[0].split(' ').map(x => parseInt(x));
  let botl = parseInt((k * l) / nl);
  let lim  = d; let s = parseInt(p / np);

  console.log( parseInt(Math.min(botl, lim, s) / n) );
});


'use strict';

const fs = require('fs');

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.replace(/\s*$/, '')
        .split('\n')
        .map(str => str.replace(/\s*$/, ''));

main();
});

function readLine() {
    return inputString[currentLine++];
}

function solve(n) {
    return n/2%2===0 ? `YES`: `NO`;
}

function main() {

    const nk = readLine().split(' ');

    const n = parseInt(nk[0], 10);

    let result = solve(n);
    console.log(result);
}


const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.question("What is weight of a watermelon? ", (value) => {
  console.log(getAnswer(+value));
  rl.close();
});

function getAnswer(weight) {
  if (weight < 4 || weight > 100 || weight % 2 !== 0) {
    return "NO";
  }

  return "YES";
}


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

// var numbers = readline().split(" ").map(function(x) { return parseInt(x); });

readline.on('line', line => {
    readline.close();

    const number = line.split(" ")[0];

    if (number % 2 === 0) {
        print('YES');
    } else {
        print('NO');
    }
});


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

// var numbers = readline().split(" ").map(function(x) { return parseInt(x); });

readline.on('line', line => {
    readline.close();

    const number = line.split(" ")[0];

    if (number % 2 === 0) {
        console.log('YES');
    } else {
        console.log('NO');
    }
});


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', function(line){
    console.log(+line % 2 === 0 && line !== 0 ? "YES" : "NO");
})


const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  rl.question("",function (x) {

    if (x%2 === 0 || x===2 ) {
        console.log('YES');

    }else  {
        console.log('NO')
    }

  })


const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('', (answer) => {
    if (answer % 2 === 0) {
        console.log('YES')
    } else {
        console.log('NO')
    }
    rl.close()
})


const readline = require('readline');
const z=2 ;
const x=1;
const c=100
const rl = readline.createInterface({
  input: process.stdin
});
rl.on('line', (input) => {
  if (input.trim()>=x && input.trim()<=c){
  if (input.trim() % z != 0 )
  {
    console.log("NO");
  }
  else
  {
    console.log("YES");
  }
}
  rl.close();
});


process.stdin.resume();
process.stdin.setEncoding('utf-8');
var arr = "";
process.stdin.on('data', function(chunk) {
  arr += chunk;
});
process.stdin.on('end', function() {
  arr = arr.split("\n");
  var n = parseInt(arr.shift()); // in order ot get no of test cases
   if(n%2===0 && n!==2)
    console.log('YES');
    else
    console.log('NO');
  }

});


process.stdin.resume();
process.stdin.setEncoding('utf-8');
var arr = "";
process.stdin.on('data', function(chunk) {
  arr += chunk;
});
process.stdin.on('end', function() {
  arr = arr.split("\n");
  var n = parseInt(arr.shift()); // in order ot get no of test cases
  for(let i=0;i<n;i++){ //loop through no of test cases.
      var a=parseInt(arr[i].split(" ")[0]);
      if(a%2===0 && a!==2)
        console.log('YES');
      else
        console.log('NO');
  }

});


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question('', (w) => {
  if (w <= 2 || w % 2 === 0) {
      console.log('YES');
  } else {
      console.log('NO');
  }

  rl.close();
});


var w = readline();
if(w-2)%2 != 0) console.log("YES")
else console.log("NO");


var w = readline();
if((w-2)%2 != 1) console.log("YES");
else console.log("NO");


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}

function main() {
    let w = readline();
    if(w > 1 && (w-2) %2 == 0)console.log("YES");
    else console.log("NO");
}


const solve = (w) => {
    if (w % 2 != 0) return false;
    if ((w >> 1) % 2 != 0) return false;
    return true;
};

const main = () => {
    const readline = require('readline');
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout
    });

    let input;
    rl.on('line', (line) => {
        input = Number(line);
    });

    rl.on('close', () => {
        let res = solve(input) ? 'YES' : 'NO';
        console.log(res);
    });

};

main()


// Generated by CoffeeScript 2.5.1
var lines, mainAux, print, readline, rl, rli, write;

rl = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

print = console.log;

write = function(...args) {
  return process.stdout.write(args.join(' '));
};

lines = [];

rl.on('line', function(line) {
  return lines.push(line);
});

rl.on('close', main);

rli = 0;

readline = function() {
  return lines[rli++];
};

mainAux = function() {
  var args, weight;
  args = readline();
  weight = args;
  if ((weight - 2) % 2 === 0) {
    return print('YES');
  } else {
    return print('NO');
  }
};

function main() {
  return mainAux();
};

//# sourceMappingURL=watermelon.js.map


// Generated by CoffeeScript 2.5.1
var lines, mainAux, print, readline, rl, rli, write;

rl = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

print = console.log;

write = function(...args) {
  return process.stdout.write(args.join(' '));
};

lines = [];

rl.on('line', line(function() {
  return lines.push(line);
}));

rl.on('close', main);

rli = 0;

readline = function() {
  return lines[rli++];
};

mainAux = function() {
  return print('YES');
};

function main() {
  return mainAux();
};

//# sourceMappingURL=watermelon.js.map


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
  inputString += inputStdin;
});

process.stdin.on('end', _ => {
  inputString = inputString
    .trim()
    .split('\n')
    .map(string => {
      return string.trim();
    });

  process.stdout.write(main(inputString));
  process.exit();
});

function readline() {
  return inputString[currentLine++];
}

const main = ([inputString]) => {
  return inputString % 2 === 0 ? 'YES' : 'NO';
};


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
rl.on('line', (input) => {
  console.log("YES" + input);
});
rl.close();


var line = readline().split(' ')
var number = parseInt(line)
if (number % 2 === 0 && number > 2) {
	print("YES")
} else {
	print("NO")
}


"use strict";

process.stdin.resume();
process.stdin.setEncoding("utf-8");

let inputString = "";
let currentLine = 0;

process.stdin.on("data", inputStdin => {
  inputString += inputStdin;
});

process.stdin.on("end", function() {
  inputString = inputString
    .replace(/\s*$/, "")
    .split("\n")
    .map(str => str.replace(/\s*$/, ""));

  main();
});

function readLine() {
  return inputString[currentLine++];
}

function main() {
  const firstLine = readLine();
  const weight = parseInt(firstLine, 10);
  // const a = readLine().split(' ').map(aTemp => parseInt(aTemp, 10));

  console.log(watermelon(weight));
}

function watermelon(weight) {
  return weight % 2 === 0 ? "YES" : "NO";
}


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin[],
  output: process.stdout,
  terminal: false
});

rl.on('line', function(line){
    console.log(line);
})


var readline = require('readline');
var rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});

rl.on('line', function(line){
    console.log(line);
})


const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
rl.question('Give input', (input) => {
    if (input%2 === 0 && input>= 4) {console.log ("YES")}
    else console.log ("NO")
}

)


// Sample code to perform I/O:

process.stdin.resume();
process.stdin.setEncoding("utf-8");
var stdin_input = "";

process.stdin.on("data", function (input) {
    stdin_input += input;                               // Reading input from STDIN
});

process.stdin.on("end", function () {
    main(stdin_input);
});

function main(input) {
    let output = nameLookUp(input);

    process.stdout.write(output);       // Writing output to STDOUT
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here
function nameLookUp(arr) {
    let nLines = arr.split('\n');
    let nWeight = nLines[0];
    let quotient = nWeight % 2 === 0 ? 'yes' : 'no';
    return quotient;

}


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}

function main() {
    const parameterVariable = readLine();
    const line2 = readLine();

    if(parameterVariable >= 2 && parameterVariable % 2 === 0) console.log('YES')
    else console.log('NO')

}


process.stdin.on('data', (n) =>
  process.stdout.write(n < 4 && n % 2? 'No' : 'YES')
);


var readline = require('readline');
var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false
});

rl.on('line', function (line) {
    console.log(dividable(parseInt(line)) ? 'YES' : 'NO');
    rl.close()
})

function dividable(w) {
    return (w % 2) === 0;
    // let part = 0;
    // while (part <= w) {
    //     if (((w - part) % 2) === 0) return true;
    //     part += 2;
    // }
    // return false;
}


const readline = require('readline').createInterface({
  input: process.stdin,
  output: process.stdout
});

// single line input
// readline.on('line', line => {
//   readline.close(), console.log(line)}
// });

// multi line input
readline.on('line', line => {
  let val = parseFloat(line);
  console.log( val%2 ==0 && val >=2? 'YES': 'NO');;
  readline.close();
});


 /*
Own input stream*/
const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    terminal: false
});

process.stdin.setEncoding('utf8');
let arr=[]
rl.on('line', (input) => {
    if(input!='') arr.push(input)

}).on('close', () => {
    console.log(minfill(arr))
    process.exit(0);

});
function minfill(arr){

   if ((arr/2)%2==0){
       return "YES"

   }
   else if(arr%2!=0){
        return "NO"
   }
   else{
       return "YES"

   }

}

module.exports=(minfill)


 /*
Own input stream*/
const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    terminal: false
});

process.stdin.setEncoding('utf8');
let arr=[]
rl.on('line', (input) => {
    if(input!=='') arr.push(input);

}).on('close', () => {
    console.log(minfill(arr))
    process.exit(0);

});
function minfill(arr){
return (arr>=2&&arr%2==0?"YES":"NO")

}

module.exports=(minfill)


process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
    _input += input;
});

process.stdin.on("end", function () {
   processData(_input);
});

function processData(input) {
    const values = input.split('\n')
    if (values && values.length > 0 && values[0]%2 === 0) {
        const temp = Math.floor(values[0]/2)
        if (temp%2 === 0) {
                        console.log("YES")

        } else {
                        console.log("NO")

        }

    } else {
            console.log("NO")
    }
}


process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
    _input += input;
});

process.stdin.on("end", function () {
   processData(_input);
});

function processData(input) {
    const values = input.split('\n')
    if (values && values.length > 0 && values[0]%2 === 0) {
        const temp = Math.floor(values[0]/2)
        if (temp%2 === 0) {
                        console.log("YES")

        } else {
                        console.log("NO")

        }


const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});
rl.on('line', (input) => console.log(`${input}`));
/*
let n = readline();
console.log(1);
*/
function main(){
    let a = readline();
    if(a > 2 && a % 2 === 0) console.log("YES");
    else console.log("NO")
    return 0;
}


process.stdin.resume();
process.stdin.setEncoding('utf8');
let input= '', readline, cout;
process.stdin.on('data', (chunk) => input+=chunk);
process.stdin.on('end', () => {
    input = input.split('\n');
    cout = (data) => process.stdout.write(data+'\n');
    var inputLineIndex = 0;
    readline = function(){return inputLineIndex>=input.length?undefined:input[inputLineIndex++]};
    process.exit(main() || 0);
});
/*
let n = readline();
output(1);
*/
function main(){
    let a = readline();
    if(a > 2 && a % 2 === 0) output("YES");
    else output("NO")
    return 0;
}


const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on("line",(name) => {
  const n = parseInt(name)

  if(n % 2 == 0 ){
    console.log("YES");

  }else{
    console.log("NO")
  }
  process.exit()
});


var read = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});
var obj;
var inLine = [];
read.on('line', function(input){inLine.push(input);});
read.on('close', function(){
  obj = init(inLine);
  myerr("-----start-----");
  var start = new Date();
  Main();
  var end = new Date() - start;
  myerr("----- end -----");
  myerr("time : " + (end) + "ms");
  myerr("memory : " + Math.round(process.memoryUsage().heapTotal / 1024) + "KB");
});
function nextInt(){return myconv(next(),1);} function nextStrArray(){return myconv(next(),2);}
function nextIntArray(){return myconv(next(),4);} function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();}
function init(input){
  var returnObj = {
    list : input, index : 0, max : input.length,
    hasNext : function(){return (this.index < this.max);},
    next : function(){if(!this.hasNext()){throw "ArrayIndexOutOfBoundsException これ以上ないよ";}else{var returnInput = this.list[this.index];this.index++;return returnInput;}}
  };
  return returnObj;
}
function myout(s){console.log(s);}
function myerr(s){console.error("debug:" + require("util").inspect(s,false,null));}

function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(" ");case 4:return i.split(" ").map(Number);case 6:return i.split("");case 7:return i.split("").map(Number);case 8:return i.join(" ");case 9:return i.join("\n");case 0:return i.join("");default:return i;}}catch(e){return i;}}

function Main() {
    var t = nextInt();
    if (t % 2 === 0) {
        if (t / 2 === 1) {
            console.log("NO");
        }
        console.log("YES");
    } else {
        console.log("NO");
    }
}


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

function input(){
    return new Promise ( (resolve , error) => {
       readline.question('', (data) => {
           readline.close();
           resolve(data);
       })
    });
}

async function main(){
    n  = await input();
    if(n === 2 || n % 2 === 1){
        console.log('NO');
    } else {
        console.log('YES');
    }
}

main();


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

function input(){
    return new Promise ( (resolve , error) => {
       readline.question('', (data) => {
           readline.close();
           //resolve(data);
       })
    });
}

async function main(){
    n  = await input();
    if(n == 2 || n % 2 == 1){
        console.log('NO');
    } else {
        console.log('YES');
    }
}

main();


const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
});

function input(){
    return new Promise ( (resolve , error) => {
       readline.question('', (data) => {
           readline.close();
       })
    });
}

async function main(){
    n  = await input();
    if(n == 2 || n % 2 == 1){
        console.log('NO');
    } else {
        console.log('YES');
    }
}

main();
resolve(data);


// https://code.i-harness.com/ko-kr/q/4c65e5
var stdin = process.stdin;
stdin.setEncoding( 'utf8' );
stdin.on( 'data', function( key ){
    process.stdout.write( parseInt(key) % 4 === 0 ? "YES" : "NO" );
});


//nodejs v4.2.6
process.stdin.resume();
	process.stdin.setEncoding('utf8');
	//Taking a usr input
	process.stdin.on('data', function (text) {
			//Printing out user input
			var input = parseInt(text)
				if(input%2 === 0){
					console.log('YES');
				}else{
					console.log('NO')
				}
	});


//nodejs v4.2.6
process.stdin.resume();
	process.stdin.setEncoding('utf8');
	//Taking a usr input
	process.stdin.on('data', function (text) {
			//Printing out user input
			var input = parseInt(text)
				if(input===2){
					colsole.log('NO')
				}else
				if(input%2 === 0){
					console.log('YES');
				}else{
					console.log('NO')
				}
	});


//const readline = require('readline')

const rl = readline.createInterface({
	    input: process.stdin,
	    output: process.stdout,
	terminal : false
});

rl.on("line", (w)=>{
	const r = w%2 ===0 ? "YES" : "NO"
       console.log(r)
})


const readline = require('readline')

const rl = readline.createInterface({
	    input: process.stdin,
	    output: process.stdout,
	terminal : false
});

rl.on("line", (w)=>{
	const r = w%2 ===0 ? "YES" : "NO"
       console.log(r)
})


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readline() {
    return inputString[currentLine++];
}
// Make a Snippet for the code above this and then write your logic in main();

function main() {
    let w = readline();
    w = parseInt(w);

    if (w%2 === 0) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}


let w = readline();
    w = parseInt(w);

    if (w%2 === 0) {
        foo('YES');
    } else {
        foo( 'NO');
    }


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}
function main(){
   const w = readLine();
   if (w%2===0){
       console.log("YES");
   }
   else{
       console.log("NO");
   }

}


const readline = require('readline');
let inputs = [];
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
rl.on('line', lineInput => {
    inputs.push(lineInput)
})
rl.on('close', () => {
		const n = inputs[0].split(' ').map(function (a) { return parseInt(a); });
    const k = inputs[1].split(' ').map(function (a) { return parseInt(a); });
    console.log(solution(n, k));
})
 function solution(n){
    if(n%2===0){
        console.log("YES")
    }
    else{
        console.log("NO")
    }
 }


'use strict';

process.stdin.resume();
process.stdin.setEncoding('utf-8');

let inputString = '';
let currentLine = 0;

process.stdin.on('data', inputStdin => {
    inputString += inputStdin;
});

process.stdin.on('end', _ => {
    inputString = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

function readLine() {
    return inputString[currentLine++];
}
function main(){
   const w = readLine();
   if w%2===0{
       console.log("YES");
   }
   else{
       console.log("NO");
   }

}


var readline = require('readline'),
    rl = readline.createInterface(process.stdin, process.stdout);

    rl.prompt();

rl.on('line', function (line) {

    var n=line.split(' ')
    n%2==0 && n!=2 ? console.log("YES") : console.log("NO");
    rl.close();

}).on('close', function () {

    process.exit(0);
});


var readline = require('readline'),
    rl = readline.createInterface(process.stdin, process.stdout);

rl.on('line', function (line) {

    var n=line.split(' ')
    (n%2==0 && n!=2) ? console.log("YES") : console.log("NO");
    rl.close();

}).on('close', function () {

    process.exit(0);
});