var inputs = readline();
var count = inputs.split(' ')[0];
var skill = inputs.split(' ')[1];

function main(isDone, solved, problems){
    //print(skill, '|',problems, '|', solved, '|',isDone);
    if(count == 0)
        return 0;

    while( problems.length > 0 && !isDone){
        if(parseInt(problems[0]) <= skill){
            //print('deleted', problems[0])
            problems.splice(0, 1);
            solved++;
        } else if(parseInt(problems[problems.length-1]) <= skill){
            //print('deleted', problems[problems.length-1])
            problems.splice(problems.length-1, 1)
            solved++;
        } else if(parseInt(problems[problems.length-1]) > skill && parseInt(problems[0]) > skill){
            isDone = true;
        }
        //print(problems,isDone, problems[problems.length-1], problems[0])
    }
    return solved;
}
while(inputs = readline()){
    var problems = inputs.split(' ');
    var isDone = false;
    var solved = 0;

    print(main(isDone, solved, problems));
}


(function() {
    'use strict';
    let n = readline().split(' ').map(Number);
    let x = readline().split(' ').map(Number);
    let y = 0;
    let i = 0;
    while(x[i] <= n[1]) {
            y++;
            i++;
    }
    x.splice(0, y);
    let m = x.length - 1;
    while(x[m] <= n[1]) {
        y++;
        m--;
    }
    print(y);
}());


var s1=readline().split(" ");
var s2=readline().split(" ");
var n=parseInt(s1[0]),k=parseInt(s1[1]),t=0;
var f=0;
for(var i=0;i<n;i++){
	if(parseInt(s2[i])<=k){t++;}
	else{f=1;break;}
}
if(f===1){

		for(var y=n-1;y>=0;y--){
			if(parseInt(s2[y])<=k){t++;}
			else{break;}
		}

}

print(t);


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) {
    c++;
    [n, k] = d.split(' ').map(Number);
    return;
  }

  const arr = d.split(' ').map(Number);
  let ans = 0;
  let L = 0;
  let R = arr.length - 1;

  while (L <= R) {
    if (arr[L] <= k) {
      ans++;
      L++;
    }
    else if (arr[R] <= k) {
      ans++;
      R--;
    }
    else {
      break;
    }
  }

  console.log(ans);

  c++;
});


print(function(a, b) {
	var ans = 0;
	for (var i = 0; i < a.length; i += 2) {
		if (a[i] === b[i]) continue;
		if (a[i] === '8') {
			if (b[i] === '[') ans++;
			else ans--;
		}
		if (a[i] === '[') {
			if (b[i] === '(') ans++;
			else ans--;
		}
		if (a[i] === '(') {
			if (b[i] === '8') ans++;
			else ans--;
		}
	}
	if (ans === 0) return 'TIE';
	return 'TEAM ' + (ans > 0 ? 1 : 2) + ' WINS';
}(readline(), readline()));


'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].y === a[3].y
        && a[3].y === a[5].y
        && a[0].y === a[1].y
        && a[1].y === a[2].y) {
        printResult('respectable');
    } else {
        printResult('ugly');
    }
};


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


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


'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]);
    }

    // console.log('eee',arrPoints[0].x);
    // const result = eightPointSet(arrPoints);
    eightPointSet(arrPoints);
    // printResult(result.toString());
}

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

const eightPointSet = (a) => {
    a.sort(comparePoints);
    if (a[0].x === a[1].x && a[1].x === a[2].x
        && a[2].x !== a[3].x
        && a[3].x === a[4].x
        && a[4].x !== a[5].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[5].y !== a[1].y
        && a[1].y === a[6].y
        && a[6].y !== a[2].y
        && a[2].y === a[4].y && a[4].y === a[7].y) {
        printResult('respectable');
    } else {
        printResult('ugly');
    }
};


function n (f) { return f == Math.floor(f); }

;(function () {

	var k = +readline();
	var l = +readline();

	var t = k;
	var i = 1;
	while (t < l) {
		t *= k;
		i++;
	}

	if ( t == l) {
		print('YES');
		print(i - 1);
		return;
	}

	print('NO');

}).call(this);


var k = +readline(), l = +readline();
var x = k;
for( var i=0; x<l; x=x*k, i++ ) ;
if( x==l ){
	print( 'YES\n' + i );
}else{
	print( 'NO' );
}


var importanceInPetriciumusCifera = function ( base, number ) {
  var rest,
    importance;
  rest = number;
  importance = 0;
  while ( rest % base === 0 && rest > base) {

    rest /= base;
    ++importance;
  }
  if ( rest === base ) {
    return importance;
  }
};

var k = parseInt( readline(), 10 );
var l = parseInt( readline(), 10 );
var importance = importanceInPetriciumusCifera( k, l );
if ( typeof importance !== "undefined" ) {
  print( "YES" );
  print( importance );
} else {
  print( "NO" );
}


var i = 0;
var s = parseInt(readline());
var e = parseInt(readline());
var curr = s;

(function res() {
	while (curr <= e) {
		if (curr == e) {
			print('YES');
			print(i);
			return;
		} else {
			curr *= s;
			i++;
		}
	}
	print('NO');
})()


var isInPetriciumusCifera = function ( base, number ) {
  var rest = number;
  while ( rest % base === 0) {
    rest /= base;
  }
  return rest === 1;
};

var k = parseInt( readline(), 10 );
var l = parseInt( readline(), 10 );
if ( isInPetriciumusCifera( k, l ) ) {
  print( "YES" );
} else {
  print( "NO" );
}


var c = {};

function T(i, n) {
  if (i > n / 2) i = n - i;
  if (i === 0) return 1;
  if (c[i + '+' + n]) return c[i + '+' + n];
  if (i == 1) {
    return n;
  }
  var ans = 0;
  for (var j = 1; j < n; j++) {
    ans += T(i - 1, j);
  }
  return c[i + '+' + n] = ans;
}

print(function(n, m, t) {
  var a = [];
  for (var i = 1; i <= m; i++) {

    var j = t - i;

    if (j <= n && j >= 4) {
      a.push([T(i, m), T(j, n)]);
    }
  }

  var b = [];
  var x = 0;
  a.forEach(function(v){
  	if(v[0]*v[1]>1e15){
  		var xx=v[1].toString();
  		var j=xx.length-1;
  		// print(v)
  		for(var i=1; i<v[1]; i*=10){
  			b.push( v[0]*xx[j--]*i )
  		}
  	}else{
  		b.push(v[0]*v[1]);
  	}
  });
  return b.reduce(function(a,b){
  	// return a+b
  	//print(a,b)
  	a=a.toString();
  	b=b.toString();
  	var sum=[];
  	var i=a.length-1;
  	var j=b.length-1;
  	var c=0;
  	while(i>=0||j>=0){
  		var k= +(a[i]||0) +  +(b[j]||0) + c;
  		c=~~(k/10);
  		sum.push(k%10);
  		i--;
  		j--;
  	}
  	if(c>0){
	  	sum.push(c)
  	}
  	return sum.reverse().join('');
  });
}.apply(0, readline().split(' ').map(Number)));


var c = {};
function T(i, n) {
  if (i > n / 2) i = n - i;
  if (i === 0) return 1;
  if (c[i + '+' + n]) return c[i + '+' + n];
  if (i == 1) {
    return n;
  }
  var ans = 0;
  for (var j = 1; j < n; j++) {
    ans += T(i - 1, j);
  }
  return c[i + '+' + n] = ans;
}

const MAX = Math.pow(2,53)-5;
print(function(n, m, t) {

  var a = [];

  for (var i = 1; i <= m; i++) {
    var j = t - i;
    if (j <= n && j >= 4) {
      var x = T(i, m);
      var y = T(j, n);
      if(x*y>MAX){
        x.toString().split('').map(Number).reverse().forEach(function(v, i){
          a.push(x*v*Math.pow(10, i));
        });
      }else{
        a.push(x*y);
      }
    }
  }

  return a.map(function(v){
    return v.toString().split('').map(Number);
  }).reduce(function(a,b){
    var sum=[];
    var c=0;
    for(i=a.length-1, j=b.length-1; i>=0||j>=0; i--,j--){
      var v = (a[i]||0) +  (b[j]||0) + c;
      c=Math.floor(v/10);
      sum.push(v%10);
    }
    if(c>0){
      sum.push(c);
    }
    return sum.reverse();
  }).join('');

}.apply(0, readline().split(' ').map(Number)));


var c={};
function T(i, n){
  if(i>n/2) i=n-i;
  if(c[i+'+'+n]) return c[i+'+'+n];
  if(i==1){
    return n;
  }
  var ans=0;
  for(var j=1; j<n; j++){
    ans+=T(i-1, j);
  }
  return c[i+'+'+n]=ans;
}

print(function(n, m, t){
  var ans=0;
  for(var i=1; i<=m; i++){
    var j=t-i;
    if(j<=n&&j>=4){
      ans+=T(i, m)*T(j, n);
    }
  }
  return ans;
}.apply(0, readline().split(' ').map(Number)));


var c = {};

function T(i, n) {
  if (i > n / 2) i = n - i;
  if (i === 0) return 1;
  if (c[i + '+' + n]) return c[i + '+' + n];
  if (i == 1) {
    return n;
  }
  var ans = 0;
  for (var j = 1; j < n; j++) {
    ans += T(i - 1, j);
  }
  return c[i + '+' + n] = ans;
}

