let i = '';
process.stdin.on('data', c => i += c)
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = i.split(EOL); /*your input text, split by lines*/
    let cases = parseInt(lines[0])
    //const splitLines = lines.map(x => x.split(" ").map(x => parseInt(x)))
    for (let i = 1; i <= cases; i ++)
    {
        let a = lines[i].split(" ").map(x => parseInt(x))
        if ((a[0] + a[1]) % 2 == 0)
        {
            console.log("Tonya")
        }
        else{
            console.log("Burenka")
        }
    }
})

'use strict';

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

let inputString = '';
let currentLine = 0;

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

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

    main();
});

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

function output(x) {
    if (typeof x !== 'string') {
        x = x.toString();
    }
    //process.stdout.write(x);   // without auto '\n' (newline)
    console.log(x);  // with auto '\n' (newline)
}

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

    for (let test = 0; test < N; test++) {
        const [n, m] = readline().split(' ').map(Number);

        const nEven = n % 2 === 0;
        const mEven = m % 2 === 0;

        if ((nEven && mEven) || (!nEven && !mEven)) {
            output('Tonya');
        } else {
            output('Burenka');
        }
    }
}

var n, m;

    var tests = parseInt(readline());
    for (var t=0; t<tests;t++) {
        var nm = readline().split(' ').map(x=>parseInt(x));
        n = nm[0];
        m = nm[1];
        if ((n+m) & 1) {
            print('Burenka')
        } else {
            print('Tonya')
        }
    }

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

var data = [];
var sum = 0;
readline.once("line", (_n) => {
  readline.on("line", (line) => {
    data.push(line);
    if (data.length == _n) {
      data.map((m) => {
        [a, b] = m.split(" ");
        let x= parseInt(a);
        let y= parseInt(b);
        if ((x&1 && y&1) || (x%2 === 0 && y%2 === 0)) {
            console.log('Tonya');
        }
        else
            console.log('Burenka');

      });
      readline.close();
    }
  });
});

let i = '';
process.stdin.on('data', c => i += c);
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = i.split(EOL);
    var n = lines[0],e=0, k = 0
    for(j = 1; j <= n; j++){
        k = lines[j].split(' ').map(Number)
        a = k[0]
        b = k[1]
        if(a % 2 === 0 && b % 2 === 0 || a % 2 == 1 && b % 2 == 1){
            console.log('Tonya')
        }else{
            console.log("Burenka");

        }
    }

});

'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 solve(x, y){
    if ((x + y) % 2){
        console.log("Burenka");
    }
    else
        console.log("Tonya");
}

function main(){
    let t = Number(readline());

    while (t--){
        let [a,b] = readline().split(" ").map(x => parseInt(x));
        solve(a,b);
    }
}

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

/***
Codeforces Round #814 (Div. 2)
2022-08-16

A. Chip Game
***/

function main() {
  const t = parseInt(readline());

  for (let i = 0; i < t; i++) {
    const board = readline().split(" ");
    const n = parseInt(board[0]);
    const m = parseInt(board[1]);

    // not-odd chip game solved in Explorations
    // we need n=m or even number of squares to diagonal for P2 to win
    console.log((m - n) % 2 == 0 ? "Tonya" : "Burenka");
  }
}

function formula(a, b, c) {
  return (a ^ b) + (b ^ c) + (a ^ c);
}

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const [n, m] = lines[l++].trim().split(' ').map(Number)
        output[i] = solve(n, m) ? 'Burenka' : 'Tonya'
    }
    console.log(output.join('\n'))
// })()
})

function solve(n, m) {
    return (cal(n) + cal(m)) & 1
}
function cal(n) {
    if (n === 1) return 0
    return ((n - 1) & 1) ? 1 : 2
}

'use strict';

const fs = require('fs');

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

let inputString = '';
let currentLine = 0;

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

process.stdin.on('end', function() {
    inputString = inputString.split('\n');

    main();
});

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

function isPossible(n, x, heights) {
    heights.sort();
    heights.sort(function(a, b) {
        return a - b;
      });
    // //console.log(heights)

    let front = []
    let back = []

    for (let i = 0; i < heights.length; i++) {
        if (i < n) {
            front.push(heights[i])
        } else {
            back.push(heights[i])
        }
    }

    // //console.log(front)
    // //console.log(back)
    for (let j = 0; j < front.length; j++) {
        if (back[j] - front[j] < x) {
            // //console.log(back[j] + " " + front[j])
            return "NO";
        }
    }

    return "YES";
}

function calc(a, m) {
    let s = "";
    for (let index = 0; index < m; index++) {
        s += "B"
    }

   for (let index = 0; index < a.length; index++) {
        let ai = a[index];

        if (ai < (m + 1 - ai)) {
            let _s = s.replaceAt(ai - 1, "A");
            if (compare(_s, s) < 0) {
                s = _s;
                continue;
            } else if (compare(_s, s) >= 0) {
                    let __ss = s.replaceAt(m + 1 - ai - 1, "A");
                    if (compare(__ss, s) < 0) {
                        s = __ss;
                        continue;
                    }
            }
         }  else {
            let _s = s.replaceAt(m + 1 - ai - 1, "A");
            if (compare(_s, s) < 0) {
                s = _s;
                continue;
            }  if (compare(_s, s) >= 0) {
                    let __ss = s.replaceAt(ai - 1, "A");
                    if (compare(__ss, s) < 0) {
                        s = __ss;
                        continue;
                    }
            }
    }
}

   return s;
}

function compare(s1, s2) {
    return s1.localeCompare(s2)
}

String.prototype.replaceAt = function(index, replacement) {
    return this.substring(0, index) + replacement + this.substring(index + replacement.length);
}

function main() {
    // const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

    const test_cases = parseInt(readLine().trim(), 10);

    for (let gItr = 0; gItr < test_cases; gItr++) {
        // const n = parseInt(readLine().trim(), 10);
        const arr = readLine().replace(/\s+$/g, '').split(' ').map(arrTemp => parseInt(arrTemp, 10));

        const n = arr[0]
        const m = arr[1]

        if (n == 1 && m == 1) {
            console.log("Tonya")
        } else {
            if ((n%2 ==0 && m%2 == 0) || (n%2 == 1 && m%2 == 1))  {
                console.log("Tonya")
            } else {
                console.log("Burenka")
            }
        }

    }

    // ws.end();
}

let stop = '';
process.stdin.on('data', c => stop += c);
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = stop.split(EOL);
    var t = lines[0];
    for(i = 1; i <= t; i++){
        var k = lines[i].split(' ').map(Number);
        var a = k[0], b = k[1];
        if((a % 2 === 0 && b % 2 === 0) || (a % 2 !== 0 && b % 2 !== 0)){
			console.log('Tonya');
		}
		else{
			console.log("Burenka");
		}
    }
});

//Don't have to see. start------------------------------------------
var read = require('readline').createInterface({
	input: process.stdin, output: process.stdout
});
var obj; var inLine = []; var outputList = [];var retcode = new Set();
read.on('line', function(input){
	var tmp = input.split(' ');
	for(var i = 0; i < tmp.length; i++){
		inLine.push(tmp[i]);
		if(i == tmp.length - 1){
			retcode.add(inLine.length);
		}
	}
});
read.on('close', function(){
	obj = init(inLine);
	console.error('\n↑入力 ↓出力');
	Main();
	console.log(myconv(outputList, 9));
});
function makeClone(obj){return (obj instanceof Set) ? new Set(Array.from(obj)) : JSON.parse(JSON.stringify(obj));}
function nextArray(size, code){
	var ret = new Array(size);
	for(var i = 0; i < size; i++){
		if(code == 'int'){
			ret[i] = nextInt();
		}else if(code == 'long'){
			ret[i] = nextLong();
		}else if(code == 'double'){
			ret[i] = nextDouble();
		}else{
			ret[i] = next();
		}
	}
	return ret;
}
function nextIntArray(size){return nextArray(size, 'int');} function nextStrArray(size){return nextArray(size, 'str');} function nextLongArray(size){return nextArray(size, 'long');} function nextDoubleArray(size){return nextArray(size, 'double');}
function nextCharArray(){return myconv(next(),6);}
function next(){return obj.next();} function hasNext(){return obj.hasNext();} function nextInt(){return myconv(next(),1);} function nextLong(){return BigInt(next());} function nextDouble(){return parseFloat(next());}
function getCountMap(list){
	var map = {};
	for(var i = 0; i < list.length; i++){
		if(map[list[i]] == null){
			map[list[i]] = 0;
		}
		map[list[i]]++;
	}
	return map;
}
function init(input){
	return {
		list : input, index : 0, max : input.length,
		hasNext : function(){return (this.index < this.max);},
		next : function(){if(this.hasNext()){return this.list[this.index++];}else{throw 'ArrayIndexOutOfBoundsException ‚There is no more input';}},
		isReturn : function(){return retcode.has(this.index);}
	};
}
function myout(s){outputList.push(s);}
function myerr(s){console.error('debug:' + require('util').inspect(s,false,null));}
function isReturn(){return obj.isReturn();}
//param "no" is
//unknown or outlier : return i. 1: parseInt.
//2: split space. 4: split space and parseInt.
//6: split 1 character. 7: split 1 character and parseInt.
//8: join space. 9: join nextline. 0: join no character.
function myconv(i,no){try{switch(no){case 1:return parseInt(i);case 2:return i.split(' ');case 4:return i.split(' ').map(Number);case 6:return i.split('');case 7:return i.split('').map(Number);case 8:return i.join(' ');case 9:return i.join('\n');case 0:return i.join('');default:return i;}}catch(e){return i;}}

