A sequence $$$(b_1, b_2, \ldots, b_k)$$$ is called strange, if the absolute difference between any pair of its elements is greater than or equal to the maximum element in the sequence. Formally speaking, it's strange if for every pair $$$(i, j)$$$ with $$$1 \le i<j \le k$$$, we have $$$|a_i-a_j|\geq MAX$$$, where $$$MAX$$$ is the largest element of the sequence. In particular, any sequence of length at most $$$1$$$ is strange.For example, the sequences $$$(-2021, -1, -1, -1)$$$ and $$$(-1, 0, 1)$$$ are strange, but $$$(3, 0, 1)$$$ is not, because $$$|0 - 1| < 3$$$.Sifid has an array $$$a$$$ of $$$n$$$ integers. Sifid likes everything big, so among all the strange subsequences of $$$a$$$, he wants to find the length of the longest one. Can you help him?A sequence $$$c$$$ is a subsequence of an array $$$d$$$ if $$$c$$$ can be obtained from $$$d$$$ by deletion of several (possibly, zero or all) elements.

The first line contains an integer $$$t$$$ $$$(1\le t\le 10^4)$$$ — the number of test cases. The description of the test cases follows. The first line of each test case contains an integer $$$n$$$ $$$(1\le n\le 10^5)$$$ — the length of the array $$$a$$$. The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ $$$(-10^9\le a_i \le 10^9)$$$ — the elements of the array $$$a$$$. It is guaranteed that the sum of $$$n$$$ over all test cases doesn't exceed $$$10^5$$$.

For each test case output a single integer — the length of the longest strange subsequence of $$$a$$$.

NoteIn the first test case, one of the longest strange subsequences is $$$(a_1, a_2, a_3, a_4)$$$In the second test case, one of the longest strange subsequences is $$$(a_1, a_3, a_4, a_5, a_7)$$$.In the third test case, one of the longest strange subsequences is $$$(a_1, a_3, a_4, a_5)$$$.In the fourth test case, one of the longest strange subsequences is $$$(a_2)$$$.In the fifth test case, one of the longest strange subsequences is $$$(a_1, a_2, a_4)$$$.

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ncnt = 0;
    for (let i = 0; i < n; i++) if (arr[i] <= 0) ncnt++;
    arr.sort((a, b) => b - a);
    let min = Infinity;
    for (let i = 0; i < n; i++) if (arr[i] > 0) min = Math.min(min, arr[i]);
    if (min === Infinity) console.log(ncnt);
    else {
      let flag = true;
      for (let i = 1; i < n; i++)
        if (arr[i] <= 0) flag &= arr[i - 1] - arr[i] >= min;
      if (flag) console.log(ncnt + 1);
      else console.log(ncnt);
    }
  }
};
solve();

const nextString = (function() {
  const listeners = [], strings = [], ps = process.stdin
  let last = ''
  ps.setEncoding('utf8')
  ps.on('readable', () => {
    let chunk
    while ((chunk = ps.read()) !== null) {
      chunk = (last + chunk).split(/\r\n|\r|\n/)
      last = chunk[chunk.length - 1]
      for (let i = 0; i < chunk.length - 1; ++i) {
        if (chunk[i].length > 0) {
          if (listeners.length > 0) {
            listeners.shift(1)(chunk[i])
          }
          else {
            strings.push(chunk[i])
          }
        }
      }
    }
  })
  const fn = resolve => {
    if (strings.length > 0) {
      resolve(strings.shift(1))
    }
    else {
      listeners.push(resolve)
    }
  }
  return () => new Promise(fn)
})()

async function proc() {
  let n = +await nextString();
  let mas = (await nextString()).split(' ').map(x => +x).sort((a, b) => a - b)
  let qq
  for (qq = 0; qq < n && mas[qq] <= 0; ++qq) {}
  if (qq === 0) {
    return 1
  }
  if (qq === 1) {
    return n === 1 ? 1 : 2
  }
  if (qq === n) {
    return qq
  }
  let min = mas[1] - mas[0]
  for (let i = 2; i <= qq; ++i) {
    min = Math.min(min, mas[i] - mas[i - 1])
  }
  if (mas[qq] <= min) {
    return qq + 1
  }
  return qq

}