print(function(n, m, t) {
  var ans = 0;
  for (var i = 1; i <= m; i++) {

    var j = t - i;

    if (j <= n && j >= 4) {
      ans += T(i, m) * T(j, n);
    }
  }
  return ans;
}.apply(0, readline().split(' ').map(Number)));


var c = {};

function T(i, n) {
  if (i > n / 2) i = n - i;
  if (i === 0) return 1;
  if (c[i + '+' + n]) return c[i + '+' + n];
  if (i == 1) {
    return n;
  }
  var ans = 0;
  for (var j = 1; j < n; j++) {
    ans += T(i - 1, j);
  }
  return c[i + '+' + n] = ans;
}

print(function(n, m, t) {
  var a = [];
  for (var i = 1; i <= m; i++) {

    var j = t - i;

    if (j <= n && j >= 4) {
      a.push(T(i, m));
    }
  }

  var b = [];
  var x = 0;
  a.forEach(function(v){
  	if(v>1e8){
  		var xx=v.toString();
  		var j=xx.length-1;
  		for(var i=1; i<v; i*=10){
  			b.push( v*xx[j--]*i )
  		}
  	}else{
  		b.push(v*v);
  	}
  });

  return b.reduce(function(a,b){
  	//print(a,b)
  	a=a.toString();
  	b=b.toString();
  	var sum=[];
  	var i=a.length-1;
  	var j=b.length-1;
  	var c=0;
  	while(i>=0||j>=0){
  		var k= +(a[i]||0) +  +(b[j]||0) + c;
  		c=~~(k/10);
  		sum.push(k%10);
  		i--;
  		j--;
  	}
  	if(c>0){
	  	sum.push(c)
  	}
  	return sum.reverse().join('');
  });
}.apply(0, readline().split(' ').map(Number)));


print(function(n, m, t) {
  var a = [];
  for (var i = 1; i <= m; i++) {

    var j = t - i;

    if (j <= n && j >= 4) {
      a.push([T(i, m), T(j, n)]);
    }
  }

  var b = [];
  var x = 0;
  a.forEach(function(v){
  	if(v[0]>1e8||v[1]>1e8){
  		var xx=v[1].toString();
  		var j=xx.length-1;
  		for(var i=1; i<v[1]; i*=10){
  			b.push( v[0]*xx[j--]*i )
  		}
  	}else{
  		b.push(v[0]*v[1]);
  	}
  });

  return b.reduce(function(a,b){
  	//print(a,b)
  	a=a.toString();
  	b=b.toString();
  	var sum=[];
  	var i=a.length-1;
  	var j=b.length-1;
  	var c=0;
  	while(i>=0||j>=0){
  		var k= +(a[i]||0) +  +(b[j]||0) + c;
  		c=~~(k/10);
  		sum.push(k%10);
  		i--;
  		j--;
  	}
  	if(c>0){
	  	sum.push(c)
  	}
  	return sum.reverse().join('');
  });
}.apply(0, readline().split(' ').map(Number)));


n = readline();

var player1 = 1, player2 = 2, watcher = 3, res = 'YES';

for (var i = 0; i < n; i++) {
	winner = readline();

	if (watcher == winner) {
		res = 'NO';
		break;
	} else if (player1 == winner) {
		var temp = watcher;
		watcher = player2;
		player2 = temp;
	} else if (player2 == winner) {
		var temp = watcher;
		watcher = player1;
		player1 = temp;
	};
};

print(res);


n=readline();
a=1;
b=2;
c=3;
r='YES';
for(i=0; i<n; i++) {
    x = readline();
    if(x==c){
        r='NO';
        break;
    }
    if(a==x){
        a=b;
        b=c;
        c=a;
        a=x;
    } else {
        b=a;
        a=c;
        c=b;
        b=x;
    }
}
print(r);


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

const distance = (x1, x2, y1, y2) => {
  return Math.sqrt(Math.abs(x1 - x2)**2 + Math.abs(y1 - y2)**2);
}

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

  const [x, y] = d.split(' ').map(Number);
  const white = distance(1, x, 1, y);
  const black = distance(m, x, m, y);

  if (black < white) {
    console.log('Black');
  }
  else {
    console.log('White');
  }

  c++;
});


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 = nl.num();
	let [x, y] = nl.nums();

	let w = Math.max(x-1,y-1);
	let b = Math.max(n-x,n-y);
	console.log(w<=b?'White':'Black');

};

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


var n = +readline();
var s = readline().split(' ').map(v=>+v);

var w = Math.max(s[0] - 1, s[1] - 1);
var b = Math.max(n - s[0], n - s[1]);

print(b < w ? 'Black' : 'White');


const readline = require('readline');

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

var convertToInt = function(str){
   let n = str.length;
   let ans = 0;
   for(let i = 0; i < n;i++){
       ans = ans * 10 + (str[i] - '0');

   }
   return ans;
}
var counter = 0, N;

rl.on('line', (input) => {
    if (counter == 0) {
        N = BigInt(input);
        counter++;
    }
    else {
        //let cont = input.split(' ').map(item => parseInt(item));
        //let x = cont[0], y = cont[1];
        let cont = input.split(' ');
        //x=parseInt(cont[0]), y = parseInt(cont[1]);
        //x=Number(cont[0]), y=Number(cont[1]);
        //x = convertToInt(cont[0]), y = convertToInt(cont[1]);
        x = BigInt(cont[0]), y = BigInt(cont[1]);

        let whiteMoves = 0n, blackMoves = 0n, minDiff=0n, maxDiff=0n;
        console.log("N = %d  x = %d  y = %d  cont[0] = %s  cont[1] = %s", N, x, y, cont[0], cont[1]);
        //calculate white moves
       /* minDiff = Math.min(x - 1n, y - 1n);
        maxDiff = Math.max(x - 1n, y - 1n);
        whiteMoves=minDiff+(maxDiff-minDiff);
        minDiff = Math.min(N - x, N - y);
        maxDiff = Math.max(N - x, N - y);
        blackMoves=minDiff+(maxDiff-minDiff);*/
        let help1 = x - 1n, help2 = y - 1n;
        minDiff = (help1 > help2) ? help2 : help1;
        maxDiff = (help1 < help2) ? help2 : help1;
        whiteMoves=minDiff+(maxDiff-minDiff);

        help1 = N - x, help2 = N - y;
        minDiff = (help1 > help2) ? help2 : help1;
        maxDiff = (help1 < help2) ? help2 : help1;
        blackMoves=minDiff+(maxDiff-minDiff);

        console.log(whiteMoves<=blackMoves?"White":"Black");
        rl.close();
    }
});


/*
 *  big.js v5.2.2
 *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
 *  Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
 *  https://github.com/MikeMcl/big.js/LICENCE
 */

  'use strict';
  var Big,

/************************************** EDITABLE DEFAULTS *****************************************/

    // The default values below must be integers within the stated ranges.

    /*
     * The maximum number of decimal places (DP) of the results of operations involving division:
     * div and sqrt, and pow with negative exponents.
     */
    DP = 20,          // 0 to MAX_DP

    /*
     * The rounding mode (RM) used when rounding to the above decimal places.
     *
     *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)
     *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)
     *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
     *  3  Away from zero.                                  (ROUND_UP)
     */
    RM = 1,             // 0, 1, 2 or 3

    // The maximum value of DP and Big.DP.
    MAX_DP = 1E6,       // 0 to 1000000

    // The maximum magnitude of the exponent argument to the pow method.
    MAX_POWER = 1E6,    // 1 to 1000000

    /*
     * The negative exponent (NE) at and beneath which toString returns exponential notation.
     * (JavaScript numbers: -7)
     * -1000000 is the minimum recommended exponent value of a Big.
     */
    NE = -7,            // 0 to -1000000

    /*
     * The positive exponent (PE) at and above which toString returns exponential notation.
     * (JavaScript numbers: 21)
     * 1000000 is the maximum recommended exponent value of a Big.
     * (This limit is not enforced or checked.)
     */
    PE = 21,            // 0 to 1000000