//Don't have to see. end------------------------------------------
function Main(){
	var t = nextInt();
	while(hasNext()){
		var N = nextInt();
		var M = nextInt();
		if((N + M) % 2 == 0){
			myout("Tonya");
		}else{
			myout("Burenka");
		}
	}
}

const fs = require("fs");

const input = fs.readFileSync(0, "utf8").trim().split("\n");

const testCases = [];
let T;

function parseInput() {
  T = parseInt(input[0]);
  let index = 0;

  for (let i = 0; i < T; i++) {
    index++;
    const [n, m] = input[index].split(" ").map((item) => parseInt(item));
    const testCase = {
      n,
      m,
    };

    testCases.push(testCase);
  }
}

function solution(testCase) {
  const { n, m } = testCase;

  let result = (n + m) % 2 ? "Burenka" : "Tonya";
  console.log(result);
}

parseInput();

testCases.forEach(solution);

'use strict';

function solve(a) {
  const [n, m] = a;
  if ((n & 1) === (m & 1)) return 'Tonya';
  return 'Burenka';
}

async function main(r) {
  const rns = async () => {
    return (await r()).split(' ').filter(s => s !== '').map(Number);
  };
  try {
    let t = Number(await r());
    let res = new Array(t);
    for (let i = 0; i < t; i++) {
      const a = await rns();
      res[i] = solve(a);
    }
    return res.join('\n');
  } catch (error) {
    console.log(error);
  }
}

let inputs,
    str = '';
function read() {
  return inputs.next().value.trim();
}
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', input => str += input);
process.stdin.on('end', async () => {
  inputs = str.split('\n').values();
  const output = await main(read);
  process.stdout.write(output);
});

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

var data = [];
var sum = 0;
readline.once("line", (_n) => {
  readline.on("line", (line) => {
    data.push(line);
    if (data.length == _n) {
      data.map((m) => {
        [a, b] = m.split(" ");
        let x= parseInt(a);
        let y= parseInt(b);
        if ((x === 1 && y === 1) || (x%2 === 0 && y%2 === 0)) {
            console.log('Tonya');
        }
        else
            console.log('Burenka');

      });
      readline.close();
    }
  });
});

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

var data = [];
var sum = 0;
readline.once("line", (_n) => {
  readline.on("line", (line) => {
    data.push(line);
    if (data.length == _n) {
      data.map((m) => {
        [a, b] = m.split(" ");
        let x= parseInt(a);
        let y= parseInt(b);
        if (x === y) {
            console.log('Tonya');
        }
        else if(x !== y && (x%2 === 1 || y%2 ===1))
            console.log('Burenka');

      });
      readline.close();
    }
  });
});

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

var data = [];
var sum = 0;
readline.once("line", (_n) => {
  readline.on("line", (line) => {
    data.push(line);
    if (data.length == _n) {
      data.map((m) => {
        [a, b] = m.split(" ");
        let x= parseInt(a);
        let y= parseInt(b);
        if (x === y) {
            console.log('Tonya');
        }
        else
            console.log('Burenka');

      });
      readline.close();
    }
  });
});

let i = '';
process.stdin.on('data', c => i += c);
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = i.split(EOL);
    var n = lines[0],e=0, k = 0
    for(j = 1; j <= n; j++){
        k = lines[j].split(' ').map(Number)
        a = k[0]
        b = k[1]
        if(a % 2 === 0 && b % 2 === 0){
            console.log('Tonya')
        }else{
            console.log("Burenka");

        }
    }

});

let i = '';
process.stdin.on('data', c => i += c);
process.stdin.on('end', () => {
    const {EOL} = require('os');
    const lines = i.split(EOL);
    var n = lines[0]
    var a = 0
    for(j = 1; j <= n ;j ++){
    var k = lines[j].split(' ').map(Number)
    if(k[0] == k[1]){
        console.log('Tonya')
    }else{
         console.log('Burenka')
    }
    }

});

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

/***
Codeforces Round #814 (Div. 2)
2022-08-16

A. Chip Game
***/

function main() {
  const t = parseInt(readline());

  for (let i = 0; i < t; i++) {
    const board = readline().split(" ");
    const n = parseInt(board[0]);
    const m = parseInt(board[1]);

    // same as not-odd chip game, solved in Explorations
    console.log(Math.floor(n / 2) == Math.floor(m / 2) ? "Tonya" : "Burenka");
  }
}

function formula(a, b, c) {
  return (a ^ b) + (b ^ c) + (a ^ c);
}

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

/***
Codeforces Round #814 (Div. 2)
2022-08-16

A. Chip Game
***/

function main() {
  const t = parseInt(readline());

  for (let i = 0; i < t; i++) {
    const board = readline().split(" ");
    const n = parseInt(board[0]);
    const m = parseInt(board[1]);

    // same as not-odd chip game, solved in Explorations
    console.log(n == m ? "Tonya" : "Burenka");
  }
}

function formula(a, b, c) {
  return (a ^ b) + (b ^ c) + (a ^ c);
}

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const [n, m] = lines[l++].trim().split(' ').map(Number)
        output[i] = solve(n, m) ? 'Burenka' : 'Tonya'
    }
    console.log(output.join('\n'))
// })()
})

function solve(n, m) {
    if (n > m) return solve(m, n)
    // [1, odd] - false
    // [1, even] - true
    if (n === 1) return (m - 1) & 1
    if ((n & 1) || (m & 1)) return true
    return false
}

'use strict';

const fs = require('fs');

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

let inputString = '';
let currentLine = 0;

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

process.stdin.on('end', function() {
    inputString = inputString.split('\n');

    main();
});

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

function isPossible(n, x, heights) {
    heights.sort();
    heights.sort(function(a, b) {
        return a - b;
      });
    // //console.log(heights)

    let front = []
    let back = []

    for (let i = 0; i < heights.length; i++) {
        if (i < n) {
            front.push(heights[i])
        } else {
            back.push(heights[i])
        }
    }

    // //console.log(front)
    // //console.log(back)
    for (let j = 0; j < front.length; j++) {
        if (back[j] - front[j] < x) {
            // //console.log(back[j] + " " + front[j])
            return "NO";
        }
    }

    return "YES";
}

function calc(a, m) {
    let s = "";
    for (let index = 0; index < m; index++) {
        s += "B"
    }

   for (let index = 0; index < a.length; index++) {
        let ai = a[index];

        if (ai < (m + 1 - ai)) {
            let _s = s.replaceAt(ai - 1, "A");
            if (compare(_s, s) < 0) {
                s = _s;
                continue;
            } else if (compare(_s, s) >= 0) {
                    let __ss = s.replaceAt(m + 1 - ai - 1, "A");
                    if (compare(__ss, s) < 0) {
                        s = __ss;
                        continue;
                    }
            }
         }  else {
            let _s = s.replaceAt(m + 1 - ai - 1, "A");
            if (compare(_s, s) < 0) {
                s = _s;
                continue;
            }  if (compare(_s, s) >= 0) {
                    let __ss = s.replaceAt(ai - 1, "A");
                    if (compare(__ss, s) < 0) {
                        s = __ss;
                        continue;
                    }
            }
    }
}

   return s;
}

function compare(s1, s2) {
    return s1.localeCompare(s2)
}

String.prototype.replaceAt = function(index, replacement) {
    return this.substring(0, index) + replacement + this.substring(index + replacement.length);
}

function main() {
    // const ws = fs.createWriteStream(process.env.OUTPUT_PATH);

    const test_cases = parseInt(readLine().trim(), 10);

    for (let gItr = 0; gItr < test_cases; gItr++) {
        // const n = parseInt(readLine().trim(), 10);
        const arr = readLine().replace(/\s+$/g, '').split(' ').map(arrTemp => parseInt(arrTemp, 10));

        const n = arr[0]
        const m = arr[1]

        if (n == 1 && m == 1) {
            console.log("Tonya")
        } else {
            if (n%2 ==0 && m%2 == 0) {
                console.log("Tonya")
            } else {
                console.log("Burenka")
            }
        }

    }

    // ws.end();
}


