source_code:
const readline = require('readline');

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

rl.on('line', function(line){
	const b = parseInt(line);
	let counter = 0;
	const sqrt = Math.sqrt(b)
	for (let i = 2; i < sqrt; i++) {
		if (b % i === 0) { counter += 2; }
	}
	if (sqrt % 1 === 0) { counter++; }
	console.log(b === 1 ? 1 : counter + 2);
	rl.close();
});

lang_cluster: Javascript

exec_outcome: PASSED


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

readline.question('', str => {
  solution(str);
  readline.close();
});

function solution(str) {
  let i, j, count = 0;
  for(i = 0; i < str.length; i++) {
    for(j = i - 1; j >= 0; j--) {
      if (str[i] === str[j]) {
        break;
      }
    }
    if (j === -1) count++;
  }
  if (count % 2) {
    console.log("IGNORE HIM!");
    return;
  }
  console.log("CHAT WITH HER!");
  return;
}


source_code:
let inputString = '';
let currentLine = 0;

const runMain = () => {
  inputString = inputString.trim().split('\n').map(string => string.trim());
  main();
  process.exit();
}
const readLine = () => inputString[currentLine++];

process.stdin.on('data', inputStdin => inputString += inputStdin);
process.stdin.on('end', runMain);
process.on('SIGINT', runMain);

function main() {
  const [n, t] = readLine().split(' ').map(num => Number(num));
  const str = readLine().split('');
  for (let i = 0; i < t; i++) {
    let j = 0;
    while (j < n - 1) {
      if (str[j] === 'B' && str[j + 1] === 'G') {
        str[j] = 'G';
        str[j + 1] = 'B';
        j++;
      }
      j++;
    }
  }
  console.log(str.join(''));
}


source_code:
const readline = require('readline');

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

var ans=0,met=false;

rl.on('line', (input) => {
    let temp=input.match(/B/g);
   // console.log("temp= "+temp);
    if(/*temp.length == 8*/ input=="BBBBBBBB")
       ans++;
    else if(!met){
      if(temp!=null)
          ans+=temp.length;
       met=true;
    }

  }).on('close',function(){
      console.log(ans);
  });


source_code:
function main() {
    // write code here:
    var m=Number(stdin[0]);
    var n=1;
    for(var i=1;i<=m;i++){
        n+=4*(i-1);
    }
    console.log(n);
}

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


source_code:
let i = '';

process.stdin.on('data', c => i += c);
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = i.split(EOL);
    var t = lines[0]
    for(j = 1; j <= t; j++){
        var s = 1
        var n = lines[j]
        for(k = 1; k < n; k++){
            s +=  s + 1
        }
        console.log(s   )
    }
});


source_code:
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('H') || word.includes('Q') || word.includes('9')) {
        console.log('YES');
    } else {
        console.log('NO');
    }
}


source_code:
const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  terminal: false
});
let counter = 0;
let S, T;

rl.on('line', (d) => {
  if (counter === 0) {
    S = d;
  }
  else {
    T = d;

    let ans = 'YES';
    let j = 0;
    for (let i = T.length - 1; i >=0; i--) {
      if (T[i] !== S[j]) {
        ans = 'NO';
        break;
      }
      j++;
    }

    console.log(ans);
  }

  counter++;
});


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

rl.on('line', (d) => {
  if (c === 0) {
    c++;
    return;
  }

  const arr = d.split(' ').map(Number);
  arr.sort((a, b) => a - b);
  let ans = 0;
  let prev = -1;

  for (let i = 0; i < arr.length; i++) {
    if (prev !== arr[i] && arr[i] !== 0) {
      ans++;
      prev = arr[i];
    }
  }

  console.log(ans);

  c++;
});


source_code:
let inputString = "";
let currentLine = 0;
process.stdin.on("data", (data) => {
  inputString += data;
});
process.stdin.on("end", function () {
  inputString = inputString
    .trim()
    .split("\n")
    .map((str) => str.trim());
  main();
});
function readLine() {
  return inputString[currentLine++];
}
function main() {
  let a = readLine();
  if (a.toUpperCase() === a) {
    console.log(a.toLowerCase());
  } else if (a[0].toLowerCase() + a.substring(1).toUpperCase() === a) {
    console.log(a[0].toUpperCase() + a.substring(1).toLowerCase());
  } else {
    console.log(a);
  }
}


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

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

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