async function main() {
  let t = +await nextString()
  for (let i = 0; i < t; ++i) {
    console.log(await proc())
  }
}

main()

//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] = BigInt(next());
		}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 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 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 list = nextIntArray(N);
		list.sort(function(a,b){
			return a - b;
		});
		var output = 1;
		var min = Math.pow(10, 15);
		var isZero = false;
		//myerr(list);
		for(var i = 1; i < N; i++){
			if(list[i] < 0){
				min = Math.min(min, Math.abs(list[i - 1] - list[i]));
				output++;
			}else{
				if(list[i] <= Math.min(min, Math.abs(list[i - 1] - list[i]))){
					output++;
					min = Math.min(min, Math.abs(list[i - 1] - list[i]));

				}else{
					break;
				}
			}
		}
		myout(output);
	}
}

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

let lines = [];
let lineIdx = 0;

rl.on("line", line => {
    lines.push(line);
});

rl.on("close", () => {
    main();
});

function readLine() {
    return lines[lineIdx++];
}

function main() {
    let t = +readLine();
    while (t--) {
        let n = +readLine();
        let a = readLine().split(' ').map(x => +x).sort((x, y) => x - y);
        let diff = Infinity;
        let hasPos = false;
        let ret = 0;
        for (let i=0; i<n; i++) {
            if (a[i] <= 0) {
                ret++;
                if (i > 0)
                    diff = Math.min(diff, a[i] - a[i-1]);
            } else if (diff >= a[i] && !hasPos) {
                ret++;
                hasPos = true;
            }
        }
        console.log(ret);
    }
}

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var os = require('os');

const stdin = process.stdin;
const stdout = process.stdout;
class InputAndOutput {
    constructor() {
        this.lineIndex = 0;
        this.lines = [];
    }
    dried() {
        return this.lineIndex >= this.lines.length;
    }
    readLine() {
        const line = this.lines[this.lineIndex];
        this.lineIndex += 1;
        return line;
    }
    print(content) {
        stdout.write(content);
    }
    async init() {
        const lines = await this.readLines();
        this.lines = lines;
    }
    readLines() {
        const buffers = [];
        return new Promise(resolve => {
            stdin.on('data', (buffer) => buffers.push(buffer));
            stdin.on('end', function () {
                const inputs = buffers.join('');
                const lines = inputs.split(os.EOL);
                resolve(lines);
            });
        });
    }
}
async function __main__(handle) {
    const io = new InputAndOutput();
    await io.init();
    handle(io);
}