const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const n = +lines[l++]
        output[i] = solve(n)
    }
    console.log(output.join('\n'))
// })()
})

function solve(n) {
    if (n === 1) return 3
    const s = n.toString(2)
    let one = 0
    let ans = 0
    let p = 1
    for (let i = s.length - 1; i >= 0; i--) {
        if (s[i] === '1') {
            one++
            if (!ans) {
                ans = p
            }
        }
        p *= 2
    }
    return one > 1 ? ans : ans + 1
}

'use strict';

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

let inputString = '';
let currentLine = 0;

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

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

    main();
});

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

function output(x) {
    if (typeof x !== 'string') {
        x = x.toString();
    }
    //process.stdout.write(x);   // without auto '\n' (newline)
    console.log(x);  // with auto '\n' (newline)
}

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

    const isPowerOfTwo = n => n && (n & (n - 1)) === 0;

    for (let test = 0; test < N; test++) {
        let x = parseInt(readline(), 10);
        if (x === 1) {
            output('3');
            continue;
        }
        let str = x.toString(2).split('').reverse();
        let first1 = str.indexOf('1');
        let isPow2 = isPowerOfTwo(x);
        let res = 2 ** first1;
        if (isPow2) {
            res += 1;
        }
        output(res);
    }
}

const lines = [];
const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
rl.on('line', line => lines.push(line));
rl.on('close', main);
let rli = 0;
function readline() {
    return lines[rli++];
}

const ra = ()=>readline().split(' ').map(a=>+a);

/*---------------------------------------------------*/

function div(val, by){
    return (val - val % by) / by;
}

const calc = (t)=>{
    /* read */
    // let [a, b, c, d] = ra();
    let x = +readline();
    if (x === 1) return 3;

    let one = -1;
    let ones = 0;
    let zero = -1;

    for (let i = 0; i < 31; i++) {
        if (x & (1 << i)) {
            if (one === -1) one = i;
            ones++;
        }
    }

    if (ones > 1) {
        return (1 << one);
    } else {
        return (1 << one) + 1;
    }
};

function main() {
    let T = +readline();
    let out = [];
    for (let t = 1; t <= T; t++){
        out.push(calc(t));
        // process.stdout.write(`${calc(t)}\n`);
    }
    process.stdout.write(out.join('\n')+'\n');
}

'use strict';

function solve(n) {
  let t = -1,
      one = 0;
  for (let i = 0; i < 31; i++) {
    if (n & 1 << i) {
      if (t === -1) t = i;
      one++;
    }
  }
  let res = 1 << t;
  if (one > 1) return res;
  if (t > 0) return res | 1;else return 3;
}

async function main(read) {
  try {
    let res = [];
    let t = Number(await read());
    while (t--) {
      const n = Number(await read());
      res.push(solve(n));
    }
    console.log(res.join('\n'));
  } catch (error) {
    console.log(error);
  }
}

let inputs,
    str = '';
function read() {
  return inputs.next().value.trim();
}
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', input => str += input);
process.stdin.on('end', () => {
  inputs = str.split('\n').values();
  main(read);
});

function getMinY(x) {
    const rightBit = x % 2;
    let countOfEqualRightBits = 0;
    let res = 0;
    let shiftedX = x;
    while (shiftedX % 2 === rightBit) {
        shiftedX >>= 1;
        ++countOfEqualRightBits;
    }

    const shiftedBits = 1 << countOfEqualRightBits;
    if (rightBit === 0) {
        res = shiftedBits;

        if (res == x) {
            ++res;
        }
    } else {
        res += 1;

        if (x === 1) {
            res += shiftedBits;
        }
    }

    return res;
}

function main() {
    let t = +readline();

    while (t > 0) {

        const curX = +readline();
        console.log(getMinY(curX));
        --t;
    }
}

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

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 getMinY(x) {
    const rightBit = x % 2;
    let countOfEqualRightBits = 0;
    let res = 0;
    let shiftedX = x;
    while (shiftedX % 2 === rightBit) {
        shiftedX >>= 1;
        ++countOfEqualRightBits;
    }

    const shiftedBits = 1 << countOfEqualRightBits;
    if (rightBit === 0) {
        res = shiftedBits;

        if (res == x) {
            ++res;
        }
    } else {
        res += 1;

        if (shiftedBits - 1 === x) {
            res += shiftedBits;
        }
    }

    return res;
}

function main() {
    let t = +readline();

    while (t > 0) {

        const curX = +readline();
        console.log(getMinY(curX));
        --t;
    }
}

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

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

const lines = [];
const rl = require('readline').createInterface({ input: process.stdin, output: process.stdout });
rl.on('line', line => lines.push(line));
rl.on('close', main);
let rli = 0;
function readline() {
    return lines[rli++];
}

const ra = ()=>readline().split(' ').map(a=>+a);

/*---------------------------------------------------*/

function div(val, by){
    return (val - val % by) / by;
}

const calc = (t)=>{
    /* read */
    // let [a, b, c, d] = ra();
    let x = +readline();
    let one = -1;
    let ones = 0;
    let zero = -1;

    for (let i = 0; i < 31; i++) {
        if (x & (1 << i)) {
            if (one === -1) one = i;
            ones++;
        }
    }
    for (let i = 0; i < 31; i++) {
        if ((x ^ (1 << i)) & (1 << i)) {
            zero = i;
            break;
        }
    }

    if (zero === -1) {
        return x + 2;
    } else if (ones > 1) {
        return (1 << one);
    } else {
        return (1 << one) + 1;
    }
};

function main() {
    let T = +readline();
    let out = [];
    for (let t = 1; t <= T; t++){
        out.push(calc(t));
        // process.stdout.write(`${calc(t)}\n`);
    }
    process.stdout.write(out.join('\n')+'\n');
}


'use strict';

var fs = require('fs');

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

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

function solve(read) {
  const [rn, rb, rns, re, rbs] = convertInput(read);
  const [a, b, c, d] = rns();
  const cnt = new Map();
  const calc = n => {
    var _cnt$get2;
    for (let i = 2; i <= n / i; i++) {
      if (n % i === 0) {
        while (n % i === 0) {
          var _cnt$get;
          cnt.set(i, ((_cnt$get = cnt.get(i)) !== null && _cnt$get !== void 0 ? _cnt$get : 0) + 1);
          n /= i;
        }
      }
    }
    if (n > 1) cnt.set(n, ((_cnt$get2 = cnt.get(n)) !== null && _cnt$get2 !== void 0 ? _cnt$get2 : 0) + 1);
  };
  calc(a);
  calc(b);
  const p = [...cnt.entries()];
  const [A, B, C, D] = [a, b, c, d].map(BigInt);
  const t = A * B;
  const check = (a, b, c) => {
    if (c > a && c <= b) return c;
    let x = a / c;
    if (x * c <= a) x++;
    if (x * c <= b) return x * c;
    return -1n;
  };
  let res = [-1n, -1n];
  const dfs = (i, num) => {
    if (i === p.length) {
      if (num > t) return false;
      let a = check(A, C, num),
          b = check(B, D, t / num);
      if (a !== -1n && b !== -1n) {
        res = [a, b];
        return true;
      }
      return false;
    }
    const [x, y] = p[i];
    for (let j = 0; j <= y; j++) {
      if (dfs(i + 1, num * BigInt(x ** j))) return true;
    }
  };
  dfs(0, 1n);
  return res.join(' ');
}
function convertInput(read) {
  const rn = () => Number(read());
  const rb = () => BigInt(read());
  const rns = () => read().split(/\s+/).map(Number);
  const re = () => read().split(/\s+/).map(s => Number(s) - 1);
  const rbs = () => read().split(/\s+/).map(BigInt);
  return [rn, rb, rns, re, rbs];
}
function main(r) {
  try {
    let t = Number(r());
    let res = new Array(t);
    let limit = 0;
    for (let i = 0; i < t; i++) {
      var _solve;
      const s = (_solve = solve(r)) !== null && _solve !== void 0 ? _solve : '';
      if (t < limit) {
        process.stdout.write(s.toString());
        process.stdout.write('\n');
      } else {
        res[i] = s;
      }
    }
    if (t >= limit) {
      return res.join('\n');
    } else {
      return '';
    }
  } catch (error) {
    console.log(error);
  }
}

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

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const [a, b, c, d] = lines[l++].trim().split(' ').map(Number)
        output[i] = solve(a, b, c, d).join(' ')
    }
    console.log(output.join('\n'))