/**************************************************************************************************/

    // Error messages.
    NAME = '[big.js] ',
    INVALID = NAME + 'Invalid ',
    INVALID_DP = INVALID + 'decimal places',
    INVALID_RM = INVALID + 'rounding mode',
    DIV_BY_ZERO = NAME + 'Division by zero',

    // The shared prototype object.
    P = {},
    UNDEFINED = void 0,
    NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;

  /*
   * Create and return a Big constructor.
   *
   */
  function _Big_() {

    /*
     * The Big constructor and exported function.
     * Create and return a new instance of a Big number object.
     *
     * n {number|string|Big} A numeric value.
     */
    function Big(n) {
      var x = this;

      // Enable constructor usage without new.
      if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);

      // Duplicate.
      if (n instanceof Big) {
        x.s = n.s;
        x.e = n.e;
        x.c = n.c.slice();
      } else {
        parse(x, n);
      }

      /*
       * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
       * points to Object.
       */
      x.constructor = Big;
    }

    Big.prototype = P;
    Big.DP = DP;
    Big.RM = RM;
    Big.NE = NE;
    Big.PE = PE;
    Big.version = '5.2.2';

    return Big;
  }

  /*
   * Parse the number or string value passed to a Big constructor.
   *
   * x {Big} A Big number instance.
   * n {number|string} A numeric value.
   */
  function parse(x, n) {
    var e, i, nl;

    // Minus zero?
    if (n === 0 && 1 / n < 0) n = '-0';
    else if (!NUMERIC.test(n += '')) throw Error(INVALID + 'number');

    // Determine sign.
    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;

    // Decimal point?
    if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');

    // Exponential form?
    if ((i = n.search(/e/i)) > 0) {

      // Determine exponent.
      if (e < 0) e = i;
      e += +n.slice(i + 1);
      n = n.substring(0, i);
    } else if (e < 0) {

      // Integer.
      e = n.length;
    }

    nl = n.length;

    // Determine leading zeros.
    for (i = 0; i < nl && n.charAt(i) == '0';) ++i;

    if (i == nl) {

      // Zero.
      x.c = [x.e = 0];
    } else {

      // Determine trailing zeros.
      for (; nl > 0 && n.charAt(--nl) == '0';);
      x.e = e - i - 1;
      x.c = [];

      // Convert string to array of digits without leading/trailing zeros.
      for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);
    }

    return x;
  }

  /*
   * Round Big x to a maximum of dp decimal places using rounding mode rm.
   * Called by stringify, P.div, P.round and P.sqrt.
   *
   * x {Big} The Big to round.
   * dp {number} Integer, 0 to MAX_DP inclusive.
   * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
   * [more] {boolean} Whether the result of division was truncated.
   */
  function round(x, dp, rm, more) {
    var xc = x.c,
      i = x.e + dp + 1;

    if (i < xc.length) {
      if (rm === 1) {

        // xc[i] is the digit after the digit that may be rounded up.
        more = xc[i] >= 5;
      } else if (rm === 2) {
        more = xc[i] > 5 || xc[i] == 5 &&
          (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);
      } else if (rm === 3) {
        more = more || !!xc[0];
      } else {
        more = false;
        if (rm !== 0) throw Error(INVALID_RM);
      }

      if (i < 1) {
        xc.length = 1;

        if (more) {

          // 1, 0.1, 0.01, 0.001, 0.0001 etc.
          x.e = -dp;
          xc[0] = 1;
        } else {

          // Zero.
          xc[0] = x.e = 0;
        }
      } else {

        // Remove any digits after the required decimal places.
        xc.length = i--;

        // Round up?
        if (more) {

          // Rounding up may mean the previous digit has to be rounded up.
          for (; ++xc[i] > 9;) {
            xc[i] = 0;
            if (!i--) {
              ++x.e;
              xc.unshift(1);
            }
          }
        }

        // Remove trailing zeros.
        for (i = xc.length; !xc[--i];) xc.pop();
      }
    } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
      throw Error(INVALID_RM);
    }

    return x;
  }

  /*
   * Return a string representing the value of Big x in normal or exponential notation.
   * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
   *
   * x {Big}
   * id? {number} Caller id.
   *         1 toExponential
   *         2 toFixed
   *         3 toPrecision
   *         4 valueOf
   * n? {number|undefined} Caller's argument.
   * k? {number|undefined}
   */
  function stringify(x, id, n, k) {
    var e, s,
      Big = x.constructor,
      z = !x.c[0];

    if (n !== UNDEFINED) {
      if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
        throw Error(id == 3 ? INVALID + 'precision' : INVALID_DP);
      }

      x = new Big(x);

      // The index of the digit that may be rounded up.
      n = k - x.e;

      // Round?
      if (x.c.length > ++k) round(x, n, Big.RM);

      // toFixed: recalculate k as x.e may have changed if value rounded up.
      if (id == 2) k = x.e + n + 1;

      // Append zeros?
      for (; x.c.length < k;) x.c.push(0);
    }

    e = x.e;
    s = x.c.join('');
    n = s.length;

    // Exponential notation?
    if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {
      s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;

    // Normal notation.
    } else if (e < 0) {
      for (; ++e;) s = '0' + s;
      s = '0.' + s;
    } else if (e > 0) {
      if (++e > n) for (e -= n; e--;) s += '0';
      else if (e < n) s = s.slice(0, e) + '.' + s.slice(e);
    } else if (n > 1) {
      s = s.charAt(0) + '.' + s.slice(1);
    }

    return x.s < 0 && (!z || id == 4) ? '-' + s : s;
  }

  // Prototype/instance methods

  /*
   * Return a new Big whose value is the absolute value of this Big.
   */
  P.abs = function () {
    var x = new this.constructor(this);
    x.s = 1;
    return x;
  };

  /*
   * Return 1 if the value of this Big is greater than the value of Big y,
   *       -1 if the value of this Big is less than the value of Big y, or
   *        0 if they have the same value.
  */
  P.cmp = function (y) {
    var isneg,
      x = this,
      xc = x.c,
      yc = (y = new x.constructor(y)).c,
      i = x.s,
      j = y.s,
      k = x.e,
      l = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;

    // Signs differ?
    if (i != j) return i;

    isneg = i < 0;

    // Compare exponents.
    if (k != l) return k > l ^ isneg ? 1 : -1;

    j = (k = xc.length) < (l = yc.length) ? k : l;

    // Compare digit by digit.
    for (i = -1; ++i < j;) {
      if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
    }

    // Compare lengths.
    return k == l ? 0 : k > l ^ isneg ? 1 : -1;
  };

  /*
   * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
   * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.div = function (y) {
    var x = this,
      Big = x.constructor,
      a = x.c,                  // dividend
      b = (y = new Big(y)).c,   // divisor
      k = x.s == y.s ? 1 : -1,
      dp = Big.DP;

    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);

    // Divisor is zero?
    if (!b[0]) throw Error(DIV_BY_ZERO);

    // Dividend is 0? Return +-0.
    if (!a[0]) return new Big(k * 0);

    var bl, bt, n, cmp, ri,
      bz = b.slice(),
      ai = bl = b.length,
      al = a.length,
      r = a.slice(0, bl),   // remainder
      rl = r.length,
      q = y,                // quotient
      qc = q.c = [],
      qi = 0,
      d = dp + (q.e = x.e - y.e) + 1;    // number of digits of the result

    q.s = k;
    k = d < 0 ? 0 : d;

    // Create version of divisor with leading zero.
    bz.unshift(0);

    // Add zeros to make remainder as long as divisor.
    for (; rl++ < bl;) r.push(0);

    do {

      // n is how many times the divisor goes into current remainder.
      for (n = 0; n < 10; n++) {

        // Compare divisor and remainder.
        if (bl != (rl = r.length)) {
          cmp = bl > rl ? 1 : -1;
        } else {
          for (ri = -1, cmp = 0; ++ri < bl;) {
            if (b[ri] != r[ri]) {
              cmp = b[ri] > r[ri] ? 1 : -1;
              break;
            }
          }
        }

        // If divisor < remainder, subtract divisor from remainder.
        if (cmp < 0) {

          // Remainder can't be more than 1 digit longer than divisor.
          // Equalise lengths using divisor with extra leading zero?
          for (bt = rl == bl ? b : bz; rl;) {
            if (r[--rl] < bt[rl]) {
              ri = rl;
              for (; ri && !r[--ri];) r[ri] = 9;
              --r[ri];
              r[rl] += 10;
            }
            r[rl] -= bt[rl];
          }

          for (; !r[0];) r.shift();
        } else {
          break;
        }
      }

      // Add the digit n to the result array.
      qc[qi++] = cmp ? n : ++n;

      // Update the remainder.
      if (r[0] && cmp) r[rl] = a[ai] || 0;
      else r = [a[ai]];

    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);

    // Leading zero? Do not remove if result is simply zero (qi == 1).
    if (!qc[0] && qi != 1) {

      // There can't be more than one zero.
      qc.shift();
      q.e--;
    }

    // Round?
    if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);

    return q;
  };

  /*
   * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
   */
  P.eq = function (y) {
    return !this.cmp(y);
  };

  /*
   * Return true if the value of this Big is greater than the value of Big y, otherwise return
   * false.
   */
  P.gt = function (y) {
    return this.cmp(y) > 0;
  };

  /*
   * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
   * return false.
   */
  P.gte = function (y) {
    return this.cmp(y) > -1;
  };

  /*
   * Return true if the value of this Big is less than the value of Big y, otherwise return false.
   */
  P.lt = function (y) {
    return this.cmp(y) < 0;
  };

  /*
   * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
   * return false.
   */
  P.lte = function (y) {
    return this.cmp(y) < 1;
  };

  /*
   * Return a new Big whose value is the value of this Big minus the value of Big y.
   */
  P.minus = P.sub = function (y) {
    var i, j, t, xlty,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.plus(y);
    }

    var xc = x.c.slice(),
      xe = x.e,
      yc = y.c,
      ye = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) {

      // y is non-zero? x is non-zero? Or both are zero.
      return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);
    }

    // Determine which is the bigger number. Prepend zeros to equalise exponents.
    if (a = xe - ye) {

      if (xlty = a < 0) {
        a = -a;
        t = xc;
      } else {
        ye = xe;
        t = yc;
      }

      t.reverse();
      for (b = a; b--;) t.push(0);
      t.reverse();
    } else {

      // Exponents equal. Check digit by digit.
      j = ((xlty = xc.length < yc.length) ? xc : yc).length;

      for (a = b = 0; b < j; b++) {
        if (xc[b] != yc[b]) {
          xlty = xc[b] < yc[b];
          break;
        }
      }
    }

    // x < y? Point xc to the array of the bigger number.
    if (xlty) {
      t = xc;
      xc = yc;
      yc = t;
      y.s = -y.s;
    }

    /*
     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
     * needs to start at yc.length.
     */
    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;

    // Subtract yc from xc.
    for (b = i; j > a;) {
      if (xc[--j] < yc[j]) {
        for (i = j; i && !xc[--i];) xc[i] = 9;
        --xc[i];
        xc[j] += 10;
      }

      xc[j] -= yc[j];
    }

    // Remove trailing zeros.
    for (; xc[--b] === 0;) xc.pop();

    // Remove leading zeros and adjust exponent accordingly.
    for (; xc[0] === 0;) {
      xc.shift();
      --ye;
    }

    if (!xc[0]) {

      // n - n = +0
      y.s = 1;

      // Result must be zero.
      xc = [ye = 0];
    }

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a new Big whose value is the value of this Big modulo the value of Big y.
   */
  P.mod = function (y) {
    var ygtx,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    if (!y.c[0]) throw Error(DIV_BY_ZERO);

    x.s = y.s = 1;
    ygtx = y.cmp(x) == 1;
    x.s = a;
    y.s = b;

    if (ygtx) return new Big(x);

    a = Big.DP;
    b = Big.RM;
    Big.DP = Big.RM = 0;
    x = x.div(y);
    Big.DP = a;
    Big.RM = b;

    return this.minus(x.times(y));
  };

  /*
   * Return a new Big whose value is the value of this Big plus the value of Big y.
   */
  P.plus = P.add = function (y) {
    var t,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.minus(y);
    }

    var xe = x.e,
      xc = x.c,
      ye = y.e,
      yc = y.c;

    // Either zero? y is non-zero? x is non-zero? Or both are zero.
    if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);

    xc = xc.slice();

    // Prepend zeros to equalise exponents.
    // Note: reverse faster than unshifts.
    if (a = xe - ye) {
      if (a > 0) {
        ye = xe;
        t = yc;
      } else {
        a = -a;
        t = xc;
      }

      t.reverse();
      for (; a--;) t.push(0);
      t.reverse();
    }

    // Point xc to the longer array.
    if (xc.length - yc.length < 0) {
      t = yc;
      yc = xc;
      xc = t;
    }

    a = yc.length;

    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
    for (b = 0; a; xc[a] %= 10) b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;

    // No need to check for zero, as +x + +y != 0 && -x + -y != 0

    if (b) {
      xc.unshift(b);
      ++ye;
    }

    // Remove trailing zeros.
    for (a = xc.length; xc[--a] === 0;) xc.pop();

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a Big whose value is the value of this Big raised to the power n.
   * If n is negative, round to a maximum of Big.DP decimal places using rounding
   * mode Big.RM.
   *
   * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
   */
  P.pow = function (n) {
    var x = this,
      one = new x.constructor(1),
      y = one,
      isneg = n < 0;

    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) throw Error(INVALID + 'exponent');
    if (isneg) n = -n;

    for (;;) {
      if (n & 1) y = y.times(x);
      n >>= 1;
      if (!n) break;
      x = x.times(x);
    }

    return isneg ? one.div(y) : y;
  };

  /*
   * Return a new Big whose value is the value of this Big rounded using rounding mode rm
   * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
   * multiple of 10**-dp.
   * If dp is not specified, round to 0 decimal places.
   * If rm is not specified, use Big.RM.
   *
   * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
   * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
   */
  P.round = function (dp, rm) {
    var Big = this.constructor;
    if (dp === UNDEFINED) dp = 0;
    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) throw Error(INVALID_DP);
    return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
  };

  /*
   * Return a new Big whose value is the square root of the value of this Big, rounded, if
   * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.sqrt = function () {
    var r, c, t,
      x = this,
      Big = x.constructor,
      s = x.s,
      e = x.e,
      half = new Big(0.5);

    // Zero?
    if (!x.c[0]) return new Big(x);

    // Negative?
    if (s < 0) throw Error(NAME + 'No square root');

    // Estimate.
    s = Math.sqrt(x + '');

    // Math.sqrt underflow/overflow?
    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
    if (s === 0 || s === 1 / 0) {
      c = x.c.join('');
      if (!(c.length + e & 1)) c += '0';
      s = Math.sqrt(c);
      e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
      r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);
    } else {
      r = new Big(s);
    }

    e = r.e + (Big.DP += 4);

    // Newton-Raphson iteration.
    do {
      t = r;
      r = half.times(t.plus(x.div(t)));
    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));

    return round(r, Big.DP -= 4, Big.RM);
  };

  /*
   * Return a new Big whose value is the value of this Big times the value of Big y.
   */
  P.times = P.mul = function (y) {
    var c,
      x = this,
      Big = x.constructor,
      xc = x.c,
      yc = (y = new Big(y)).c,
      a = xc.length,
      b = yc.length,
      i = x.e,
      j = y.e;

    // Determine sign of result.
    y.s = x.s == y.s ? 1 : -1;

    // Return signed 0 if either 0.
    if (!xc[0] || !yc[0]) return new Big(y.s * 0);

    // Initialise exponent of result as x.e + y.e.
    y.e = i + j;

    // If array xc has fewer digits than yc, swap xc and yc, and lengths.
    if (a < b) {
      c = xc;
      xc = yc;
      yc = c;
      j = a;
      a = b;
      b = j;
    }

    // Initialise coefficient array of result with zeros.
    for (c = new Array(j = a + b); j--;) c[j] = 0;

    // Multiply.

    // i is initially xc.length.
    for (i = b; i--;) {
      b = 0;

      // a is yc.length.
      for (j = a + i; j > i;) {

        // Current sum of products at this digit position, plus carry.
        b = c[j] + yc[i] * xc[j - i - 1] + b;
        c[j--] = b % 10;

        // carry
        b = b / 10 | 0;
      }

      c[j] = b;
    }

    // Increment result exponent if there is a final carry, otherwise remove leading zero.
    if (b) ++y.e;
    else c.shift();

    // Remove trailing zeros.
    for (i = c.length; !c[--i];) c.pop();
    y.c = c;

    return y;
  };

  /*
   * Return a string representing the value of this Big in exponential notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   */
  P.toExponential = function (dp) {
    return stringify(this, 1, dp, dp);
  };

  /*
   * Return a string representing the value of this Big in normal notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   *
   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
   */
  P.toFixed = function (dp) {
    return stringify(this, 2, dp, this.e + dp);
  };

  /*
   * Return a string representing the value of this Big rounded to sd significant digits using
   * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
   * the integer part of the value in normal notation.
   *
   * sd {number} Integer, 1 to MAX_DP inclusive.
   */
  P.toPrecision = function (sd) {
    return stringify(this, 3, sd, sd - 1);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Omit the sign for negative zero.
   */
  P.toString = function () {
    return stringify(this);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Include the sign for negative zero.
   */
  P.valueOf = P.toJSON = function () {
    return stringify(this, 4);
  };

  // Export

  Big = _Big_();

  Big['default'] = Big.Big = Big;

  //AMD.
  if (typeof define === 'function' && define.amd) {
    define(function () { return Big; });

  // Node and other CommonJS-like environments that support module.exports.
  } else if (typeof module !== 'undefined' && module.exports) {
    module.exports = Big;

  //Browser.
  } else {
    GLOBAL.Big = Big;
  }
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.elem = function(funParse) {
	return funParse(this.next().value);
};
nl.array = function(funParse) {
		return this.next().value.split(/\s/g).map(funParse||(x => x));
	};
nl.line = function() {
		return this.next().value;
	}

const sol = () => {
	let n = nl.elem(Big);
	let [x, y] = nl.array(Big);
	let wx = x.minus(Big(1));
	let wy = y.minus(Big(1));
	let bx = n.minus(x);
	let by = n.minus(y);

	let w = wx.lte(wy)?wx:wy;
	let b = bx.lte(by)?bx:by;
	console.log(w.lte(b)?'White':'Black');

};

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


const readline = require('readline');

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

var convertToInt = function(str){
   let n = str.length;
   let ans = 0;
   for(let i = 0; i < n;i++){
       ans = ans * 10 + (str[i] - '0');

   }
   return ans;
}
var counter = 0, N;

rl.on('line', (input) => {
    if (counter == 0) {
        N = BigInt(input);
        counter++;
    }
    else {
        //let cont = input.split(' ').map(item => parseInt(item));
        //let x = cont[0], y = cont[1];
        let cont = input.split(' ');
        //x=parseInt(cont[0]), y = parseInt(cont[1]);
        //x=Number(cont[0]), y=Number(cont[1]);
        //x = convertToInt(cont[0]), y = convertToInt(cont[1]);
        x = BigInt(cont[0]), y = BigInt(cont[1]);

        let whiteMoves = 0n, blackMoves = 0n, minDiff=0n, maxDiff=0n;
        //console.log("N = %d  x = %d  y = %d  cont[0] = %s  cont[1] = %s", N, x, y, cont[0], cont[1]);
        //calculate white moves
       /* minDiff = Math.min(x - 1n, y - 1n);
        maxDiff = Math.max(x - 1n, y - 1n);
        whiteMoves=minDiff+(maxDiff-minDiff);
        minDiff = Math.min(N - x, N - y);
        maxDiff = Math.max(N - x, N - y);
        blackMoves=minDiff+(maxDiff-minDiff);*/
        let help1 = x - 1n, help2 = y - 1n;
        minDiff = (help1 > help2) ? help2 : help1;
        maxDiff = (help1 < help2) ? help2 : help1;
        whiteMoves=minDiff+(maxDiff-minDiff);

        help1 = N - x, help2 = N - y;
        minDiff = (help1 > help2) ? help2 : help1;
        maxDiff = (help1 < help2) ? help2 : help1;
        blackMoves=minDiff+(maxDiff-minDiff);

        console.log(whiteMoves<=blackMoves?"White":"Black");
        rl.close();
    }
});


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.array = function(parse) {
		return this.next().value.split(/\s/g).map(parse);
	};

nl.line = function() {
		return this.next().value;
	}

const sol = () => {
	let n = nl.num();
	let [x, y] = nl.array(BigNum);

	let w = Math.max(x-1,y-1);
	let b = Math.max(n-x,n-y);
	console.log(w<=b?'White':'Black');

};

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


"use strict";

function main()
{
  var line = readline().split(" ");

  var size = parseInt(line[0], 10);
  var words = parseInt(line[1], 10);

  var transforms = new Array(6);
  for (var i=0 ; i<6 ; i++)
  {
    transforms[i] = new Array(6);
    transforms[i].fill(0);
  }

  for (var i=0 ; i<words ; i++)
  {
      var line = readline();

      transforms[convert(line, 0)][convert(line, 3)]++;
  }

  var count = [1, 0, 0, 0, 0, 0];
  var tmp = new Array(6);
  for (var s=1 ; s<size ; s++)
  {
    tmp.fill(0);

    for (var i=0 ; i<6 ; i++)
    {
      for (var j=0 ; j<6 ; j++)
      {
        tmp[i] += count[j] * transforms[i][j];
      }
    }

    var swap = tmp;
    tmp = count;
    count = swap;
  }

  var sum = 0;
  for (var i=0 ; i<6 ; i++)
  {
    sum += count[i];
  }

  print(sum);

  function convert(str, i)
  {
    return str.toUpperCase().charCodeAt(i) - 0x41;
  }
}

main();


var alphabet = ['a', 'b', 'c', 'd', 'e', 'f']

var input = readline().split(' ')

var n = input[0]

var strings = generateStrings(n)

var q = input[1]

var ops = {}

for (var i = 0; i < q; i++) {

    input = readline().split(' ')
    ops[input[0]] = input[1]

}

print(
    strings
        .filter(function (string) {
            for (var i = 0; string.length > 1; i++) {
                var op = string.slice(0, 2)
                if (!ops[op]) { return false }
                string = ops[op] + string.slice(2)
            }
            return string === 'a'
        })
        .length
)

function generateStrings (NN) {

    var strings = []

    var K = NN - 1, k = 0,
        N = alphabet.length, n = 0,
        out = [],
        stack = []

    function next(){
        while (true) {
            while (n < alphabet.length) {
                out[k] = alphabet[n++];
                if (k == K) return out.slice(0);
                else {
                    if (n < alphabet.length) {
                        stack.push(k);
                        stack.push(n);
                    }
                    k++;
                    n = 0;
                }
            }
            if (stack.length == 0) break;

            n = stack.pop();
            k = stack.pop();
        }
        return false;
    }

    var str

    while (str = next()) {
        strings.push(str.join(''))
    }

    return strings

}


var num = readline();

// var num = '2901'

function allNines(num) {
  var arr=[]
  for (var i = 0; i < num.length-1; i++) {
    arr.push(9);
  }

  return parseInt(arr.join(''))
}

function main(num) {
  //add less than 2 case
  if (num.length === 1) {
    return parseInt(num);
  } else if (num[0] === '1') {
    return main(num.split('').slice(1))
  } else {
    return Math.max(parseInt(num[0])*main(num.split('').slice(1).join('')), (parseInt(num[0]) - 1)*allNines(num));
  }
}

write(main(num))


const readline = require('readline');

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

function readLines(number, cb) {
    const lines = [];
    rl.on('line', function(line) {
        lines.push(line);
        if (lines.length === number) {
            rl.close();
            cb(lines);
        }
    });
};

function doIt(lines) {
    const n = parseInt(lines[0]);
    if (n === 0)
        console.log(n)
    else
        console.log(calc(n, 1));
}

function calc(next, acc) {
    if (next === 0)
        return acc;
    let unit1 = next%10;
    let rest1 = Math.floor(next/10);
    let ret1 = calc(rest1, unit1*acc);
    let ret2 = 0;
    if (unit1 < 9 && rest1>0) {
        let unit2 = 9;
        let rest2 = Math.floor(next/10) -1;

        ret2 = calc(rest2, unit2*acc);
    }
    return Math.max(ret1, ret2);
}

readLines(1, doIt);


const readline = require('readline')

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

rl.question('', ans => {
  rl.close()

  let n = Number(ans)

    function nirvana(num) {
        const str = String(num)

        function mult(str) {
            return Number(str) === 0 ? 1 : str.split('').map(x => Number(x)).reduce((i, acc = 1) => i * acc)
        }

        let l = mult(str)
        for (let i = str.length - 1; i > 0; i--) {
    		nines = str.length -1 - i + 1
    		let tMult = mult(String(Number(str.substr(0, i)) - 1))
    		tMult = tMult * (9 ** nines)

    		if (tMult > l) l = tMult
        }

    	return l
    }

  console.log(nirvana(n))
})


var num = readline();

// var num = '1000000000'

function multiplyNines(num) {
  var hi = 1;
  for (var i = 0; i < num.length-1; i++) {
    hi *= 9;
  }

  return hi + ''
}

function allNines(num) {
  var arr=[]
  for (var i = 0; i < num.length-1; i++) {
    arr.push(9);
  }

  return parseInt(arr.join(''))
}

function main(num) {
  //add less than 2 case
  if (num.length === 1) {
    return parseInt(num);
  } else if (num[0] === '1') {
    return multiplyNines(num)
  } else {
    return Math.max(parseInt(num[0])*main(num.split('').slice(1).join('')), (parseInt(num[0]) - 1)*parseInt(multiplyNines(num)));
  }
}

write(main(num))


const readline = require('readline')

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

rl.question('', ans => {
  rl.close()

  let n = Number(ans)

  function closest (n) {
    let closest = ''
    while (true) {
        if (n <= 9) {
			closest = n + closest
			break
        }

		closest = 9 + closest
        n = ~~((n - 9) / 10)
    }

    return Number(closest)
  }

  function nirvana (n) {
    const c = closest(n)
    const sC = String(c).split('')
    let grtst = Number(sC.reduce((i, acc = 1) => Number(i) * acc))

    for (let i = c + 1; i <= n; i++) {
    const sI = String(i).split('')
        let dMult = Number(sI.reduce((i, acc = 1) => i * acc))
        grtst = dMult > grtst ? dMult : grtst
    }

    return grtst
  }

  console.log(nirvana(n))
})


var num = readline();

// var num = '7'

function multiplyNines(num) {
  var hi = 1;
  for (var i = 0; i < num.length-1; i++) {
    hi *= 9;
  }

  return hi + ''
}

function allNines(num) {
  var arr=[]
  for (var i = 0; i < num.length-1; i++) {
    arr.push(9);
  }

  return parseInt(arr.join(''))
}

function main(num) {
  //add less than 2 case
  if (num.length === 1) {
    return parseInt(num);
  } else if (num[0] === '1') {
    return multiplyNines(num)
  } else {
    return Math.max(parseInt(num[0])*main(num.split('').slice(1).join('')), (parseInt(num[0]) - 1)*allNines(num));
  }
}

write(main(num))


n=+readline()
a=readline().split(' ').map(function(x){return +x;})
var d=a[1]-a[0]
var keks=1;
for (var i=2;i<n;i++)
{
    if (a[i]-a[i-1]!=d)
    {
        keks=0;
        break;
    }
}
if (keks){print(d+a[n-1]);}else{print(a[n-1]);}


// Getting problem data from codeforces.
var count = parseInt(readline()),
  array = readline().split(' ').map(function(e){
     return parseInt(e);
  });
// Determining if "array" form arithematic progression.
var prediction = 0,
  commDiff = array[1]-array[0];
if(array.length == 2){
   verdict = true;
     prediction = array[1]+commDiff;
}
else{
  var go = true;
  for(var x = 2;x<array.length && go;++x){
    if(commDiff != array[x]-array[x-1]){
      go = false;
    }
  }
  go? prediction = commDiff+array[array.length-1]:
    prediction = array[array.length-1];
}
// Solution.
print(prediction);


var n=parseInt(readline());
var ar=readline().split(" ");
for(var i=0;i<n;i++){
	ar[i]=parseInt(l[i]);
}var d=Math.abs(ar[0]-ar[1]);
var res=0;
for(var i=0;i<n-1;i++){
	if(Math.abs(ar[i]-ar[i+1])!==d){res=ar[n-1];break;}
}if(res!==0){print(res);}
else{
	if(ar[n-1]-ar[n-2]<0){print(ar[n-1]-d);}
	else if(ar[n-1]-ar[n-2]>0){print(ar[n-1]+d);}
	else{print(ar[0]);}
}


function getAmount(card) {
	switch(card) {
		case "6":
			return 6;
		case "7":
			return 7;
		case "8":
			return 8;
		case "9":
			return 9;
		case "10":
			return 10;
		case "T":
			return 11;
		case "J":
			return 12;
		case "Q":
			return 13;
		case "K":
			return 14;
		case "A":
			return 15;

	}
}

var kozyr = readline();
var input = readline().split(' ');
var a1 =  getAmount(input[0][0]);
var m1 = input[0][1];
var a2 = getAmount(input[1][0]);
var m2 = input[1][1];

var cond1 = (m1 === m2) & (a1 > a2);
var cond2 = (m1 === kozyr) & (m2 !== kozyr);
if (cond1 || cond2) {
	print('YES');
} else {
	print('NO');
}


//var input = readline()

var ar = readline().split(' ').map(x => parseInt(x));
var a = ar[0], b = ar[1];

if(a < b  &&  Math.abs(a-b) == 1) {
    print(a +' '+ b);
}
else if(a == 9 && b == 1) {
    print(9 +' '+ 10);
}
else print(a == b ? a+'1' +' '+ b+'2' : -1);

//


var nums = readline().split(' ').map(function(num) {
  return parseInt(num);
});

// var nums = [9, 4]

function main() {
  if (nums[0] === nums[1]) {
    return write(nums[0] + '1' + ' ' + nums[1] + '2');
  } else if (nums[0] + 1 === nums[1]) {
    return write(nums[0] + '9' + ' ' + nums[1] + '0');
  } else if (nums[0] === 9 && nums[1] === 1) {
    return write(nums[0] + '9' + ' ' + nums[1] + '00')
  } else {
    return write('-1');
  }
}

main();


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

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

  if (a === 9 && b === 1) {
    console.log(9, 10);
  }
  else if (diff > 1 || a > b) {
    console.log(-1);
  }
  else if (a === b) {
    console.log(`${a}1`, `${b}2`);
  }
  else {
    console.log(a, b);
  }

  c++;
});