function solution(nums) {
    nums.sort((x, y) => x - y);
    if (nums[0] > 0)
        return 1;
    if (nums[nums.length - 1] <= 0)
        return nums.length;
    let i = 1;
    let minimumPositiveValue = -1;
    let minimumDelta = 2e9 + 7;
    for (; i < nums.length; ++i) {
        if (nums[i] > 0) {
            minimumPositiveValue = nums[i];
            break;
        }
        minimumDelta = Math.min(minimumDelta, nums[i] - nums[i - 1]);
    }
    if (minimumDelta >= minimumPositiveValue)
        return i + 1;
    return i;
}
__main__(function (io) {
    const T = Number(io.readLine());
    for (let kase = 1; kase <= T; ++kase) {
        const countOfNums = Number(io.readLine());
        const nums = io
            .readLine()
            .trim()
            .split(/\s+/g)
            .map(x => Number(x))
            .slice(0, countOfNums);
        const answer = solution(nums);
        io.print('' + answer + '\n');
    }
});

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ncnt = 0;
    for (let i = 0; i < n; i++) if (arr[i] <= 0) ncnt++;
    arr.sort((a, b) => b - a);
    let min = Infinity;
    for (let i = 0; i < n; i++) if (arr[i] > 0) min = Math.min(min, arr[i]);
    if (min === Infinity) console.log(ncnt);
    else {
      let flag = true;
      for (let i = 1; i < n - 1; i++)
        if (arr[i] <= 0) flag &= arr[i - 1] - arr[i] >= min;
      if (flag) console.log(ncnt + 1);
      else console.log(ncnt);
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    p.sort((a, b) => a - b);
    if (ni.length === 0) {
      let cnt = 0;
      for (let i = 0; i < p.length; i++) {
        if (p[i] === 0) cnt++;
        else {
          if(cnt>1) break;
          cnt++;
          break;
        }
      }
      console.log(cnt);
    } else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      let res = [];
      if (ni.length === 1) {
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else {
            if (res.length > 1) break;
            res.push(p[i]);
            break;
          }
        }
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else if (p[i] <= d) {
            res.push(p[i]);
            break;
          } else break;
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    p.sort((a, b) => a - b);
    if (ni.length === 0) {
      let cnt = 0;
      for(let i=0;i<p.length;i++){
        if(p[i]===0) cnt++;
        else{
          cnt++;
          break;
        }
      }
      console.log(cnt);
    } else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      let res = [];
      if (ni.length === 1) {
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else {
            if (res.length > 1) break;
            res.push(p[i]);
            break;
          }
        }
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else if (p[i] <= d) {
            res.push(p[i]);
            break;
          } else break;
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    p.sort((a, b) => a - b);
    if (ni.length === 0) {
      if(p[0]===0) console.log(2);
      else console.log(1);
    }
    else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      let res = [];
      if (ni.length === 1) {
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else {
            if (res.length > 1) break;
            res.push(p[i]);
            break;
          }
        }
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else if (p[i] <= d) {
            res.push(p[i]);
            break;
          } else break;
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    if (ni.length === 0) console.log(1);
    else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      p.sort((a, b) => a - b);
      let res = [];
      if (ni.length === 1) {
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else {
            if (res.length > 1) break;
            res.push(p[i]);
            break;
          }
        }
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else if (p[i] <= d) {
            res.push(p[i]);
            break;
          } else break;
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    if (ni.length === 0) console.log(1);
    else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      p.sort((a, b) => a - b);
      let res = [];
      if (ni.length === 1) {
        res.push(p[0]);
        for (let i = 1; i < p.length; i++)
          if (res[res.length - 1] === p[i]) res.push(p[i]);
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (p[i] === 0) res.push(p[i]);
          else if (p[i] <= d) {
            res.push(p[i]);
            break;
          } else break;
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    if (ni.length === 0) console.log(1);
    else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      p.sort((a, b) => a - b);
      let res = [];
      if (ni.length === 1) {
        res.push(p[0]);
        for (let i = 1; i < p.length; i++)
          if (res[res.length - 1] === p[i]) res.push(p[i]);
        console.log(ni.length + res.length);
      } else {
        let d = Infinity;
        for (let i = 0; i < ni.length - 1; i++)
          d = Math.min(d, Math.abs(ni[i] - ni[i + 1]));
        for (let i = 0; i < p.length; i++) {
          if (i === 0) {
            if (p[i] <= d) res.push(p[i]);
            else break;
          } else {
            if (p[i] <= d) {
              if (Math.abs(res[res.length - 1] - p[i]) === p[i]) res.push(p[i]);
              else break;
            } else break;
          }
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

"use strict";
const fs = require("fs");
//let filename = "0.txt";
let filename = 0;
const input = fs.readFileSync(filename, "utf8").trim().split("\n");
let line = 0;
function readline() {
  return input[line++];
}

const solve = () => {
  let t = parseInt(readline());
  while (t--) {
    let n = parseInt(readline());
    let arr = readline()
      .trim()
      .split(" ")
      .map((cur) => parseInt(cur));
    let ni = [],
      p = [];
    for (let i = 0; i < n; i++) {
      if (arr[i] < 0) ni.push(arr[i]);
      else p.push(arr[i]);
    }
    if (ni.length === 0) console.log(1);
    else if (p.length === 0) console.log(ni.length);
    else {
      ni.sort((a, b) => b - a);
      p.sort((a, b) => a - b);
      let res = [];
      if (ni.length === 1) {
        res.push(p[0]);
        for (let i = 1; i < p.length; i++)
          if (res[res.length - 1] === p[i]) res.push(p[i]);
        console.log(ni.length + res.length);
      } else {
        let d = Math.abs(ni[0] - ni[1]);
        for (let i = 0; i < p.length; i++) {
          if (i === 0) {
            if (p[i] <= d) res.push(p[i]);
            else break;
          } else {
            if (p[i] <= d) {
              if (Math.abs(res[res.length - 1] - p[i]) === p[i]) res.push(p[i]);
              else break;
            } else break;
          }
        }
        console.log(ni.length + res.length);
      }
    }
  }
};
solve();

const nextString = (function() {
  const listeners = [], strings = [], ps = process.stdin
  let last = ''
  ps.setEncoding('utf8')
  ps.on('readable', () => {
    let chunk
    while ((chunk = ps.read()) !== null) {
      chunk = (last + chunk).split(/\r\n|\r|\n/)
      last = chunk[chunk.length - 1]
      for (let i = 0; i < chunk.length - 1; ++i) {
        if (chunk[i].length > 0) {
          if (listeners.length > 0) {
            listeners.shift(1)(chunk[i])
          }
          else {
            strings.push(chunk[i])
          }
        }
      }
    }
  })
  const fn = resolve => {
    if (strings.length > 0) {
      resolve(strings.shift(1))
    }
    else {
      listeners.push(resolve)
    }
  }
  return () => new Promise(fn)
})()

async function proc() {
  let n = +await nextString();
  let mas = (await nextString()).split(' ').map(x => +x).sort((a, b) => a - b)
  let qq
  for (qq = 0; qq < n && mas[qq <= 0]; ++qq) {}
  if (qq === 0) {
    return 1
  }
  if (qq === 1) {
    return n === 1 ? 1 : 2
  }
  if (qq === n) {
    return qq
  }
  let min = mas[1] - mas[0]
  for (let i = 2; i <= qq; ++i) {
    min = Math.min(min, mas[i] - mas[i - 1])
  }
  if (mas[qq] <= min) {
    return qq + 1
  }
  return qq

}

async function main() {
  let t = +await nextString()
  for (let i = 0; i < t; ++i) {
    console.log(await proc())
  }
}

main()

const nextString = (function() {
  const listeners = [], strings = [], ps = process.stdin
  let last = ''
  ps.setEncoding('utf8')
  ps.on('readable', () => {
    let chunk
    while ((chunk = ps.read()) !== null) {
      chunk = (last + chunk).split(/\r\n|\r|\n/)
      last = chunk[chunk.length - 1]
      for (let i = 0; i < chunk.length - 1; ++i) {
        if (chunk[i].length > 0) {
          if (listeners.length > 0) {
            listeners.shift(1)(chunk[i])
          }
          else {
            strings.push(chunk[i])
          }
        }
      }
    }
  })
  const fn = resolve => {
    if (strings.length > 0) {
      resolve(strings.shift(1))
    }
    else {
      listeners.push(resolve)
    }
  }
  return () => new Promise(fn)
})()

async function proc() {
  let n = +await nextString();
  let mas = (await nextString()).split(' ').map(x => +x).sort((a, b) => a - b)
  let qq = mas.findIndex(x => x === 0)
  if (qq === -1) {
    for (qq = 0; qq < n && mas[qq < 0]; ++qq) {}
  }
  if (qq === 0) {
    return 1
  }
  if (qq === 1) {
    return n === 1 ? 1 : 2
  }
  if (qq === n) {
    return qq
  }
  let min = mas[1] - mas[0]
  for (let i = 2; i <= qq; ++i) {
    min = Math.min(min, mas[i] - mas[i - 1])
  }
  if (mas[qq] <= min) {
    return qq + 1
  }
  return qq

}

async function main() {
  let t = +await nextString()
  for (let i = 0; i < t; ++i) {
    console.log(await proc())
  }
}

main()

//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] = BigInt(next());
		}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 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 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 list = nextIntArray(N);
		list.sort(function(a,b){
			return a - b;
		});
		var output = 1;
		var min = Math.pow(10, 15);
		var isZero = false;
		//myerr(list);
		for(var i = 1; i < N; i++){
			if(list[i] < 0){
				output++;
			}else{
				if(list[i] <= Math.min(min, Math.abs(list[i - 1] - list[i]))){
					output++;
					min = Math.min(min, Math.abs(list[i - 1] - list[i]));

				}else{
					break;
				}
			}
		}
		myout(output);
	}
}

//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] = BigInt(next());
		}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 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 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 list = nextIntArray(N);
		list.sort(function(a,b){
			return a - b;
		});
		var output = 0;
		var isZero = false;
		for(var i = 0; i < N; i++){
			if(list[i] < 0){
				output++;
				max = list[i];
			}else if(list[i] == 0 && !isZero){
				isZero = true;
				output++;
			}else{
				output++;
				break;
			}
		}
		myout(output);
	}
}