// })()
})
// const PRIMES = primes(4e4)
// console.log(PRIMES.slice(-3))
const PRIMES = primes(Math.ceil(Math.sqrt(1e9)))
function primes(n) {
    const filtered = Array(n + 1)
    const ps = []
    let count = 0
    // const phi = Array(n + 1).fill(0)
    // phi[1] = 1
    // const mu = Array(n + 1).fill(0)
    // mu[1] = 1

    for (let i = 2; i <= n; i++) {
        if (!filtered[i]) {
            ps[count++] = i
            // phi[i] = i - 1
            // mu[i] = -1
        }
        for (let j = 0; j < count; j++) {
            const k = i * ps[j]
            if (k > n) break

            filtered[k] = 1
            if (i % ps[j]) {
                // phi[k] = phi[i] * (ps[j] - 1)
                // mu[k] = -mu[i]
            } else {
                // phi[k] = phi[i] * ps[j]
                // mu[k] = 0
                break
            }
        }
    }
    return ps
}
function getFactors(n) {
    if (n < 2) return [[n, 1]]

    const r = []
    let x = n
    PRIMES.some(p => {
        let c = 0
        while (!(x % p)) {
            c++
            x /= p
        }
        if (c) r.push([p, c])
        if (p >= x) return true
    })
    if (x > 1) r.push([x, 1])
    return r
}
function solve(a, b, c, d) {
    const af = getFactors(a)
    const bf = getFactors(b)
// console.log(af, bf)
    const m = {}
    for (let [p, k] of af) {
        m[p] = (m[p] || 0) + k
    }
    for (let [p, k] of bf) {
        m[p] = (m[p] || 0) + k
    }
// console.log(m)
    //
    // return []
    const prod = BigInt(a) * BigInt(b)
    const max = 1000000000n
    const ks = Object.keys(m).map(k => {
        k = BigInt(k)
        // key, count, pow
        return [k, m[k], k ** BigInt(m[k])]
    })
    let count = Array(ks.length).fill(0)
    let now = 1n
    let ok = true
    while (ok) {
// console.log(now, count)
        let k1 = now
        let k2 = prod / k1
        if (k1 > max || k2 > max) {
            update()
            continue
        }
        k1 = Number(k1)
        k2 = Number(k2)
        const r1 = has(k1, a, c)
        const r2 = has(k2, b, d)
// console.log(k1, k2, r1, r2)
        if (r1 < 0 || r2 < 0) {
            update()
        } else {
            return [r1, r2]
        }
    }
    return [-1, -1]

    function update() {
        let i = 0
        while (i < ks.length) {
            if (count[i] + 1 <= ks[i][1]) {
                count[i]++
                now *= ks[i][0]
                return
            } else {
                count[i] = 0
                now /= ks[i][2]
                i++
            }
        }
        ok = false
    }
}
function has(k, a, b) {
    // (a, b]
    let r = Math.ceil(a / k) * k
    if (r === a) r += k
    return r <= b ? r : -1
}
function factors(n) {
    const limit = Math.ceil(Math.sqrt(n))
    const r = []
    for (let i = 1; i < limit; i++) {
        if (!(n % i)) {
            r.push(i, n / i)
        }
    }
    if (!(n % limit)) r.push(limit)
    return r
}

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const [a, b, c, d] = lines[l++].trim().split(' ').map(Number)
        output[i] = solve(a, b, c, d).join(' ')
    }
    console.log(output.join('\n'))
// })()
})
const PRIMES = primes(Math.ceil(Math.sqrt(1e9)))
function primes(n) {
    const filtered = Array(n + 1)
    const ps = []
    let count = 0
    // const phi = Array(n + 1).fill(0)
    // phi[1] = 1
    // const mu = Array(n + 1).fill(0)
    // mu[1] = 1

    for (let i = 2; i <= n; i++) {
        if (!filtered[i]) {
            ps[count++] = i
            // phi[i] = i - 1
            // mu[i] = -1
        }
        for (let j = 0; j < count; j++) {
            const k = i * ps[j]
            if (k > n) break

            filtered[k] = 1
            if (i % ps[j]) {
                // phi[k] = phi[i] * (ps[j] - 1)
                // mu[k] = -mu[i]
            } else {
                // phi[k] = phi[i] * ps[j]
                // mu[k] = 0
                break
            }
        }
    }
    return ps
}
function getFactors(n) {
    if (n < 2) return [[n, 1]]

    const r = []
    let x = n
    PRIMES.some(p => {
        let c = 0
        while (!(x % p)) {
            c++
            x /= p
        }
        if (c) r.push([p, c])
        if (p >= x) return true
    })
    return r
}
function solve(a, b, c, d) {
    const af = getFactors(a)
    const bf = getFactors(b)
// console.log(af, bf)
    const m = {}
    for (let [p, k] of af) {
        m[p] = (m[p] || 0) + k
    }
    for (let [p, k] of bf) {
        m[p] = (m[p] || 0) + k
    }
// console.log(m)
    //
    // return []
    const prod = BigInt(a) * BigInt(b)
    const max = 1000000000n
    const ks = Object.keys(m).map(k => {
        k = BigInt(k)
        // key, count, pow
        return [k, m[k], k ** BigInt(m[k])]
    })
    let count = Array(ks.length).fill(0)
    let now = 1n
    let ok = true
    while (ok) {
// console.log(now, count)
        let k1 = now
        let k2 = prod / k1
        if (k1 > max || k2 > max) {
            update()
            continue
        }
        k1 = Number(k1)
        k2 = Number(k2)
        const r1 = has(k1, a, c)
        const r2 = has(k2, b, d)
// console.log(k1, k2, r1, r2)
        if (r1 < 0 || r2 < 0) {
            update()
        } else {
            return [r1, r2]
        }
    }
    return [-1, -1]

    function update() {
        let i = 0
        while (i < ks.length) {
            if (count[i] + 1 <= ks[i][1]) {
                count[i]++
                now *= ks[i][0]
                return
            } else {
                count[i] = 0
                now /= ks[i][2]
                i++
            }
        }
        ok = false
    }
}
function has(k, a, b) {
    // (a, b]
    let r = Math.ceil(a / k) * k
    if (r === a) r += k
    return r <= b ? r : -1
}
function factors(n) {
    const limit = Math.ceil(Math.sqrt(n))
    const r = []
    for (let i = 1; i < limit; i++) {
        if (!(n % i)) {
            r.push(i, n / i)
        }
    }
    if (!(n % limit)) r.push(limit)
    return r
}


var dataitr;
var stdin_input = "";
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { dataitr = stdin_input.split('\n').values(); main(); });

const rl = () => dataitr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

const INF = 99;

const g = [];

function main () {
	let T = rn();
	while (T--) {
		let [n, m, r, c] = rna();
		r--;c--;

		let ans = INF;
		for (let i = 0; i < n; i++) {
			g[i] = rl();
			for (let j = 0; j < m; j++) {
				if (g[i][j] == 'B') {
					if (i == r && j == c)
						ans = Math.min(ans, 0);
					else if (i == r || j == c)
						ans = Math.min(ans, 1);
					else
						ans = Math.min(ans, 2);
				}
			}
		}

		console.log(ans == INF ? -1 : ans);
	}
}

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.num = function() {
		return nl.elem(Number);
	};

nl.nums = function() {
		return nl.array(Number);
	};

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

const sol = () => {
	//your code this
	let t = nl.num();
	let ans = [];
	for(let i = 0; i < t; i++) {
		let [h, w, r, c] = nl.nums();
		r--;
		c--;
		let p = [];
		for(let j = 0; j < h; j++){
			p.push(nl.line().split('').map(e => 'B' === e));
		}
		if (p[r][c]){
			ans.push(0);
		} else {
			let flag = p[r].some(e => e);
			if (!flag) {
				for(let j = 0; j < h && !flag; j++){
					flag  = p[j][c];
				}
			}
			if (flag) {
				ans.push(1);
			} else {
				if (p.some(e => e.some(e => e))) {
					ans.push(2);
				} else {
					ans.push(-1);
				}
			}
		}
	}
	console.log(ans.join('\n'));
};

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

const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').trim().split('\n');
let currentline = 0;
function readline(){
    return input[currentline++];
}

var T = readline();
for(var q=1;q<=T;q++) {
            var [n,m,r,c] = readline().split(" ").map(w => parseInt(w))
            var g = []
            for(var i=0;i<n;i++) {
                var f = readline();
                g.push(f)
            }
            var inf = 100000000000;
            console.log(solve(g))
            function solve(g) {
                if(g[r-1][c-1] == 'B') return 0;
            	var ans = inf;
            	for(var i=0;i<g.length;i++) {
            	  for(var j=0;j<g[i].length;j++) {
            	  	if(g[i][j] == 'B') {
            	  		ans = 2;
            	  		if(j+1 == c || i+1 == r) {
            	  		  ans = 1;
            	  		  return 1;
            	  		}
            	  	}
            	  }
            	}
            	return ans == inf ? -1 : ans;
            }
}