source_code:
let stdin = process.stdin;
stdin.setEncoding('utf8');
stdin.on('data', function (data) {
    let input = data.split('\n');
    let n = input[0].split(' ').map(function (a) { return parseInt(a); });
    let result = solution(n[0], n[1]);
    console.log(result);
});

// End of interface

const solution = function(a, b){
	let i = 0;
	while (a <= b) {
		a = a * 3;
		b = b * 2;
		i++;
	}
	return i;
};


source_code:
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('Mahmoud');
  else console.log('Ehab');
});


source_code:
'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 output(x) {
    if (typeof x !== 'string') {
        x = x.toString();
    }
    //process.stdout.write(x);   // without auto '\n' (newline)
    console.log(x);  // with auto '\n' (newline)
}

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

    for (let test = 0; test < N; test++) {
        let f = readline().split(' ').map(Number);
        let s = readline().split(' ').map(Number);

        let result = 2;
        if (f[0] === 0 && f[1] === 0 && s[0] === 0 && s[1] === 0) {
            result = 0;
        } else if (f[0] + f[1] + s[0] + s[1] === 4) {
            result = 2;
        } else {
            result = 1;
        }

        output(result);
    }
}


source_code:
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 = Number(input[0]);
    const left = [], right = [];
    for (let i = 1; i <= n; i++) {
        let [l, r] = input[i].split(' ');
        left.push(l); right.push(r);
    }
    let c = 0;
    for (let i = 0; i < left.length; i++) {
        for (let j = 0; j < right.length; j++) {
            if (j === i) continue;
            if (left[i] === right[j]) c++;
        }
    }
    console.log(c);
});


source_code:
'use strict';

var fs = require('fs');

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

var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);

function solve(read) {
  const [rn, rb, rns, re, rbs] = convertInput(read);
  const [n, m] = rns();
  let pre = 1,
      M = mod(m),
      res = 0,
      ans = M,
      ans1 = M;
  const p = getPrimes(n + 10);
  for (let i = 2; i <= n; i++) {
    if (pre <= m && p[i]) pre = pre * i;
    if (pre > m) {
      ans = 0;
    } else {
      ans = mul(ans, Math.floor(m / pre));
    }
    ans1 = mul(ans1, M);
    res = mod(res + ans1 - ans);
  }
  return res;
}
function getPrimes(n) {
  const nums = new Array(n + 1).fill(1);
  nums[0] = nums[1] = 0;
  const primes = [];
  for (let i = 2; i <= n; i++) {
    if (nums[i]) primes.push(i);
    for (let j = 0; primes[j] <= n / i; j++) {
      nums[primes[j] * i] = 0;
      if (i % primes[j] === 0) break;
    }
  }
  return nums;
}
const MOD = 998244353;
function mod(num) {
  if (num >= MOD) return num % MOD;else if (num < 0) return (num % MOD + MOD) % MOD;
  return num;
}
function mul(...args) {
  if (args.length === 0) throw new Error('参数不能为空');
  if (args.length === 1) return args[0];
  const [a, b] = args;
  if (args.length > 2) return mul(mul(a, b), ...args.slice(2));
  return (Math.floor(a / 65536) * b % MOD * 65536 + (a & 65535) * b) % MOD;
}
function convertInput(read) {
  const rn = () => Number(read());
  const rb = () => BigInt(read());
  const rns = () => read().split(/\s+/).map(Number);
  const re = () => read().split(/\s+/).map(s => Number(s) - 1);
  const rbs = () => read().split(/\s+/).map(BigInt);
  return [rn, rb, rns, re, rbs];
}
function main(r) {
  try {
    let t = 1;
    let res = new Array(t);
    let limit = 0;
    for (let i = 0; i < t; i++) {
      var _solve;
      const s = (_solve = solve(r)) !== null && _solve !== void 0 ? _solve : '';
      if (t < limit) ; else {
        res[i] = s;
      }
    }
    if (t >= limit) {
      return res.join('\n');
    }
  } catch (error) {
    console.log(error);
  }
}

