const { read } = require('fs');

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

readline.question('', w => {
    if(parseInt(w) %2==0 && parseInt(w)>4){
        console.log('YES');
    }
    else{
        console.log('NO');
    }
    readline.close();
})


const readline = require('readline').Interface({
	input: process.stdin,
	output: process.stdout
});
const watermelon = (num) => {
	return num % 2 === 0 ? 'YES' : 'NO';
};
readline.on('line', (num) => {
	readline.close(), print(watermelon(num));
});


const readline = require('readline').Interface({
	input: process.stdin,
	output: process.stdout
});
const watermelon = (num) => {
	for (let i = 2; i < num; i += 2) {
		for (let j = 2; j < num; j += 2) {
			if (i + j === num) return 'YES';
		}
	}
	return 'NO';
};

readline.on('line', (num) => {
	readline.close(), console.log(watermelon(num));
});


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

// read each line
rl.on("line", (lineInput) => {
  if (lineInput % 2 == 0 || lineInput != 2) {
    console.log("Yes");
  } else console.log("NO");
});

// when all file readed
rl.on("close", () => {});


console.log(process.argv[2]%2 === 0 ? "YES", "NO")


process.stdin.on('data', chunk => console.log(chunk.toString() % 2 === 0 ? "YES":"NO"))


const readline = require('readline');

let inputs = [];

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

// Read Inputs
rl.on('line', inputLine => {
    let nums = inputLine.split(' ').map(num => parseInt(num));
    let n = nums[0];
    let m = nums[1];
    let a = nums[2];
    let b = nums[3];

    if (n === 1) {
        if (a < b)
            return console.log(a)
        else
            return console.log(b)
    } else if (n % m === 0 || a > b) {
        return console.log(Math.ceil((n / m)) * b)
    } else {
        return console.log((Math.floor((n / m)) * b) + (n % m) * a)
    }

    return console.log(n)

});


const input = [];

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

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

RL.on('close', () => {
  let [n, m, a, b] = input[0].split(' ').map(x => parseInt(x));

  if (b/m <= a) {
    if (n % m === 0) {
      console.log( (n/m) * b );
    } else {
      console.log(Math.min(
        (parseInt(n/m) * b) + (n - parseInt(n/m) * m) * a,
        parseInt(Math.ceil(n/m) * b)
      ));
    }
  } else {
    console.log(m/b);
    console.log(n*a);
  }
});


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

rl.on('line', (d) => {
  if (c === 0) {
    [n, k] = d.split(' ').map(Number);
    c++;
    return;
  }

  const arr = [...d];
  const obj = {};

  for (let i = 0; i < arr.length; i++) {
    if (obj[arr[i]]) {
      obj[arr[i]]++;
    }
    else {
      obj[arr[i]] = 1;
    }
  }

  const ans = new Set(Object.values(obj));
  if (ans.size === 1) {
    console.log('YES');
  }
  else {
    console.log('NO');
  }

  c++;
});


const readline = require('readline');
//const lineReader = require('fs');
//const scanner = lineReader.createReadStream('main.in');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.on('line', (input) => {
    let n = parseInt(input);
    for (let i = 1; i * i <= n; i++){
        let eq = ((n - 1) - i - (i * i)) / (2 * i);
        if (eq === parseInt(eq) || eq > 0){
            console.log(i + " " + eq);
            process.exit(0);
        }
    }
    console.log("NO");
    rl.close();
});


'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 nn = readline();
    var n = nn[0];
    let arr = readline().split(' ');
    n = parseInt(n);

    arr = arr.map(ele => parseInt(ele))

    console.log(flip(n, arr));
}

function flip (n, arr) {
  let total =  0;
  for(let i = 0; i < arr.length; i ++){
    total += arr[i];
  }

 let max = 0;

 for (let i = 0; i < arr.length -2; i++) {
   for (let j = arr.length - 1; j > i; j--) {
       let sub = arr.slice(i, j + 1);
       let subSum = 0;
       for(let k = 0; k < sub.length; k++) {
           subSum += sub[k] === 0 ? 1 : -1;
       }
       let subRes = total + subSum;
       max = Math.max(max, subRes);
   }
 }
 return max;
}


function run(input, count = 0) {
    var i = input.indexOf('xxx');
    if (i == -1) return count;
    else return run(input.substr(i + 1), count + 1)
}

process.stdin.setEncoding('utf8');

process.stdin.on('readable', () => {
    let input = process.stdin.read();
    input = input.trim();

    if (input !== null) {
        run(input);
    }

    process.exit(0);

});


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 fileName = lines[0]
    let newFileName = buildNewFileName(fileName)
    let omittedCharactersCount = fileName.length - newFileName.length
    console.log(omittedCharactersCount)
})

function buildNewFileName(fileName) {
    let explodedName = fileName.split("")

    let xCount = 0
    let newFileName = "";
    explodedName.forEach(element => {
        if (element === 'x') {
            xCount++;
        } else {
            xCount = 0
        }

        if (xCount < 3) {
            newFileName += element
        }
    });
    return newFileName
}


'use strict';

var readline = require('readline');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var readline__default = /*#__PURE__*/_interopDefaultLegacy(readline);

async function solve(read) {
  const rn = async () => Number(await read());
  const n = await rn();
  const check = m => {
    let ans = Math.floor((m - 1) / 2) + Math.floor(m / 4) - 1;
    return ans >= n;
  };
  let l = 3,
      r = 10 ** 12;
  while (l < r) {
    const m = Math.floor((l + r) / 2);
    if (check(m)) {
      r = m;
    } else {
      l = m + 1;
    }
  }
  return l;
}

async function main(r) {
  try {
    let t = 1;
    let res = new Array(t);
    for (let i = 0; i < t; i++) {
      res[i] = await solve(r);
    }
    return res.join('\n');
  } catch (error) {
    console.log('zdebug' + error);
  }
}

const rl = readline__default["default"].createInterface({
  input: process.stdin,
  output: process.stdout
});
const it = rl[Symbol.asyncIterator]();
async function read() {
  return (await it.next()).value;
}
void async function () {
  const output = await main(read);
  process.stdout.write(output);
}();