You are given an array $$$a$$$ of length $$$n$$$, which initially is a permutation of numbers from $$$1$$$ to $$$n$$$. In one operation, you can choose an index $$$i$$$ ($$$1 \leq i < n$$$) such that $$$a_i < a_{i + 1}$$$, and remove either $$$a_i$$$ or $$$a_{i + 1}$$$ from the array (after the removal, the remaining parts are concatenated). For example, if you have the array $$$[1, 3, 2]$$$, you can choose $$$i = 1$$$ (since $$$a_1 = 1 < a_2 = 3$$$), then either remove $$$a_1$$$ which gives the new array $$$[3, 2]$$$, or remove $$$a_2$$$ which gives the new array $$$[1, 2]$$$.Is it possible to make the length of this array equal to $$$1$$$ with these operations?

The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 2 \cdot 10^4$$$)  — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $$$n$$$ ($$$2 \leq n \leq 3 \cdot 10^5$$$)  — the length of the array. The second line of each test case contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, ..., $$$a_n$$$ ($$$1 \leq a_i \leq n$$$, $$$a_i$$$ are pairwise distinct) — elements of the array. It is guaranteed that the sum of $$$n$$$ over all test cases doesn't exceed $$$3 \cdot 10^5$$$.

For each test case, output on a single line the word "YES" if it is possible to reduce the array to a single element using the aforementioned operation, or "NO" if it is impossible to do so.