const inputs = fs__default["default"].readFileSync(0, 'utf-8').split(/\r?\n/);
void function () {
  const read = ((i = 0) => () => inputs[i++])();
  const output = main(read);
  process.stdout.write(output);
}();


source_code:
const readline = require('readline');

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

rl.on('line', n => {
  const a = Array.from(n).filter(letter => letter === 'a').length;
  console.log((a > (n.length / 2)) ? n.length : (a + (a - 1)));
  rl.close();
});


source_code:
const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
rl.on('line', (inputString) => {
    let numberOfSquares = parseInt(inputString);
    rl.close();
    console.log(findTheNumberOfLinesForLady(numberOfSquares));
});

function findTheNumberOfLinesForLady(forTheNumberOfSquaress) {
    let a = Math.sqrt(forTheNumberOfSquaress);
    let b = Math.trunc(a);
    if (a == b) return 2 * a;
    if (b * (b + 1) >= forTheNumberOfSquaress) return 2 * b + 1;
    return 2 * b + 2;
}


source_code:
//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↑入力 ↓出力');
	Main();
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : 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();
	var L = one[0];
	var R = one[1];
	var C = one[2];
	if(Math.abs(L - R) >= C){
		myout((Math.min(Math.max(L, R), Math.min(L, R) + C)) * 2);
	}else{
		var diff = Math.abs(L - R);
		if(L > R){
			R += diff;
		}else{
			L += diff;
		}
		C -= diff;
		myout((Math.floor(C / 2) + L) * 2);
	}
}


source_code:
'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 output(x) {
    if (typeof x !== 'string') {
        x = x.toString();
    }
    //process.stdout.write(x);   // without auto '\n' (newline)
    console.log(x);  // with auto '\n' (newline)
}

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

    for (let test = 0; test < N; test++) {
        let x = Number(readline());
        let arr = readline().split(' ').map(Number);

        let result = 'YES';

        let first = arr[x - 1];
        let second = first ? arr[first - 1] : 0;

        if (first === 0) {
            result = 'NO';
        } else if (second === 0) {
            result = 'NO';
        }

        output(result);
    }
}


source_code:
/**
 * Problem - http://codeforces.com/contest/989/problem/A
 */

process.stdin.resume()
process.stdin.setEncoding('utf8')

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 main() {
  let input = readLine()
  process.stdout.write(doAppearInSomeCell(input))
  process.exit()
}

function doAppearInSomeCell(input) {
    if (input.length < 3) {
        return 'No'
    }

    let set = ['ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA']

    for (let i = 0 ; i < input.length ; i++) {
        let k = input.substring(i, i + 3)
        if (k.length === 3 && set.indexOf(k) !== -1) {
            return 'Yes'
        }
    }

    return 'No'
}


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

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

  if (m === 0 || m === 1) {
    console.log(1);
  }
  else if (n === m) {
    console.log(0);
  }
  else if (n / 2 > m) {
    console.log(m);
  }
  else {
    console.log(n - m);
  }

  c++;
});


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

rl.on('line', (str) => {
  if (c === 0) {
    c++;
    return;
  }

  let ans = 0;
  const arr = str.split(' ');

  for (let i = 0; i < arr.length; i++) {
    let curr = 0;

    for (let j = 0; j < arr[i].length; j++) {
      if (arr[i].charCodeAt(j) >= 65 && arr[i].charCodeAt(j) <= 90) {
        curr++;
      }
    }

    ans = Math.max(ans, curr);
  }

  console.log(ans);

  c++;
});


source_code:
let inputString = "";
let currentLine = 0;
process.stdin.on("data", (data) => {
  inputString += data;
});
process.stdin.on("end", function () {
  inputString = inputString
    .trim()
    .split("\n")
    .map((str) => str.trim());
  main();
});
function readLine() {
  return inputString[currentLine++];
}
function main() {
  const [total, front, back] = readLine()
    .split(" ")
    .map((n) => parseInt(n));
  const diff = total - front;

  if (diff > back) console.log(back + 1);
  else console.log(diff);
}