'use strict';

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

let inputString = '';
let currentLine = 0;

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

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

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

function output(x) {
    if (typeof x !== 'string') {
        x = x.toString();
    }
    //process.stdout.write(x);   // without auto '\n' (newline)
    console.log(x);  // with auto '\n' (newline)
}

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

    for (let test = 0; test < N; test++) {
        let [n, m, r, c] = readline().split(' ').map(Number);

        let grid = new Array(n);
        for (let i = 0; i < n; i++) {
            grid[i] = readline().split('');
        }

        if (grid[r - 1][c - 1] === 'B') {
            output(0);
            continue;
        }

        let rowBlack = false;
        for (let i = 0; i < m; i++) {
            if (grid[r - 1][i] === 'B') {
                rowBlack = true;
                break;
            }
        }
        let colBlack = false;
        for (let i = 0; i < n; i++) {
            if (grid[i][c - 1] === 'B') {
                colBlack = true;
                break;
            }
        }

        if (rowBlack || colBlack) {
            output(1);
            continue;
        }

        let black = false;
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < m; j++) {
                if (grid[i][j] === 'B') {
                    black = true;
                    break;
                }
            }
        }

        if (black) {
            output(2);
        } else {
            output(-1);
        }
    }
}

/**
 * Author : Fazlul Hoque
 * Node.js version : 12.16.3
 * command : node fileName.js <input.txt >output.txt
 */
"use strict";
process.stdin.resume();
process.stdin.setEncoding("utf-8");
let inputString = ""; //An array of  raw inputs (includes 'n,\r , not usable. need to process before use)
let currentLine = 0; //input sequence controller variable.

process.stdin.on("data", (inputStdin) => {
    inputString += inputStdin;
});
process.stdin.on("end", () => {
    inputString = inputString.split("\n");
    main(); // after input
});

/********** Utility Functions Start **********/
/**
 *  read row Input
 * @returns string
 */
function _readRawLine() {
    return inputString[currentLine++];
}
function readLine(){
    // return _readRawLine().replace(/\s+$/g, '');
    return _readRawLine().replace('\r', '');
}

function print(x) {
    console.log(x);
}

function readSingleInt() {
    const p = readLine();
    return parseInt(p);
}

function readIntArray() {
    return readLine().split(" ").map((v) => parseInt(v));
}

function readArray() {
    return readLine().split(" ");
}

function int(n) {
    return parseInt(n);
}
/********** Utility Functions End **********/
/**
 * Don't Touch this fucntion at all , unless you know what are you doing!
 */
function main() {
    solve();
}

// ********** actual Code Starts from here **********

function solve() {
        let t=readSingleInt();
        while(t--){
            let br = false;
            let [n,m,r,c] = readIntArray();
            // console.log(n,m,r,c)
            let grid = [];
            for(let i=0;i<n;i++){
                grid.push(Array.from(readLine()));
            }
            if(grid[r-1][c-1]=='B'){
                console.log(0);
                continue;
            }
            if(grid[r-1].includes('B')){
                console.log("1");
                continue;
            }
            for(let i=0;i<n;i++){
                if(grid[i][c-1]=='B'){
                    console.log('1');
                    br=true;
                    break;
                }
            }
            if(br){
                continue;
            }
            for(let i=0;i<n;i++){
                if(grid[i].includes('B')){
                    console.log("2");
                    br=true;
                    break;
                }
            }
            if(!br){
                console.log('-1');
            }

        }

}

let _inputLines;
let _lineNumber = 0;
let inputReader = _inputReader ();

function _main() {

	_inputLines = _inputData.trim().split('\n').map((string) => {
		return string.trim();
	});;
	let t = inputReader.readNumber();
	//let t = 1;
	function solve() {
	  let [n, m, x, y] = inputReader.readNumberArray();
	  let grid = [];
	  for(let i = 0; i < n; i++) {
	    let row = inputReader.readLine();
	    grid.push(row);
	  }
	  if(grid[x-1][y-1]=='B') {
	    console.log(0);
	    return;
	  }
	  let ans = Infinity;
	  for(let i = 0; i < n; i++) {
	    for(let j = 0; j < m; j++) {
	      if(grid[i][j] == 'B') {
	        if(i == x - 1 || j == y - 1) {
	          ans = Math.min(ans, 1);
	        }
	        else {
	          ans = Math.min(ans, 2);
	        }
	      }
	    }
	  }
	  console.log(ans==Infinity?-1:ans);

	}

	while (t--) {
	  solve();
	}

}

var _inputData = '';
function cacheInput(data) {
	_inputData += data;
}

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', cacheInput).on('end', _main);

function _inputReader () {
	function readNumber(){
		return Number(_inputLines[_lineNumber++]);
	}

	function readLine(){
		return _inputLines[_lineNumber++];
	}

	function readNumberArray(){
		return _inputLines[_lineNumber++].split(' ').map(val => Number(val));
	}

	return {
		readNumber,
		readLine,
		readNumberArray,
	}
}

/* Common Template Starts */
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++];
}
/* Common Template Ends */

function main() {
    //take input according to the format;
    const t = +(readline());
    for(let i =0; i<t; ++i){

        let [m,n,p,q] = readline().split(" ").map(el => parseInt(el));
        let arr = [];
        let columnStr = '';
        for(let j =0; j<m; ++j){

            let str = readline();
            columnStr += str[q-1];
            arr.push(str)
        }

        if(arr[p-1][q-1]==="B"){
                console.log(0);
            }
            else
            if(arr[p-1].includes("B")){
                console.log(1);
            }
            else
            if(columnStr.includes('B')){
                console.log(1);
            }
            else
            if(arr.join('').includes('B')){
                console.log(2);
            }
            else
            console.log(-1)

    }
}

 var t = parseInt(readline());
  function solve(){
    var inp = readline()
      .split(" ")
      .map((data) => +data);
    var arr = []
    var count = 0
    for(var i = 0; i < inp[0]; i++){
      var s = readline()
      arr[i] = s
      for(var j = 0; j < inp[1]; j++){
          if(s[j] === "B"){
            count++
          }
      }
    }
    if(count === 0) return -1;

    var r1 = 0;
    var c1 = 0;

        for(var j = 0; j < inp[1]; j++){
            if(arr[inp[2]-1][j]==='B')
            {
                r1=1;
                break;
            }
        }
        for(var j = 0; j < inp[0]; j++){
            if(arr[j][inp[3]-1]==='B')
            {
                c1=1;
                break;
            }
        }

       if(arr[inp[2]-1][inp[3]-1]=='B') return 0;
        else if(r1==1 || c1==1) return 1;
        else return 2;
  }

while(t--){
   print(solve())
}

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.num = function() {
		return nl.elem(Number);
	};

nl.nums = function() {
		return nl.array(Number);
	};

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

const sol = () => {
	//your code this
	let t = nl.num();
	let ans = [];
	for(let i = 0; i < t; i++) {
		let [h, w, r, c] = nl.nums();
		r--;
		c--;
		let p = [];
		for(let j = 0; j < h; j++){
			p.push(nl.line().split('').map(e => 'B' === e));
		}
		console.log(p);
		if (p[r][c]){
			ans.push(0);
		} else {
			let flag = p[r].some(e => e);
			if (!flag) {
				for(let j = 0; j < h && !flag; j++){
					flag  = p[j][c];
				}
			}
			if (flag) {
				ans.push(1);
			} else {
				if (p.some(e => e.some(e => e))) {
					ans.push(2);
				} else {
					ans.push(-1);
				}
			}
		}
	}
	console.log(ans.join('\n'));
};

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

const fs = require('fs');
const input = fs.readFileSync(0, 'utf8').trim().split('\n');
let currentline = 0;
function readline(){
    return input[currentline++];
}