var nums = readline().split(' ').map(function(num) {
  return parseInt(num);
});

// var nums = [9, 4]

function main() {
  if (nums[0] === nums[1]) {
    return write(nums[0] + '1' + ' ' + nums[1] + '2');
  } else if (nums[0] + 1 === nums[1]) {
    return write(nums[0] + '9' + ' ' + nums[1] + '0');
  } else {
    return write('-1');
  }
}

main();


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

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

  if (diff > 1 || a > b) {
    console.log(-1);
  }
  else if (a === b) {
    console.log(`${a}1`, `${b}2`);
  }
  else {
    console.log(a, b);
  }

  c++;
});


//var input = readline()

var ar = readline().split(' ').map(x => parseInt(x));
var a = ar[0], b = ar[1];

if(a < b  &&  Math.abs(a-b) == 1) print(a +' '+ b);
else print(a == b ? a+'1' +' '+ b+'2' : -1);


function toi(x){return parseInt(x);}
(function(){
    var s=readline();
    var dic={};
    var alpha="abcdefghijklmnopqrstuvwxyz".split("");
    for(var i=0;i<=s.length;i++){
	var l=s.substring(0,i);
	var r=s.substring(i);
	for(var j=0;j<alpha.length;j++){
	    dic[l+alpha[j]+r]=true;
	}
    }
    print(Object.keys(dic).length);
})();