source_code:
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 noOfVertices = 20
    for(let j = 1; j <= 7; j ++) {
      var a7 = m.get(j)
      for(let i = 1; i <= 7; i ++) {
        if(i == j) continue
        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)
    }
  }
})


source_code:
function main() {
    // write code here:
    var arr=stdin[0].split(' ').map(a => Number.parseInt(a)),s;
    var min = Math.min(arr[1], arr[2]);
    s=(arr[0] <= min) ? 'Yes' : 'No';
    console.log(s);
}

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


source_code:
function funkyNumbers(n) {

    var funkyNumber = 'NO';

    var maxTriangle = maxTrianglePossible(n);

    for(let i = maxTriangle; i > 0; i--) {
        var firstTriangle = triangleNumbers(i);
        var rem = n - firstTriangle

        if(rem === 0) continue;

        var secFactor = maxTrianglePossible(rem);
        var secTriangle = triangleNumbers(secFactor);

        var triangles = firstTriangle + secTriangle;

        if(triangles == n) {
            funkyNumber = 'YES';
            break;
        }

    }

    return funkyNumber;
}

function maxTrianglePossible(n) {
    //k(k+1) / 2 = n where n is an integer
    //k(k+1) = n*2
    //k^2 + k - n*2 = 0 -> factors

    var k = Math.floor( Math.sqrt(n*2) );

    return k;

}

function triangleNumbers(x) {

    var f = ( x * (x + 1) ) / 2;

    return f;
}

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

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

    let res = funkyNumbers(n);
    console.log(res);
});


source_code:
let input = '';
let inputResolve;
let inputPromise = new Promise(resolve => inputResolve = resolve);
process.stdin.on('data', c => input += c);
process.stdin.on('end', () => inputResolve());

function For(a, b, fn) {
  let res;
  if (a < b) {
    for (let i = a; i <= b; i++) {
      if ((res = fn(i)) !== undefined) return res;
    }
  } else {
    for (let i = a; i >= b; i--) {
      if ((res = fn(i)) !== undefined) return res;
    }
  }
}

function Arr(a, b, fn, prev) {
  let p = prev || 0;
  if (a < b) return Array(b - a + 1).fill(0).map((v, i) => fn ? (p = fn(a + i, p)) : a + i);
  return Array(a - b + 1).fill(0).map((v, i) => fn ? (p = fn(a - i, p)) : a - i);
}

Object.defineProperty(Object.prototype, '$k', {
  value: function () { return Object.keys(this) }
});
Object.defineProperty(Object.prototype, '$v', {
  value: function () { return Object.values(this) }
});
Object.defineProperty(Object.prototype, '$kv', {
  value: function () { return Object.entries(this) }
});
Array.prototype.sum = function (fn) { return this.reduce((p, v) => p + (fn ? fn(v) : v), 0) }
Array.prototype.uniq = function (fn) {
  var set = new Set();
  return this.filter(v => {
    var newValue = !set.has(fn ? fn(v) : v);
    set.add(fn ? fn(v) : v);
    return newValue;
  });
}
Array.prototype.toObj = function (fn) {
  return this.map(v => fn(v)).reduce((p, v) => {
    p[v[0]] = v[1];
    return p;
  }, {})
}
Array.prototype.min = function (fn) {
  let min = Math.min(...this.map((v, i) => fn ? fn(v, i) : v));
  let i = this.findIndex((v, i) => fn ? fn(v, i) == min : v == min);
  return [this[i], i, min];
}
Array.prototype.max = function (fn) {
  let max = Math.max(...this.map((v, i) => fn ? fn(v, i) : v));
  let i = this.findIndex((v, i) => fn ? fn(v, i) == max : v == max);
  return [this[i], i, max];
}

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/); r = 0;
  let [n, k, s, t] = inp;
  n = +n;
  k = +k;
  if (t[0] == t[1]) {
    let x = Math.min([...s].filter(c => c == t[0]).length + k, n);
    console.log(x * (x - 1) / 2);
    return;
  }
  let f = Arr(0, n + 1, i => Arr(0, n + 1, i => Arr(0, n + 1, i => -1e5)));
  f[0][0][0] = 0;
  For(0, n, i => {
    For(0, k, j => {
      For(0, i, cnt0 => {
        if (f[i][j][cnt0] < 0) return;
        let e0 = s[i] == t[0];
        let e1 = s[i] == t[1];
        f[i + 1][j][cnt0 + e0] = Math.max(f[i + 1][j][cnt0 + e0], f[i][j][cnt0] + e1 * cnt0);
        f[i + 1][j + 1][cnt0 + 1] = Math.max(f[i + 1][j + 1][cnt0 + 1], f[i][j][cnt0]);
        f[i + 1][j + 1][cnt0] = Math.max(f[i + 1][j][cnt0], f[i][j][cnt0] + cnt0);
      })
    })
  })
  // console.log(f);
  console.log(Arr(0, k, i => Arr(0, n, j => f[n][i][j]).max()[0]).max()[0]);
})();