var T = readline();
for(var q=1;q<=T;q++) {
            var [n,m,r,c] = readline().split(" ").map(w => parseInt(w))
            var g = []
            for(var i=0;i<n;i++) {
                var f = readline();
                g.push(f)
            }
            var inf = 100000000000;
            console.log(solve(g))
            function solve(g) {
            	var ans = inf;
            	for(var i=0;i<g.length;i++) {
            	  for(var j=0;j<g[i].length;j++) {
            	  	if(g[i][j] == 'B') {
            	  		ans = 2;
            	  		if(j+1 == c || i+1 == r) {
            	  		  ans = 1;
            	  		  return 1;
            	  		}
            	  	}
            	  }
            	}
            	return ans == inf ? -1 : ans;
            }
}

 var t = parseInt(readline());
  function solve(){
    var inp = readline()
      .split(" ")
      .map((data) => +data);
    var arr = []
    var count = 0
    for(var i = 0; i < inp[0]; i++){
      var s = readline()
      arr[i] = s
      for(var j = 0; j < inp[1]; j++){
          if(s[j] === "B"){
            count++
          }
      }
    }
    if(count === 0) return -1;

    var r1 = 0;
    var c1 = 0;

        for(var j = 0; j < inp[1]; j++){
            if(arr[inp[2]-1][i]=='B')
            {
                r1=1;
                break;
            }
        }
        for(var j = 0; j < inp[0]; j++){
            if(arr[j][inp[3]-1]=='B')
            {
                c1=1;
                break;
            }
        }

       if(arr[inp[2]-1][inp[3]-1]=='B') return 0;
        else if(r1==1 || c1==1) return 1;
        else return 2;
  }

while(t--){
   print(solve())
}

 var t = parseInt(readline());
  function solve(){
    var inp = readline()
      .split(" ")
      .map((data) => +data);
    var arr = []
    var count = 0
    for(var i = 0; i < inp[0]; i++){
      var s = readline()
      arr[i] = s
      for(var j = 0; j < inp[1]; j++){
          if(s[j] === "B"){
            count++
          }
      }
    }
    if(count === 0) return -1;

    var r1 = 0;
    var c1 = 0;

        for(var j = 0; j < inp[1]; j++){
            if(arr[inp[2]-1][i]=='B')
            {
                r1=1;
                break;
            }
        }
        for(var j = 0; j < inp[0]; j++){
            if(arr[j][inp[3]-1]=='B')
            {
                r1=1;
                break;
            }
        }

       if(arr[inp[2]-1][inp[3]-1]=='B') return 0;
        else if(r1==1 || c1==1) return 1;
        else return 2;
  }

while(t--){
   print(solve())
}


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

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

function Arr(a, b, fn, init) {
  if (a < b) {
    let arr = Array(b + 1);
    if (init) init(arr);
    for (let i = a; i <= b; i++) arr[i] = fn(i, arr);
    return arr;
  } else {
    let arr = Array(a + 1);
    if (init) init(arr);
    for (let i = a; i >= b; i--) arr[i] = fn(i, arr);
    return arr;
  }
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  let ans = [];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    // let a = Arr(1, n, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    // let cal = i => {
    //   if (a[i] > a[i - 1] && a[i] > a[i + 1]) return a[i]
    //   if (a[i] < a[i - 1] && a[i] < a[i + 1]) return -a[i];
    //   return 0;
    // }
    // let b = Arr(1, n, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    // let res = b.sum();
    // console.log(res);
    // let update = (i, v) => {
    //   res -= b[i - 1] + b[i] + b[i + 1];
    //   a[i] = v;
    //   b[i] = cal(i);
    //   if (i > 1) b[i - 1] = cal(i - 1)
    //   if (i < n) b[i + 1] = cal(i + 1)
    //   res += b[i - 1] + b[i] + b[i + 1];
    // }
    // if (q) For(1, q, i => {
    //   let li = inp[r++], ri = inp[r++];
    //   let temp = a[li];
    //   update(li, a[ri]);
    //   update(ri, temp);
    //   console.log(res);
    // })

    let a = Array(n + 2).fill(0);
    for (let i = 1; i <= n; i++) a[i] = inp[r++];
    let b = Array(n + 2).fill(0);
    let cal = i => {
      if (a[i] > a[i - 1] && a[i] > a[i + 1]) b[i] = a[i];
      else if (a[i] < a[i - 1] && a[i] < a[i + 1]) b[i] = -a[i];
      else b[i] = 0;
    }
    for (let i = 1; i <= n; i++) cal(i);
    let res = 0;
    for (let i = 1; i <= n; i++) res += b[i];
    ans.push(res);
    let update = (i, v) => {
      res -= b[i - 1] + b[i] + b[i + 1];
      a[i] = v;
      cal(i);
      if (i > 1) cal(i - 1);
      if (i < n) cal(i + 1);
      res += b[i - 1] + b[i] + b[i + 1];
    }
    while (q--) {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      ans.push(res);
    }
  }
  console.log(ans.join('\n'))
})();

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

function For(a, b, step, fn) {
  let res;
  for (let i = a; i <= b; i += step) {
    if ((res = fn(i)) != null) return res;
  }
}

function Arr(a, b, step, fn, init) {
  let arr = Array(Math.max(a, b) + 1);
  if (init) init(arr);
  for (let i = a; i <= b; i += step) arr[i] = fn(i, arr);
  return arr;
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  let ans = [];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    let a = Arr(1, n, 1, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    let cal = i => {
      if (a[i] > a[i - 1] && a[i] > a[i + 1]) return a[i]
      if (a[i] < a[i - 1] && a[i] < a[i + 1]) return -a[i];
      return 0;
    }
    let b = Arr(1, n, 1, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    let res = b.sum();
    ans.push(res);
    let update = (i, v) => {
      res -= b[i - 1] + b[i] + b[i + 1];
      a[i] = v;
      b[i] = cal(i);
      if (i > 1) b[i - 1] = cal(i - 1)
      if (i < n) b[i + 1] = cal(i + 1)
      res += b[i - 1] + b[i] + b[i + 1];
    }
    For(1, q, 1, i => {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      ans.push(res);
    })
  }
  console.log(ans.join('\n'))
})();

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

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

function Arr(a, b, fn, init) {
  if (a < b) {
    let arr = Array(b + 1);
    if (init) init(arr);
    for (let i = a; i <= b; i++) arr[i] = fn(i, arr);
    return arr;
  } else {
    let arr = Array(a + 1);
    if (init) init(arr);
    for (let i = a; i >= b; i--) arr[i] = fn(i, arr);
    return arr;
  }
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  // let ans = [];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    // let a = Arr(1, n, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    // let cal = i => {
    //   if (a[i] > a[i - 1] && a[i] > a[i + 1]) return a[i]
    //   if (a[i] < a[i - 1] && a[i] < a[i + 1]) return -a[i];
    //   return 0;
    // }
    // let b = Arr(1, n, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    // let res = b.sum();
    // console.log(res);
    // let update = (i, v) => {
    //   res -= b[i - 1] + b[i] + b[i + 1];
    //   a[i] = v;
    //   b[i] = cal(i);
    //   if (i > 1) b[i - 1] = cal(i - 1)
    //   if (i < n) b[i + 1] = cal(i + 1)
    //   res += b[i - 1] + b[i] + b[i + 1];
    // }
    // if (q) For(1, q, i => {
    //   let li = inp[r++], ri = inp[r++];
    //   let temp = a[li];
    //   update(li, a[ri]);
    //   update(ri, temp);
    //   console.log(res);
    // })

    let a = Array(n + 2).fill(0);
    for (let i = 1; i <= n; i++) a[i] = inp[r++];
    let b = Array(n + 2).fill(0);
    let cal = i => {
      if (a[i] > a[i - 1] && a[i] > a[i + 1]) b[i] = a[i];
      else if (a[i] < a[i - 1] && a[i] < a[i + 1]) b[i] = -a[i];
      else b[i] = 0;
    }
    for (let i = 1; i <= n; i++) cal(i);
    let res = 0;
    for (let i = 1; i <= n; i++) res += b[i];
    // ans.push(res);
    process.stdout.write(res + '\n');
    let update = (i, v) => {
      res -= b[i - 1] + b[i] + b[i + 1];
      a[i] = v;
      cal(i);
      if (i > 1) cal(i - 1);
      if (i < n) cal(i + 1);
      res += b[i - 1] + b[i] + b[i + 1];
    }
    while (q--) {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      process.stdout.write(res + '\n');
    }
  }
  // console.log(ans.join('\n'))
})();

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

function For(a, b, step, fn) {
  let res;
  for (let i = a; i <= b; i += step) {
    if ((res = fn(i)) != null) return res;
  }
}