NoteFor the first two test cases and the fourth test case, we can operate as follow (the bolded elements are the pair chosen for that operation):$$$[\text{1}, \textbf{2}, \textbf{3}] \rightarrow [\textbf{1}, \textbf{2}] \rightarrow [\text{1}]$$$$$$[\text{3}, \textbf{1}, \textbf{2}, \text{4}] \rightarrow [\text{3}, \textbf{1}, \textbf{4}] \rightarrow [\textbf{3}, \textbf{4}] \rightarrow [\text{4}]$$$$$$[\textbf{2}, \textbf{4}, \text{6}, \text{1}, \text{3}, \text{5}] \rightarrow [\textbf{4}, \textbf{6}, \text{1}, \text{3}, \text{5}] \rightarrow [\text{4}, \text{1}, \textbf{3}, \textbf{5}] \rightarrow [\text{4}, \textbf{1}, \textbf{5}] \rightarrow [\textbf{4}, \textbf{5}] \rightarrow [\text{4}]$$$

function solve() {
   var n = Number(read());
   var a = read().split(' ').map(Number);
   write(a[0] < a[n - 1] ? 'YES' : 'NO');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ').map(Number);
   var b = a.slice();
   for (var i = n - 2; i >= 0; i--) {
      b[i] = Math.max(b[i], b[i + 1]);
   }
   var cur = -1;
   var prev = 0;
   for (var i = 0; i < n; i++) {
      if (cur < prev && a[i] > prev) {
         cur = a[i];
      }
      if (a[i] === b[i]) {
         write(cur);
         if (cur < prev) {
            write('NO');
            return;
         }
         prev = cur;
         cur = -1;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ');
   var b = [0];
   for (var i = 0; i < n; i++) {
      a[i] = Number(a[i]);
      b.push(0);
   }
   var prev = 0;
   var cur = n + 1;
   var wait = n;
   var found = false;
   var nextWaitIndex = n;
   for (var i = 0; i < n; i++) {
      b[a[i]] = 1;
      if (a[i] > prev && !found) {
         cur = a[i];
         found = true;
      }
      if (a[i] === wait) {
         if (!found) {
            write('NO');
            return;
         }
         prev = cur;
         found = false;
         while(b[nextWaitIndex]) {
            nextWaitIndex--;
         }
         wait = nextWaitIndex;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ');
   var b = [0];
   for (var i = 0; i < n; i++) {
      a[i] = Number(a[i]);
      b.push(0);
   }
   var prev = 0;
   var cur = n + 1;
   var wait = n;
   var found = false;
   var nextWaitIndex = n;
   for (var i = 0; i < n; i++) {
      b[a[i]] = 1;
      if (!found) {
         cur = a[i];
         found = true;
      } else if (cur < prev && a[i] > cur) {
         cur = a[i];
      }
      if (a[i] === wait) {
         if (cur < prev) {
            write('NO');
            return;
         }
         prev = cur;
         found = false;
         while(b[nextWaitIndex]) {
            nextWaitIndex--;
         }
         wait = nextWaitIndex;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

var N = 300000;
var B = [];
for (var I = 0; I < N; I++) {
   B.push(I + 1);
}

function solve() {
   var n = Number(read());
   var a = read().split(' ').map(Number);
   var prev = 0;
   var cur = n + 1;
   var wait = n;
   var nextWaitIndex = n - 2;
   for (var i = 0; i < n; i++) {
      if (a[i] === B[nextWaitIndex]) {
         nextWaitIndex--;
      }
      if (a[i] > prev && a[i] < cur) {
         cur = a[i];
      }
      if (a[i] === wait) {
         if (cur === n + 1) {
            write('NO');
            return;
         }
         prev = cur;
         cur = n + 1;
         wait = B[nextWaitIndex--];
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ');
   var b = [0];
   for (var i = 0; i < n; i++) {
      a[i] = Number(a[i]);
      b.push(0);
   }
   var prev = 0;
   var cur = n + 1;
   var wait = n;
   var nextWaitIndex = n - 1;
   for (var i = 0; i < n; i++) {
      b[a[i]] = 1;
      if (a[i] > prev && a[i] < cur) {
         cur = a[i];
      }
      if (a[i] === wait) {
         if (cur === n + 1) {
            write('NO');
            return;
         }
         prev = cur;
         cur = n + 1;
         while(b[nextWaitIndex]) {
            nextWaitIndex--;
         }
         wait = nextWaitIndex--;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ').map(Number);
   var b = a.slice();
   for (var i = n - 2; i >= 0; i--) {
      b[i] = Math.max(b[i], b[i + 1]);
   }
   var cur = -1;
   var prev = 0;
   for (var i = 0; i < n; i++) {
      if (cur < prev && a[i] > cur) {
         cur = a[i];
      }
      if (a[i] === b[i]) {
         if (cur < prev) {
            write('NO');
            return;
         }
         prev = cur;
         cur = -1;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ');
   var b = [0];
   for (var i = 0; i < n; i++) {
      a[i] = Number(a[i]);
      b.push(0);
   }
   var prev = 0;
   var cur = n + 1;
   var wait = n;
   var found = false;
   var nextWaitIndex = n;
   for (var i = 0; i < n; i++) {
      b[a[i]] = 1;
      if (!found) {
         cur = a[i];
         found = true;
      } else if (cur < prev && cur === a[i - 1] && a[i] > cur) {
         cur = a[i];
      }
      if (a[i] === wait) {
         if (cur < prev) {
            write('NO');
            return;
         }
         prev = cur;
         found = false;
         while(b[nextWaitIndex]) {
            nextWaitIndex--;
         }
         wait = nextWaitIndex;
      }
   }
   write('YES');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}

function solve() {
   var n = Number(read());
   var a = read().split(' ').map(Number);
   var cur = a[0];
   var found = true;
   for (var i = 1; i < n; i++) {
      if (a[i - 1] < a[i]) {
         if (!found && a[i] > cur) {
            cur = a[i];
            found = true;
         }
      } else {
         if (!found) {
            write('NO');
            return;
         }
         found = false;
      }
   }
   write(found ? 'YES' : 'NO');
}

function init() {
   var T;
   T = 1;
   T = Number(read());
   for (var t = 0; t < T; t++) {
      solve();
   }
}

var isNode = typeof console !== 'undefined';
var MEMORY = [];
var MEMORY_INDEX = 0;
if (isNode) {
   var fs = require('fs');
   var path = require('path');

   var inTextName;
   var outTextName;
   if (process.argv.length === 5) {
      inTextName = process.argv[3];
      outTextName = process.argv[4];
   }

   if (inTextName) {
      fs.readFile(path.join(__dirname, inTextName), 'utf8', (err, data) => {
         MEMORY = data.split('\r\n');
         init();
      });
   } else {
      var RL = require('readline').createInterface({
         input : process.stdin,
         output : process.stdout
      });

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

      RL.on('close', init);
   }
} else {
   init();
}

function write(value) {
   isNode ? console.log(value) : print(value);
}
function read() {
   return isNode ? MEMORY[MEMORY_INDEX++] : readline();
}


A robot cleaner is placed on the floor of a rectangle room, surrounded by walls. The floor consists of $$$n$$$ rows and $$$m$$$ columns. The rows of the floor are numbered from $$$1$$$ to $$$n$$$ from top to bottom, and columns of the floor are numbered from $$$1$$$ to $$$m$$$ from left to right. The cell on the intersection of the $$$r$$$-th row and the $$$c$$$-th column is denoted as $$$(r,c)$$$. The initial position of the robot is $$$(r_b, c_b)$$$.In one second, the robot moves by $$$dr$$$ rows and $$$dc$$$ columns, that is, after one second, the robot moves from the cell $$$(r, c)$$$ to $$$(r + dr, c + dc)$$$. Initially $$$dr = 1$$$, $$$dc = 1$$$. If there is a vertical wall (the left or the right walls) in the movement direction, $$$dc$$$ is reflected before the movement, so the new value of $$$dc$$$ is $$$-dc$$$. And if there is a horizontal wall (the upper or lower walls), $$$dr$$$ is reflected before the movement, so the new value of $$$dr$$$ is $$$-dr$$$.Each second (including the moment before the robot starts moving), the robot cleans every cell lying in the same row or the same column as its position. There is only one dirty cell at $$$(r_d, c_d)$$$. The job of the robot is to clean that dirty cell.  Illustration for the first example. The blue arc is the robot. The red star is the target dirty cell. Each second the robot cleans a row and a column, denoted by yellow stripes. Given the floor size $$$n$$$ and $$$m$$$, the robot's initial position $$$(r_b, c_b)$$$ and the dirty cell's position $$$(r_d, c_d)$$$, find the time for the robot to do its job.

Each test contains multiple test cases. The first line contains the number of test cases $$$t$$$ ($$$1 \le t \le 10^4$$$). Description of the test cases follows. A test case consists of only one line, containing six integers $$$n$$$, $$$m$$$, $$$r_b$$$, $$$c_b$$$, $$$r_d$$$, and $$$c_d$$$ ($$$1 \le n, m \le 100$$$, $$$1 \le r_b, r_d \le n$$$, $$$1 \le c_b, c_d \le m$$$) — the sizes of the room, the initial position of the robot and the position of the dirt cell.

For each test case, print an integer — the time for the robot to clean the dirty cell. We can show that the robot always cleans the dirty cell eventually.

NoteIn the first example, the floor has the size of $$$10\times 10$$$. The initial position of the robot is $$$(6, 1)$$$ and the position of the dirty cell is $$$(2, 8)$$$. See the illustration of this example in the problem statement.In the second example, the floor is the same, but the initial position of the robot is now $$$(9, 9)$$$, and the position of the dirty cell is $$$(1, 1)$$$. In this example, the robot went straight to the dirty cell and clean it.   In the third example, the floor has the size $$$9 \times 8$$$. The initial position of the robot is $$$(5, 6)$$$, and the position of the dirty cell is $$$(2, 1)$$$.   In the fourth example, the floor has the size $$$6 \times 9$$$. The initial position of the robot is $$$(2, 2)$$$ and the position of the dirty cell is $$$(5, 8)$$$.   In the last example, the robot was already standing in the same column as the dirty cell, so it can clean the cell right away.

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 l = lines[i].split(' ').map(Number);
        var n = l[0], m = l[1], rb = l[2], cb = l[3], rd = l[4], cd = l[5];
        var ans = 0;
        var a = 1;
        var b = 1;
        while(true){
            if(rb == rd || cb == cd){
                break;
            }
            if(rb + a > n || rb + a < 1){
                a *= -1;
            }
            if(cb + b > m || cb + b < 1){
                b *= -1;
            }
            rb += a;
            cb += b;
            ans++;
        }
        console.log(ans);
    }
});

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 n = k[0], m = k[1], rb = k[2], cb = k[3], rd = k[4], cd = k[5];
        var ans = 0;
        var dr = 1, dc = 1;
        while(true){
            if(rb == rd || cb == cd){
                break;
            }
            if(rb + dr > n || rb + dr < 1){
                dr *= -1;
            }
            if(cb  + dc > m || cb + dc < 1){
                dc *= -1;
            }
            rb += dr;
            cb += dc;
            ans++;
        }
        console.log(ans);
	}
});

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

function _main() {

	_inputLines = _inputData.trim().split('\n').map((string) => {
		return string.trim();
	});;

	let t = inputReader.readNumber();

	function solve(){
	    let  n, m, rb, cb, rd, cd ;
	    [ n, m, rb, cb, rd, cd ] = inputReader.readNumberArray();
	    let dirx = 1, diry = 1;
	    let ans = 0;
	    while(rb != rd && cb != cd){
	        if(rb + dirx > n || rb + dirx < 1) dirx*= -1;
	        if(cb + diry > m || cb + diry < 1) diry*= -1;
	        rb+=dirx;
	        cb+=diry;
	        ans+=1;
	    }
	    console.log(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 readNumberArray(){
		return _inputLines[_lineNumber++].split(' ').map(val => Number(val));
	}

	return {
		readNumber,
		readNumberArray,
	}
}

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 = 1e9;

function main () {
	let T = rn();
	while (T--) {
		const  [n, m, rb, cb, rd, cd] = rna();

		let ans = INF;
		if (rd >= rb)
			ans = Math.min(ans, rd - rb);
		else
			ans = Math.min(ans, n - rb + n - rd);

		if (cd >= cb)
			ans = Math.min(ans, cd - cb);
		else
			ans = Math.min(ans, m - cb + m - cd);

		console.log(ans);
	}
}

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

const getLine = (function () {
    const getLineGen = (async function* () {
        for await (const line of rl) {
            yield line;
        }
    })();
    return async () => {
        let next;
        do {
            next = (await getLineGen.next());
        } while (!next.done && next.value === '');
        return next.value;
    };
})();

let solve = async () => {
    const nsc = parseInt(await getLine());
    for(let sc = 0; sc < nsc; sc++) {
       let [n,m,rb,rc,rd,cd] = (await getLine()).split(' ').map(num => parseInt(num));
       let res = 0;
       let dr, dc;
       dr = 1; dc = 1;
       while (rb !== rd && rc !== cd) {
           if (rb + dr > n || rb + dr < 1)
               dr = dr * -1;
           if (rc + dc > m || rc + dc < 1)
               dc = dc * -1;
           rb += dr;
           rc += dc;
           res += 1;
       }
       console.log(res);
    }
}

solve();

var t = parseInt(readline());

  function solve() {
    var inp = readline()
      .split(" ")
      .map((data) => +data);
    var n = inp[0],
      m = inp[1],
      rb = inp[2],
      cb = inp[3],
      rd = inp[4],
      cd = inp[5];
    var ans = Infinity;
    if (rd >= rb) {
      ans = Math.min(ans, rd - rb);
    } else {
      ans = Math.min(ans, 2 * (n - rb) + rb - rd);
    }
    if (cd >= cb) {
      ans = Math.min(ans, cd - cb);
    } else {
      ans = Math.min(ans, 2 * (m - cb) + cb - cd);
    }
    return ans;
  }

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

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 l = lines[i].split(' ').map(Number);
        var n = l[0], m = l[1], rb = l[2], cb = l[3], rd = l[4], cd = l[5];
        var ans = 0;
        var a = 1;
        var b = 1;
        while(true){
            if(rb == rd || cb == cd){
                break;
            }
            if(rb + a > n || rb + a < 0){
                a *= -1;
            }else if(cb + b > m || cb + b < 0){
                b *= -1;
            }
            rb += a;
            cb += b;
            ans++;
        }
        console.log(ans);
    }
});

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 l = lines[i].split(' ').map(Number);
        var n = l[0], m = l[1], rb = l[2], cb = l[3], rd = l[4], cd = l[5];
        var ans = 0;
        var a = 1;
        var b = 1;
        while(true){
            if(rb == rd || cb == cd){
                break;
            }
            if(rb + a > n || rb + a < 1){
                a *= -1;
            }else if(cb + b > m || cb + b < 1){
                b *= -1;
            }
            rb += a;
            cb += b;
            ans++;
        }
        console.log(ans);
    }
});