source_code:
//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↑入力 ↓出力');
	Main();
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : 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 N = nextInt();
	var alist = nextIntArray();
	var blist = nextIntArray();
	var asum = 0;
	var bsum = 0;
	for(var i = 0; i < N; i++){
		asum += alist[i];
		bsum += blist[i];
	}
	if(asum >= bsum){
		myout("Yes");
	}else{
		myout("No");
	}
}


source_code:
let i = '';
process.stdin.on('data', (c) => {
  i += c;
});
process.stdin.on('end', () => {
  const { EOL } = require('os');
  const lines = i.split(EOL);
  const [n, k] = lines[0].split(' ');
  console.log(getCandiesEaten(parseInt(n, 10), parseInt(k, 10)));
});

function getCandiesEaten(n, k) {
  if (n === 1) return 0;
  n--;
  let candies = 1;
  let sum = 2;
  let consumed = 0;
  while (n > 0) {
    while (candies <= k) {
      candies += sum;
      sum++;
      n--;
    }
    // Reduce candies to less than k
    const candiesToSubtract = candies - k;
    n -= candiesToSubtract;
    consumed += candiesToSubtract;
    candies -= candiesToSubtract;
  }
  return consumed;
}


source_code:
let data = '';
process.stdin.on('data', c => data += c);

function* nextLine() {
	let lines = data.trim().split(/\n/g);
	for(let l of lines){
		yield l.trim();
	}
}

let nl = nextLine();

nl.num = function() {
		return Number(this.next().value);
	};
nl.nums = function() {
		return this.next().value.split(/\s/g).map(Number);
	};
nl.line = function() {
		return this.next().value;
	}

const sol = () => {
	let [n, k] = nl.nums();
	let a = nl.nums();
	let r = Array(n);
	r.fill(0);
	for(let i of a){
		for(let j = i-1; j < n && r[j] === 0; j++){
			r[j] = i;
		}
	}
	console.log(r.join(' '));

};

process.stdin.on('end', sol);


source_code:
process.stdin.setEncoding('ASCII');
let string = '';
process.stdin.on('data', (data) => string += data);

const main = (input) => {
    const ns = input[0].split(' ').map(Number);
    const vol = input[1].split(' ').map(Number);

    let sum = 0, mx = 0;

    vol.forEach( (val) => {
        sum += val;
        mx = Math.max(mx, val);
    });

    if ((sum - mx) <= ns[1]) console.log("YES");
    else console.log("NO");
};

process.stdin.on('end', () => main( string.trim().split('\n') ));


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

rl.on('line', (d) => {
  console.log(Math.floor(+d / 2) + 1);
});


source_code:
var readline = require('readline');
var z = readline.createInterfrace
var r = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false
});
var b = [];
r.on('line', function (line) {
    b.push(line);
    if(b.length == 2){
        r.close();

        bain();
    }
});
function bain(){
    let a = "";
    for(let k = 0; k<b[0].length; k++){
        if(b[0].substr(k,1) != b[1].substr(k,1)){
            a += "" + 1;
        } else{
            a += "" + 0;
        }
    }
    console.log(a + "");
}


source_code:
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 nums = readLine().split(' ').map(Number);
    let [n, m] = nums; // [2, 5]
    for (let i = n + 1; i <= m; i++) {
        // console.log(i);
        if (isPrime(i) && i !== m) {
            console.log('NO');
            return;
        }
        if (isPrime(i)) {
            if (i === m) {
                // console.log(isPrime(i));
                console.log('YES');
                return;
            }
        }
    }
    console.log('NO');
}