function Arr(a, b, step, fn, init) {
  let arr = Array(Math.max(a, b) + 1);
  if (init) init(arr);
  for (let i = a; i <= b; i += step) arr[i] = fn(i, arr);
  return arr;
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v), _r = 0, $ = n => n != null ? inp.slice(_r, _r += n) : inp[_r++], out = [];
  let test = $()
  while (test--) {
    let [n, q] = $(2)
    let a = Arr(1, n, 1, (i, a) => a[i] = $(), a => a[0] = a[n + 1] = 0)
    let cal = i => {
      if (a[i] > a[i - 1] && a[i] > a[i + 1]) return a[i]
      if (a[i] < a[i - 1] && a[i] < a[i + 1]) return -a[i];
      return 0;
    }
    let b = Arr(1, n, 1, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    let res = b.sum();
    out.push(res);
    let update = (i, v) => {
      res -= b[i - 1] + b[i] + b[i + 1];
      a[i] = v;
      b[i] = cal(i);
      if (i > 1) b[i - 1] = cal(i - 1)
      if (i < n) b[i + 1] = cal(i + 1)
      res += b[i - 1] + b[i] + b[i + 1];
    }
    while (q--) {
      let [li, ri] = $(2)
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      out.push(res);
    }
  }
  console.log(out.join('\n'))
})();

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

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

function Arr(a, b, fn, init) {
  if (a < b) {
    let arr = Array(b + 1).fill(0);
    if (init) init(arr);
    for (let i = a; i <= b; i++) arr[i] = fn(i, arr);
    return arr;
  } else {
    let arr = Array(a + 1).fill(0);
    if (init) init(arr);
    for (let i = a; i >= b; i--) arr[i] = fn(i, arr);
    return arr;
  }
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    let a = Arr(1, n, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    let cal = i => (a[i] > a[i - 1] && a[i] > a[i + 1]) ? 1 : (a[i] < a[i - 1] && a[i] < a[i + 1]) ? -1 : 0;
    let b = Arr(1, n, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    let res = 0;
    For(1, n, i => { res += a[i] * b[i] });
    console.log(res);
    let update = (i, v) => {
      res -= a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
      a[i] = v;
      b[i] = cal(i);
      if (i > 1) b[i - 1] = cal(i - 1)
      if (i < n) b[i + 1] = cal(i + 1)
      res += a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
    }
    For(1, q, i => {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      console.log(res);
    })

    // let a = Array(n + 2).fill(0);
    // for (let i = 1; i <= n; i++) a[i] = inp[r++];
    // let b = Array(n + 2).fill(0);
    // let cal = i => {
    //   if (a[i] > a[i - 1] && a[i] > a[i + 1]) return 1;
    //   if (a[i] < a[i - 1] && a[i] < a[i + 1]) return -1;
    //   return 0;
    // }
    // for (let i = 1; i <= n; i++) b[i] = cal(i);
    // let res = 0;
    // for (let i = 1; i <= n; i++) res += a[i] * b[i];
    // console.log(res);
    // let update = (i, v) => {
    //   res -= a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
    //   a[i] = v;
    //   b[i] = cal(i);
    //   if (i > 1) b[i - 1] = cal(i - 1);
    //   if (i < n) b[i + 1] = cal(i + 1);
    //   res -= a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
    // }
    // while (q--) {
    //   let li = inp[r++], ri = inp[r++];
    //   let temp = a[li];
    //   update(li, a[ri]);
    //   update(ri, temp);
    //   console.log(res);
    // }
  }
})();

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

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

function Arr(a, b, fn, init) {
  if (a < b) {
    let arr = Array(b + 1);
    if (init) init(arr);
    for (let i = a; i <= b; i++) arr[i] = fn(i, arr);
    return arr;
  } else {
    let arr = Array(a + 1);
    if (init) init(arr);
    for (let i = a; i >= b; i--) arr[i] = fn(i, arr);
    return arr;
  }
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    let a = Arr(1, n, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    let cal = i => a[i] > a[i - 1] && a[i] > a[i + 1] ? 1 : a[i] < a[i - 1] && a[i] < a[i + 1] ? -1 : 0;
    let b = Arr(1, n, (i, b) => b[i] = cal(i), b => b[0] = b[n + 1] = 0);
    let res = 0;
    For(1, n, i => { res += a[i] * b[i] });
    console.log(res);
    let update = (i, v) => {
      res -= a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
      a[i] = v;
      b[i] = cal(i);
      if (i >= 2) b[i - 1] = cal(i - 1)
      if (i <= n - 1) b[i + 1] = cal(i + 1)
      res += a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
    }
    For(1, q, i => {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li, a[ri]);
      update(ri, temp);
      console.log(res);
    })
  }
})();

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

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

function Arr(a, b, fn, init) {
  if (a < b) {
    let arr = Array(b + 1);
    if (init) init(arr);
    for (let i = a; i <= b; i++) arr[i] = fn(i, arr);
    return arr;
  } else {
    let arr = Array(a + 1);
    if (init) init(arr);
    for (let i = a; i >= b; i--) arr[i] = fn(i, arr);
    return arr;
  }
}

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

function gcd(a, b) {
  if (!b) return a;
  return gcd(b, a % b);
}
function mod(a, n, m) {
  if (n == 0n) return 1n;
  if (n % 2n == 0n) return mod(a * a % m, n / 2n, m);
  return a * mod(a, n - 1n, m) % m;
}
function extendedEuclid(a, b) {
  if (!b) return [1, 0];
  else {
    let [x, y] = extendedEuclid(b, a % b);
    return [y, x - (a / b | 0) * y];
  }
}
// [m] = extendedEuclid(a, 998244353);
// let MOD = 998244353n;
// let gt = Arr(0, n, (i, a) => i == 0 ? 1n : a[i - 1] * BigInt(i) % MOD);
// let rgt = Arr(0, n, (i, a) => i <= 1 ? 1n : MOD - MOD / BigInt(i) * a[998244353 % i] % MOD);
// for (let i = 2; i < n; i++) rgt[i] = rgt[i] * rgt[i - 1] % MOD;
// let nCk = (n, k) => {
//   return gt[n] * rgt[k] * rgt[n - k] % MOD;
// }
// for (let i = dm[l.l]; i <= n + n; i += i & -i) s[i]++; // start from index 1

(async () => {
  await inputPromise;
  let inp = input.split(/\s+/).map(v => +v); r = 0;
  let test = inp[r++];
  while (test--) {
    let n = inp[r++], q = inp[r++];
    let a = Arr(1, n, (i, a) => a[i] = inp[r++], a => a[0] = a[n + 1] = 0)
    let b = Arr(1, n, (i, b) => b[i] = a[i] > a[i - 1] && a[i] > a[i + 1] ? 1 : a[i] < a[i - 1] && a[i] < a[i + 1] ? -1 : 0, b => b[0] = b[n + 1] = 0);
    let res = 0;
    For(1, n, i => { res += a[i] * b[i] });
    console.log(res);
    let update = (i, v) => {
      res -= a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
      a[i] = v;
      b[i] = a[i] > a[i - 1] && a[i] > a[i + 1] ? 1 : a[i] < a[i - 1] && a[i] < a[i + 1] ? -1 : 0
      if (i >= 2) b[i - 1] = a[i - 1] > a[i - 2] && a[i - 1] > a[i] ? 1 : a[i - 1] < a[i - 2] && a[i - 1] < a[i] ? -1 : 0
      if (i <= n - 1) b[i + 1] = a[i + 1] > a[i] && a[i + 1] > a[i + 2] ? 1 : a[i + 1] < a[i] && a[i + 1] < a[i + 2] ? -1 : 0
      res += a[i - 1] * b[i - 1] + a[i] * b[i] + a[i + 1] * b[i + 1];
    }
    For(1, q, i => {
      let li = inp[r++], ri = inp[r++];
      let temp = a[li];
      update(li,a[ri]);
      update(ri,temp);
      console.log(res);
    })
  }
})();


var n=+readline()
var x=readline().split(' ').map(function(q){return +q})
var v=readline().split(' ').map(function(q){return +q})

function max(a,b)
{
    if (a>b){return a;}
    else{return b;}
}

function res(a)
{
    v1=Math.abs(x[0]-a)/v[0]
    for (var i=1;i<n;i++)
    {
        v1=max(v1,Math.abs(x[i]-a)/v[i])
    }
    return v1
}

var l=0
var r=1000000000
for (var i=0;i<=1000;i++)
{
    var m1=(l+l+r)/3;
    var m2=(l+r+r)/3;
    var h1=res(m1)
    var h2=res(m2)
    if (h1>h2)
    {
        l=m1
    }
    else
    {
        r=m2
    }
}

print(res(l))

var n = parseInt(readline());
var minx = Infinity;
var maxx = -1;
var x = readline().split(' ').map(function(x) {
  var n = parseInt(x);
  minx = minx > n ? n : minx;
  maxx = maxx < n ? n : maxx;
  return n;
});
var v = readline().split(' ').map(function(x) {
  return parseInt(x);
});

var calc = function(d) {
  var res = -1;
  for(var i = 0; i < x.length; i += 1) {
    var tmp = Math.abs(x[i] - d) / v[i];
    res = res < tmp ? tmp : res;
  }
  return res;
};