var  text=readline();
var textLength=text.length;
var answer=0;
function getLettersNumber(textLength)
{
answer=((textLength+1)*26)-textLength
print(answer)
};

getLettersNumber(textLength);


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

rl.on('line', (str) => {
  console.log(26* (str.length + 1) - str.length);
});


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

    this.solveCase = function() {
        var res , i , j , fl , cn , a , b , c ;
        res = 26 ;
        cn = this.s.length ;
        for( i = 0 ; i < cn ; i++ ) {
            res += 25 ;
        }
        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.s = irObj.nextString() ;
        }
        catch( ex ) {
            hasMoreInput = false ;
        }
        return hasMoreInput ;
    } ;

    this.clearArraysPerCase = function() {
        var i ;
        this.arr = new Array() ;
        this.adjList = new Array() ;
        for( i = 0 ; i < this.lim1 ; i++ ) {
            this.arr.push( 0 ) ;
            this.adjList.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.adjList = 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.adjList.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 ;
        if( currentDirectory.indexOf( 'D:' ) != -1 ) {
            //on windows
            inputFilePath = currentDirectory + '\\' + inputFileName ;
        }
        else {
            //on linux
            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 ;
        if( currentDirectory.indexOf( 'D:' ) != -1 ) {
            //on windows
            outputFilePath = currentDirectory + '\\' + outputFileName ;
        }
        else {
            //on linux
            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() {
        var testCases , hasMoreTestCases , i ;
        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 && ( __dirname.indexOf( 'D:') != -1 || __dirname.indexOf( '/media/') != -1 ) ) {
                    environmentType = 'local-node-js' ;
                }
                else {
                    environmentType = 'server-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 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() ;


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 t = Number(readLine())
    for (let _i = 0; _i < t; _i++) {
        const [n, k, l] = readLine().split(/\s/).map(Number)
        const ds = readLine().split(/\s/).map(Number)
        let result = true
        for (let i = 0; i < n; i++) {
          const d = ds[i]
          let tide = l - d
          if (tide < 0) {
            result = false
            break
          }
          if (tide >= k) {
            continue
          }
          let increasing = tide === 0
          let iDiff = 1
          while(i + iDiff < n) {
            tide = increasing ? tide + 1 : tide - 1
            if (tide === 0) {
              increasing = true
            }
            const _d = ds[i + iDiff]
            if (_d <= l - k) {
              break
            }
            if (_d + tide > l) {
              tide = l - _d
              if (increasing || tide < 0) {
                result = false
                break
              }
              if (tide === 0) {
                increasing = true
              }
            }
            iDiff++
          }
          if (!result) {
            break
          }
          i = i + iDiff
        }
      console.log(result ? '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 = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

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

function main() {
    const t = Number(readLine())
    for (let _i = 0; _i < t; _i++) {
        const [n, k, l] = readLine().split(/\s/).map(Number)
        const ds = readLine().split(/\s/).map(Number)
        let result = true
        const repeats = Array(k).fill(0)
        for (const d of ds) {
          const index = d - (l - k + 1)
          if (index >= k) {
            result = false
            break
          }
          for (let i = 0; i < k; i++) {
            repeats[i] = i > index ? 0 : repeats[i] + 1
            if (repeats[i] > k - i) {
              result = false
              break
            }
          }
          if (!result) {
            break
          }
        }
      console.log(result ? '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 = inputString.trim().split('\n').map(string => {
        return string.trim();
    });

    main();
});

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

function main() {
    const t = Number(readLine())
    for (let _i = 0; _i < t; _i++) {
        const [n, k, l] = readLine().split(/\s/).map(Number)
        const ds = readLine().split(/\s/).map(Number)
        let result = true
        const repeats = Array(k).fill(0)
        for (const d of ds) {
          const index = d - (l - k + 1)
          if (index >= k) {
            result = false
            break
          }
          for (let i = 0; i < k; i++) {
            repeats[i] = index < 0 ? 0 : i > index ? repeats[i] : repeats[i] + 1
            if (repeats[i] > k - i) {
              result = false
              break
            }
          }
          if (!result) {
            break
          }
        }
      console.log(result ? 'Yes' : 'No')
    }
}


function main(){
  var line = readline().split(" ").map(Number);
  var evenSteps = line[0];
  var oddSteps = line[1];

  if(evenSteps + oddSteps === 0)
    return "NO";

  if(Math.abs(evenSteps - oddSteps) < 2)
    return "YES";
  return "NO";
}

print(main());


var diff;
var set = readline().split(" ").map(Number);
if (set[0] > 0 && set[0] === set[1]) {
	print("YES");
}
else {
	diff = Math.max.apply(Math, set) - Math.min.apply(Math, set);
	if (diff === 1) {
		print("YES");
	}
	else {
		print("NO");
	}
}


var s=readline().split (' ').map(Number);
var mf= (x,y)=>{var z =Math.abs(x-y); if (z<=1 && x+y>0) {return 'YES';} return 'NO';};
var p =mf.apply(null,s);
print (p);


var s=readline().split (' ').map(Number);
var mf= (x,y)=>{var z =Math.abs(x-y); if (z<=1) {return 'YES';} return 'NO';};
var p =mf.apply(null,s);
print(p);


var s=readline().split (' ').map(Number);
var mf= (x,y)=>{var z =Math.abs(x-y); if (z<=1 && (x!==0 && y!==0)) {return 'YES';} return 'NO';};
var p =mf.apply(null,s);
print(p);


print(function(x, y){
	var dx = Math.abs(x);
	var dy = Math.abs(y);
	var d = dx+dy;
	var a = [ d*x/dx, 0 ];
	var b = [ 0, d*y/dy ];
	return ( x<0 ? a.concat(b) : b.concat(a) ).join(' ');
}.apply(0, readline().split(' ').map(Number)));


function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i], 10);
	};
	return tokens;
}

function main() {
	var data = tokenizeIntegers(readline()),
		a = data[0], b = data[1],
		x = Math.abs(a) + Math.abs(b),
		y = x;
	x *= a/Math.abs(a);
	y *= b/Math.abs(b);
	if (x < 0) {
		print(x, 0, 0, y);
	} else {
		print(0, y, x, 0);
	}
}

main();


;(function () {
	print(function (a, b, c) {
		return f(a, b, c);

		function f (a, b, c) {
			if (a < 2 || b < 2 || c < 2) return a * b * c;
			else return (a + b + c - 3) * 2 + f(a - 1, b - 1, c - 1);
		}
	}.apply(null, readline().split(' ').map(Number)));
}).call(this);


print(function(a, b, c) {
	return a * b + a * (c - 1) + (b - 1) * (c - 1);
} .apply(0, readline().split(' ').map(Number)));


;(function () {
	print(function (a, b, c) {
		var min = Math.min(a, b, c),
			max = Math.max(a, b, c),
			mid = a + b + c - min - max;

		return (a + b + c - 3) * 2 + (max - 1) * (mid - 1);
	}.apply(null, readline().split(' ').map(Number)));
}).call(this);


;(function () {
	print(function (a, b, c) {
		var min = Math.min(a, b, c),
			max = Math.max(a, b, c),
			mid = a + b + c - min - max;

		return a * b * c - min * mid;
	}.apply(null, readline().split(' ').map(Number)));
}).call(this);


;(function () {
	print(function (a, b, c) {
		return f(a, b, c);

		function f (a, b, c) {
			if (a === 1 && b === 1 && c === 1) return 1;
			if (a === 0 || b === 0 || c === 0) return 0;
			else return (a + b + c - 3) * 2 + f(a - 1, b - 1, c - 1);
		}
	}.apply(null, readline().split(' ').map(Number)));
}).call(this);


var arr = [];
for (var i = 0; i < 4; i++) {
    for (var j = 0; j < 4; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = readline();
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color !== '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print(arr);
    print('YES1');
} else {

    if (testChange()) {
        print('YES2');
    } else {
        print('NO');
    }
}


var arr = [];
for (var i = 0; i < 4; i++) {
    for (var j = 0; j < 4; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = readline();
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color !== '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print('YES1');
} else {

    if (testChange()) {
        print('YES2');
    } else {
        print('NO');
    }
}


var arr = [];
for (var i = 0; i < 4; i++) {
    var line = readline();
    var lineChars = line.split('');
    for (var j = 0; j < lineChars.length; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = lineChars[j];
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color !== '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print('YES');
} else {

    if (testChange()) {
        print('YES');
    } else {
        print('NO');
    }
}


var arr = [];
for (var i = 0; i < 4; i++) {
    for (var j = 0; j < 4; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = readline();
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color !== '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print('YES');
} else {

    if (testChange()) {
        print('YES');
    } else {
        print('NO');
    }
}


var arr = [];
for (var i = 0; i < 4; i++) {
    var line = readline();
    var lineChars = line.split('');
    for (var j = 0; j < lineChars.length; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = lineChars[j];
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color !== '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print('YES1');
} else {

    if (testChange()) {
        print('YES2');
    } else {
        print('NO');
    }
}


"use strict";

function check(s) {
    for (var i = 0; i < 3; i++) {
        for (var j = 0; j < 3; j++) {
            var c = s[i][j];
            if (c == s[i][j+1] && c == s[i+1][j] && c == s[i+1][j+1]) return true;
        }
    }
    return false;
}

function flip(c) {
    if (c == "#") return ".";
    else return "#";
}

var s = []
for (var i = 0; i < 4; i++) s.push(readline().split(""));

var ans = false;
for (var i = 0; i < 4; i++) {
    for (var j = 0; j < 4; j++) {
        s[i][j] = flip(s[i][j]);
        if (check(s)) ans = true;
        s[i][j] = flip(s[i][j]);
    }
}
print(ans ? "YES" : "NO");


var arr = [];
for (var i = 0; i < 4; i++) {
    var line = readline();
    var lineChars = line.split('');
    for (var j = 0; j < lineChars.length; j++) {
        if (!arr[i]) {
            arr[i] = [];
        }
        arr[i][j] = lineChars[j];
    }
}

var testPosition = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    if (arr[x][y] == arr[x][y + 1] && arr[x][y] == arr[x + 1][y] && arr[x][y] == arr[x + 1][y + 1]) {
        return true;
    }
    return false;
};

var testSquare = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (testPosition(i, j)) {
                return true;
            }
        }
    }
};

var change = function(x, y) {
    if (x + 1 == 4 || y + 1 == 4) {
        return false;
    }
    var colors = {
        firstColor: {
            color: '',
            found: 0
        },
        secondColor: {
            color: '',
            found: 0
        }
    };
    colors.firstColor.color = arr[x][y];
    for (var ix = x; ix <= x + 1; ix++) {
        for (var jy = y; jy <= y + 1; jy++) {
            if (colors.firstColor.color === arr[ix][jy]) {
                colors.firstColor.found += 1;
            } else {
                if (colors.secondColor.color === '')
                    colors.secondColor.color = arr[ix][jy];
                colors.secondColor.found += 1;
            }
        }
    }
    if (colors.secondColor.found === 1 || colors.firstColor.found === 1) {
        return true;
    }
    return false;
};

var testChange = function() {
    for (var i = 0; i < 4; i++) {
        for (var j = 0; j < 4; j++) {
            if (change(i, j)) {
                return true;
            }
        }
    }
};

if (testSquare()) {
    print('YES');
} else {

    if (testChange()) {
        print('YES');
    } else {
        print('NO');
    }
}


function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var input = tokenizeIntegers(readline());

	function isRightTriangle(input) {
		var squares = [];
		for (var i = 0; i < 3; i += 1) {
			squares.push(Math.pow(input[(2*i+2)%6]-input[2*i], 2) +
					   Math.pow(input[(2*i+3)%6]-input[2*i+1], 2));
		}
		squares.sort(function(a, b) {
			return a-b;
		});
		if (squares[0] == 0) {
			return false;
		}
		return (squares[2] == squares[1] + squares[0]);
	}

	if (isRightTriangle(input)) {
		print("RIGHT");
		return;
	}

	var dx = [0, 1, 0, -1], dy = [-1, 0, 1, 0];
	for (var i = 0; i < 3; i += 1) {
		for (var j = 0; j < 4; j += 1) {
			input[2*i] += dx[j];
			input[2*i+1] += dy[j];
			if (isRightTriangle(input)) {
				print("ALMOST");
				return;
			}
			input[2*i] -= dx[j];
			input[2*i+1] -= dy[j];
		}
	}

	print("NEITHER");
}

main();


function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var input = tokenizeIntegers(readline());

	function isRightTriangle(input) {
		var squares = [];
		for (var i = 0; i < 3; i += 1) {
			squares.push(Math.pow(input[(2*i+2)%6]-input[2*i], 2) +
					   Math.pow(input[(2*i+3)%6]-input[2*i+1], 2));
		}
		squares.sort(function(a, b) {
			return a-b;
		});
		return (squares[2] == squares[1] + squares[0]);
	}

	if (isRightTriangle(input)) {
		print("RIGHT");
		return;
	}

	var dx = [0, 1, 0, -1], dy = [-1, 0, 1, 0];
	for (var i = 0; i < 3; i += 1) {
		input[2*i] += dx[i];
		input[2*i+1] += dy[i];
		if (isRightTriangle(input)) {
			print("ALMOST");
			return;
		}
		input[2*i] -= dx[i];
		input[2*i+1] -= dy[i];
	}

	print("NEITHER");
}

main();


var n=+readline();
var s=readline();
var ans=0;
s.replace(/B/g, function(_, i){
	ans+=Math.pow(2, i);
});
print(ans);


var ans=0;
readline();
readline().replace(/B/g, function(_, i){
	ans+=Math.pow(2, i);
});
print(ans);


var ans=0;
readline();
readline().replace(/B/g, function(_, i){
	ans+=1<<i;
});
print(ans);


const readline = require('readline');

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

function readLines(number, cb) {
    const lines = [];
    rl.on('line', function(line) {
        lines.push(line);
        if (lines.length === number) {
            rl.close();
            cb(lines);
        }
    });
};

function readLines(number, cb) {
    const lines = [];
    rl.on('line', function(line) {
        lines.push(line);
        if (lines.length === number) {
            rl.close();
            cb(lines);
        }
    });
};

function doIt(lines) {
    const str = lines[0];
    const k = parseInt(lines[1]);
    const snow = (str.match(/\*/g)||[]).length;
    const cane = (str.match(/\?/g)||[]).length;
    const vlen = k - (str.length - 2*(snow+cane));

    if (vlen<0) {
        console.log("Impossible");
    } else if (snow===0 && cane<vlen) {
        console.log("Impossible");
    } else {
        const caneLen = Math.min(vlen, cane);
        const snowLen = vlen - caneLen;

        const ret = generate(str, caneLen, snowLen);
        console.log(ret);
    }

    function generate(str, caneLen, snowLen) {
        const newStr = [];
        let snowCount = 0;
        let caneCount = 0;
        for (let i=0; i<str.length; i++){
            if (str.charAt(i)==='*') {
                if (snowCount === snowLen)
                    newStr.pop();
                else {
                    const char = newStr[newStr.length-1];
                    for (let j=1; j < snowLen; j++)
                        newStr.push(char);
                    snowCount = snowLen;
                }
            } else if (str.charAt(i)==='?') {
                if (caneCount === caneLen)
                    newStr.pop();
                else
                    caneCount++;
            } else
                newStr.push(str.charAt(i));
        }
        return newStr.join("");
    }
}

readLines(2, doIt);


var x = +readline();

function findMax(n) {
	var digits = ("" + n).split(""),
		currentSum = getDigitsSum(digits),
		nextNumber = +((digits[0] - 1) + (new Array(digits.length)).join("9")),
		nextSum = getDigitsSum(nextNumber);

	if(currentSum > nextSum) return n;
	if(currentSum < nextSum) return nextNumber;
	return Math.max(n, nextNumber);
}

function getDigitsSum(digits) {
	if(!Array.isArray(digits)) digits = ("" + digits).split("");
	return digits.reduce(function (sum, n) {
		return sum + 1*n;
	}, 0);
}

print(findMax(x));


var data = [];

data.push(readline());

function sum(n) {
    return n.split('').map(function (d) {
        return parseInt(d);
    }).reduce(function (s, d) {
        return s + d;
    });
}

function solve() {
    var n1 = data[0];
    if (n1.length === 1) {
        return print(n1);
    }
    var s1 = sum(n1);
    var first = parseInt(n1[0]) - 1;
    var l = n1.length - 1;
    var newN = '9'.repeat(l);
    if (first !== 0) {
        newN = first + newN;
    }
    var s2 = sum(newN);
    print(s2 > s1 ? newN : n1);
}

solve();


var xString = readline();

function findMax(nString) {
	var digits = nString.split(""),
		currentSum = getDigitsSum(digits),
		prevBit = digits[0] - 1 > 0 ? digits[0] - 1 : "",
		nextNumberString = prevBit + (new Array(digits.length)).join("9"),
		nextSum = getDigitsSum(nextNumberString);

	if(currentSum > nextSum) return nString;
	if(currentSum < nextSum) return nextNumberString;
	return +nextNumberString > +nString ? nextNumberString : nString;
}

function getDigitsSum(digits) {
	if(!Array.isArray(digits)) digits = ("" + digits).split("");
	return digits.reduce(function (sum, n) {
		return sum + 1*n;
	}, 0);
}

print(findMax(xString));


var data = [];

data.push(readline());

function sum(n) {
    return n.split('').map(function (d) {
        return parseInt(d);
    }).reduce(function (s, d) {
        return s + d;
    });
}

function solve() {
    var n1 = data[0];
    var s1 = sum(n1);
    var first = parseInt(n1[0]) - 1;
    var l = n1.length - 1;
    var newN = '9'.repeat(l);
    if (first !== 0) {
        newN = first + newN;
    }
    var s2 = sum(newN);
    print(s2 > s1 ? newN : n1);
}

solve();


var line = readline().split(" "),
    digits = [],
    a = line[0],
    count = a.length,
    maxDigit = count-1, // крайнее число с которого надо начать
    countD = 0,
    newLine = a.split("");

function sumDigits(number) {
    var s = 0;
    for (var c in number) {
        s += +number[c];
    }
    return s;
};

digits.push(a);
while (countD < count) {
    for (var i = 0; i < count; i++) {
        newLine[maxDigit] = 9; // заменили на 9 текущую 48 -> 49
        countD++; // счётчик девяток
        newLine[(maxDigit-1)] = (new Number(newLine[maxDigit - 1]) > 0 ? --newLine[maxDigit - 1] : 0); // 49 -> 39
        --maxDigit; // перешли от крайнего числа к следующему с края
        var n = newLine.join("");
        (n <= line ? digits.push(n.replace(/^0+/img, "")) : "");
    }
}

var max = sumDigits(digits[0]), maxValue = digits[0];
for (var i = 1, l = digits.length; i < l; ++i) {
    var item = sumDigits(digits[i]);
    if (max < item) {
        max = item;

        maxValue = digits[i];
    }
}

print(maxValue);


var n = readline().trim() + "";

function sumOfDigitsInNumber(k){
    var s = 0;
    var a = k.split("").map((h) => {s += +h;})
    return s;
}

function doingSmthWithNumberIDontKnowWhy(n){
    var k = n.split("").reverse();
    var min = false;
    for(var i = 0; i < k.length; i++){
        if(k[i] != "9" && !min && i != k.length - 1){
            k[i] = 9;
            min = true;
        }else if(min){
            if(k[i] == "0"){
                k[i] = 9;
            }else{
                k[i] = (+k[i] - 1) + "";
                break;
            }
        }
    }

    if(k[k.length - 1] == "0"){
        k = k.reverse().join("").substr(1, k.length);
    }else{
        k = k.reverse().join("");
    }

    return (k == n ? "-" : k);
}

var a = [];
var r = 0;
var t = n;
var max = 0;
while(t != "-"){
    a[r] = [t, sumOfDigitsInNumber(t)];
    t = doingSmthWithNumberIDontKnowWhy(t);
    r++;
}

a.sort((a, b) => {
    if(a[1] < b[1]){
        return 1
    }else{
        return -1;
    }
    return 0;
})

var b = [];
var j = 0;
for(var i = 0; i < r; i++){
    if(a[0][1] == a[i][1]){
        b[j] = a[i];
        j++;
        if(max < a[i][0].length){
            max = a[i][0].length;
        }
    }
}

var c = [];
r = 0;
for(var i = 0; i < j; i++){
    if(b[i][0].length == max){
        c[r] = a[i];
        r++;
    }
}

for(var i = 0; i < max; i++){
    var max_digit = 0;

    for(var j = 0; j < r; j++){
        if(+c[j][0][i] > max_digit) max_digit = +c[j][0][i];
    }

    max_digit = max_digit + "";
    for(var j = 0; j < r; j++){
        if(c[j][0][i] != max_digit){
            c.splice(j, 1);
            r--;
        }
    }

}

print(c[0][0]);


'use strict';

var data = [];

data.push(readline())

function sum(n) {
    return n.split('').map(function (d) {
        return parseInt(d);
    }).reduce(function (s, d) {
        return s + d;
    });
}

function minus1(s, i) {
    if (!s) return '';
    if (s[i] === '0') {
        return rem0(minus1(s.substring(0, i), i - 1) + '9' + '9'.repeat(s.substring(i + 1).length));
    } else {
        return rem0(s.substring(0, i) + String(parseInt(s[i]) - 1) + '9'.repeat(s.substring(i + 1).length));
    }
}
function rem0(s) {
    var i = 0;
    while (s[i] === '0') {
        i++;
    }
    return s.substring(i);
}

function solve() {
    var n1 = data[0];
    if (n1.length === 1) {
        return print(n1);
    }
    var s1 = sum(n1);
    var s2 = 0;
    var n2 = void 0;
    for (var i = 0; i < n1.length - 1; i++) {
        var s9 = minus1(n1, i);
        var s9s = sum(s9);
        if (s9s >= s2) {
            s2 = s9s;
            n2 = s9;
        }
    }

    print(s2 > s1 ? n2 : n1);
}

solve();


var xString = readline(),
	digits = xString.split(""),
	xLength = xString.length,
	maxSum = getDigitsSum(xString),
	maxNumber = xString,
	newNumber, newDigits, newSum, nineDigits;

for(var i = 0; i < xLength; i++) {
	nineDigits = (new Array(xLength - i)).join("9").split("");
	newDigits = digits.slice(0, i + 1).concat(nineDigits);

	if(--newDigits[i] < 0 && i) continue;
	newDigits[i] = (!i && newDigits[i] <= 0) ? "" : "" + newDigits[i];

	newNumber = newDigits.join("");
	newSum = getDigitsSum(newDigits);

	if(newSum > maxSum || (newSum == maxSum && +newNumber > +maxNumber)) {
		maxNumber = newNumber;
		maxSum = newSum;
	}
}

function getDigitsSum(digits) {
	if(!Array.isArray(digits)) digits = ("" + digits).split("");
	return digits.reduce(function (sum, n) {
		return sum + 1*n;
	}, 0);
}

print(maxNumber);


var g = ["Washington", "Adams", "Jefferson", "Madison", "Monroe"
, "Adams", "Jackson", "Van Buren", "Harrison", "Tyler", "Polk", "Taylor",
"Fillmore", "Pierce", "Buchanan", "Lincoln", "Johnson", "Grant", "Hayes",
"Garfield",  "Arthur", "Cleveland", "Harrison", "Cleveland", "McKinley",
"Roosevelt", "Taft", "Wilson", "Harding", "Coolidge", "Hoover", "Roosevelt",
"Truman", "Eisenhower", "Kennedy", "Johnson", "Nixon", "Ford", "Carter", "Reagan", "Bush", "Clinton", "Bush", "Obama"];
var c = readline();
print(g[c-1])