function isPrime(number) {
    if (number <= 1) {
        return false;
    }
    for (let i = 2; i < number; i++) {
        if (number % i === 0) {
            return false;
        }
    }
    return true;
}


source_code:
const input = [];

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

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

function solver(n, m) {
  let first = 0, second = 0, copyN = n;
  let point = (m % 2 === 0) ? m : m + 1;

  while (copyN !== point/2) {
    if (copyN > point/2) {
      first += copyN - (point/2);
      copyN = point/2;
    }
    if (copyN < point/2) { copyN *= 2;  first += 1; }
  }
  first += (m % 2 === 0) ? 1 : 2;

  copyN = n;
  while (copyN !== m) {
    if (copyN < m) copyN *= 2;
    else {
      second += copyN - m;
      break;
    }
    second += 1;
  }

  return Math.min(first, second);
}

RL.on('close', () => {
  let [n, m] = input[0].split(' ').map(x => parseInt(x));
  if (n > m) {
    console.log(n - m); return;
  }
  let data = {};
  data[n] = n;

  let find = 0;
  while (true) {
    const map = {};
    for (const i of Object.keys(data)) {
      let x = parseInt(i);
      if (x - 1 >=  1 ) {
        map[x - 1] = x-1;
        if (x - 1 === m) {
          console.log(find+1); return;
        }
      }
      if (x*2 <= m*1.5) {
        map[x * 2] =x*2;
        if (x*2 === m) {
          console.log(find+1); return;
        }
      }
    }
    data = map;

    find += 1;
  }
});


source_code:
//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↑入力 ↓出力');
	Main();
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : 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 N = nextInt();
	var s = next();
	var sf = 0;
	var fs = 0;
	for(var i = 0; i < N - 1; i++){
		if(s[i] == "F" && s[i + 1] == "S"){
			fs++;
		}
		if(s[i] == "S" && s[i + 1] == "F"){
			sf++;
		}
	}
	if(sf > fs){
		myout("YES");
	}else{
		myout("NO");
	}
}


source_code:
//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↑入力 ↓出力');
  Main();
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : 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 N = nextInt();
  var s = next().split("W");
  var output = [];
  for(var i = 0; i < s.length; i++){
    if(s[i] != ""){
      output.push(s[i].length);
    }
  }
  myout(output.length);
  myout(myconv(output, 8));
}


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

  readline.question("", (_input) => {
      const input = _input.split(' ').map(Number);
              digiGame(input[0], input[1], input[2]);
  });

  const digiGame = (a, b, r) => {
      if (2 * r <= a && 2 * r <= b) {
          console.log('First');
      } else {
        console.log('Second');
      }
  };


source_code:
// Little Pigs and Wolves - https://codeforces.com/problemset/problem/116/B

const main = async () => {
  const arr = [];
  let len = [];

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

  let m, n;
  let i = 1;

  for await (const line of rl) {
    if (!len.length) {
      len = line.split(" ").map(Number);
      n = len[0];
      m = len[1];
      arr[n + 1] = [];
      arr[0] = [];
      for (let x = 0; x < m + 2; x++) {
        arr[0].push(".");
        arr[n + 1].push(".");
      }
    } else {
      if (i < n) {
        arr[i] = ["."];
        arr[i].push(...line.split(""));
        arr[i].push(".");
      } else {
        arr[i] = ["."];
        arr[i].push(...line.split(""));
        arr[i].push(".");
        rl.close();
      }
      i++;
    }
  }
  runGame(arr, m, n);
};

const runGame = (arr, m, n) => {
  let output = 0;

  for (let i = 1; i < n + 1; i++) {
    for (let j = 1; j < m + 1; j++) {
      if (arr[i][j] == "W") {
        if (
          arr[i - 1][j] == "P" ||
          arr[i + 1][j] == "P" ||
          arr[i][j - 1] == "P" ||
          arr[i][j + 1] == "P"
        ) {
          output++;
        }
      }
    }
  }
  console.log(output);
};

main();