for(var k = 0; k < 64; k += 1) {
  var l = minx + (maxx - minx) / 3;
  var r = minx + (maxx - minx) / 3 * 2;
  if(calc(l) < calc(r)) {
    maxx = r;
  } else {
    minx = l;
  }
}

print(calc(minx));


var n = parseInt(readline())

while(n--) {
    input = readline().split(" ").map(e => parseInt(e))
    m = Math.floor(input[0]/input[1])
    d1 = Math.floor(input[2]/input[1])
    d2 = Math.floor(input[3]/input[1])
    input[2]%input[1] === 0? print(m-d2+d1-1): print(m-d2+d1)
}

var N = +readline();
var f = function(x) {
    return +x;
};

for (var i = 0; i < N; ++i) {
    var line = readline().split(' ').map(f);
    var seen = Math.floor(line[0]/line[1]);
    var hidden = Math.floor(line[3]/line[1]) - Math.floor((line[2]-1)/line[1]);
    print(seen-hidden);
}

var t = +readline();
for (var i=0; i<t; i++){
	var s = readline().split(' ').map(Number);
	var Ld = s[0];
	var v = s[1];
	var l = s[2];
	var r = s[3];
	var ans = Math.floor((l-1)/v) + Math.floor((Ld - Math.ceil((r+1)/v)*v)/v) + 1;
	print (ans);
}

var t = Number(readline());

for (var i = 0; i<t ; ++i){
    var arr = readline().split(" ");
    var L = arr[0], u = arr[1], l = arr[2], r =arr[3];
    print(Math.floor(L/u) - Math.floor(r/u)+ Math.floor((l-1)/u));
}

var t = Number(readline());

for (var i = 0; i<t ; ++i){
    var arr = readline().split(" ");
    var L = arr[0], u = arr[1], l = arr[2], r =arr[3];
    print(parseInt(L/u) - parseInt(r/u)+ parseInt((l-1)/u));
}

var N = +readline()

for (var i = 0; i < N; ++i) {
    var line = readline().split(' ').map(parseInt);
    var hidden = Math.floor(((line[3] - line[2])/line[1]));
    if(line[3]%line[2] === 0) {
        hidden++
    }
    if(line[4]%line[2] === 0) {
        hidden++
    }

    print(Math.floor((line[0]/line[1]) - hidden));
}

var N = +readline()
var f = function(x) {
    return +x;
}

for (var i = 0; i < N; ++i) {
    var line = readline().split(' ').map(f);
    var hidden = Math.floor(((line[3] - line[2])/line[1]));
    if(line[3]%line[2] === 0) {
        hidden++
    }
    if(line[4]%line[2] === 0) {
        hidden++
    }

    print(Math.floor((line[0]/line[1]) - hidden));
}

var N = +readline();
var f = function(x) {
    return +x;
};

for (var i = 0; i < N; ++i) {
    var line = readline().split(' ').map(f);
    var seen = Math.floor(line[0]/line[1]);
    var hidden = Math.floor(((line[3] - line[2])/line[1]));
    if(line[2]%line[1] === 0 || line[3]%line[1] === 0) {
        hidden++;
    }

    print(Math.floor(seen - hidden));
}


data = '';

process.stdin.on('data', c => data += c);
process.stdin.on('end' , () => {

  let [_, ...input]= data
      .trim()
      .split(/\n/)
      .map(el => el.trim())

input = input
      .map(el => el.split(' '))
      const output = [];

    for (let i = 0; i < input.length; i += 2) {
    const n = BigInt(input[i][0].trim());
    const h = BigInt(input[i][1].trim());
      const arr = input[i+1].map(el => BigInt(el.trim()));

      let left = 0n;
    let right = h;

    while (left <= right) {
      let mid = ~~((left + right) / 2n);
      if (calculate_damage(arr, n, mid) >= h) {
        right = mid - 1n;
      } else {
        left = mid + 1n;
      }
    }

    output[i] = left;

    };
    console.log(output.join('\n'))

function calculate_damage(gagarini, n, k) {
  let total_damage = 0n;

  for (let i = 1; i < n; i++) {
    if(BigInt(gagarini[i] - gagarini[i - 1]) < k){
      total_damage += BigInt(gagarini[i] - gagarini[i - 1])
    }else{
      total_damage += k;
    }
    //total_damage += Math.min(BigInt(gagarini[i] - gagarini[i - 1]), k);
  }

  total_damage += k;

  return total_damage;
}

})

var dataitr;
var stdin_input = "";
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { dataitr = stdin_input.split('\n').values(); main(); });

const rl = () => dataitr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));
const rnba = () => ra().map(x => BigInt(x));

function can (a, h, k) {
	for (let i = 0; i < a.length - 1; i++) {
		if (k < BigInt(a[i+1] - a[i]))
			h -= k;
		else
			h -= BigInt(a[i+1] - a[i]);
	}
	h -= k;
	return h <= 0;
}

function main () {
	let T = rn();
	while (T--) {
		let [n, h] = rnba();
		n = Number(n);
		let a = rna();

		let l = 0n, r = BigInt(1e18);
		while (l < r) {
			const mid = (l+r)/2n;
			if (can(a, h, mid)) {
				r = mid;
			} else {
				l = mid + 1n;
			}
		}
		const ans = l;

		console.log(ans.toString());
	}
}

const readline = require('readline')

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
})
const lines = []
rl.on('line', (input) => {
    lines.push(input);
})
rl.on('close', () => {
// (function() {
    // const lines = require('fs').readFileSync('test.in', 'utf8').split('\n')
    let l = 0;
    let t = +lines[l++]
    const output = []
    for (let i = 0; i < t; i++) {
        const [n, h] = lines[l++].trim().split(' ').map(BigInt)
        const arr = lines[l++].trim().split(' ').map(BigInt)
        output[i] = solve(n, h, arr)
    }
    console.log(output.join('\n'))
// })()
})

function solve(n, h, arr) {
    const cal = x => {
        let sum = 0n
        let prev = 0n
        arr.forEach(t => {
            const start = prev < t ? t : prev
            const last = t + x - 1n
            if (last >= start) sum += last - start + 1n
            prev = last + 1n
        })
        // console.log(x, sum)
        return sum
    }
    const k = binarySearch(1n, h, x => cal(x) <= h)
    return cal(k) < h ? k + 1n : k
}
function binarySearch(l, r, fn) {
    while (l <= r) {
        // const m = Math.floor((l + r) / 2)
        const m = (l + r) / 2n
        if (fn(m)) {
            l = m + 1n
        } else {
            r = m - 1n
        }
    }
    return r
}

var dataitr;
var stdin_input = "";
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { dataitr = stdin_input.split('\n').values(); main(); });

const rl = () => dataitr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

const INF = 1e18+1;

function main () {
	let T = rn();
	while (T--) {
		let [n, h] = rna();
		let a = rna();

		let d = new Map();
		d.set(INF, 1);
		for (let i = 1; i < n; i++) {
			const df = a[i] - a[i-1];
			d.set(df, d.has(df) ? d.get(df) + 1 : 1);
		}
		d = new Map([...d.entries()].sort((a, b) => a[0] - b[0]));

		let ans = 0 ;
		const itr = d.entries();
		while (h > 0) {
			const [df, cnt] = itr.next().value;

			const needs = Math.ceil(h / n);
			const dflft = df - ans;
			const using = Math.min(dflft, needs);
			h -= using*n;
			n -= cnt;
			ans += using;
		}

		console.log(ans);
	}
}

var dataitr;
var stdin_input = "";
process.stdin.resume();
process.stdin.setEncoding("ascii");
process.stdin.on("data", function (input) { stdin_input += input; });
process.stdin.on("end", function () { dataitr = stdin_input.split('\n').values(); main(); });

const rl = () => dataitr.next().value.trim();
const rn = () => Number(rl());
const ra = () => rl().split(' ');
const rna = () => ra().map(x => Number(x));

const INF = 1e18+1;

function main () {
	let T = rn();
	while (T--) {
		let [n, h] = rna();
		let a = rna();

		let d = new Map();
		d.set(INF, 1);
		for (let i = 1; i < n; i++) {
			const df = a[i] - a[i-1];
			d.set(df, d.has(df) ? d.get(df) + 1 : 1);
		}
		d = new Map([...d.entries()].sort((a, b) => a[0] - b[0]));

		let ans = 0 ;
		const itr = d.entries();
		while (n) {
			let [df, cnt] = itr.next().value;
			const needs = Math.ceil(h / n);
			df -= ans;
			if (df >= needs) {
				ans += needs;
				n = 0;
			} else {
				ans += df;
				h -= df*n;
				n -= cnt;
			}
		}

		console.log(ans);
	}
}