Polycarp found n segments on the street. A segment with the index i is described by two integers l_i and r_i — coordinates of the beginning and end of the segment, respectively. Polycarp realized that he didn't need all the segments, so he wanted to delete some of them.

Polycarp believes that a set of k segments is good if there is a segment [l_i, r_i] (1 ≤ i ≤ k) from the set, such that it intersects every segment from the set (the intersection must be a point or segment). For example, a set of 3 segments [[1, 4], [2, 3], [3, 6]] is good, since the segment [2, 3] intersects each segment from the set. Set of 4 segments [[1, 2], [2, 3], [3, 5], [4, 5]] is not good.

Polycarp wonders, what is the minimum number of segments he has to delete so that the remaining segments form a good set?

Input

The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^5) — number of test cases. Then t test cases follow.

The first line of each test case contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of segments. This is followed by n lines describing the segments.

Each segment is described by two integers l and r (1 ≤ l ≤ r ≤ 10^9) — coordinates of the beginning and end of the segment, respectively.

It is guaranteed that the sum of n for all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case, output a single integer — the minimum number of segments that need to be deleted in order for the set of remaining segments to become good.

Example

Input


4
3
1 4
2 3
3 6
4
1 2
2 3
3 5
4 5
5
1 2
3 8
4 5
6 7
9 10
5
1 5
2 4
3 5
3 8
4 8


Output


0
1
2
0

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeSet;

/* 
     * Subscribe to galen_colin!
     * https://tinyurl.com/galencolin
 */
 /*
    1
    3
    0 1
    1 2
    2 3
 */
public class F {

  static InputReader in = new InputReader(System.in);
  static class InputReader {

    private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
    private static final InputStream DEFAULT_STREAM = System.in;
    private static final int MAX_DECIMAL_PRECISION = 21;
    private int c;
    private byte[] buf;
    private int bufferSize, bufIndex, numBytesRead;

    private InputStream stream;

    private static final byte EOF = -1;
    private static final byte NEW_LINE = 10;
    private static final byte SPACE = 32;
    private static final byte DASH = 45;
    private static final byte DOT = 46;

    private char[] charBuffer;

    private static byte[] bytes = new byte[58];
    private static int[] ints = new int[58];
    private static char[] chars = new char[128];

    static {
      char ch = ' ';
      int value = 0;
      byte _byte = 0;
      for (int i = 48; i < 58; i++) {
        bytes[i] = _byte++;
      }
      for (int i = 48; i < 58; i++) {
        ints[i] = value++;
      }
      for (int i = 32; i < 128; i++) {
        chars[i] = ch++;
      }
    }

    private static final double[][] doubles = {
      {0.0d, 0.00d, 0.000d, 0.0000d, 0.00000d, 0.000000d, 0.0000000d, 0.00000000d, 0.000000000d, 0.0000000000d, 0.00000000000d, 0.000000000000d, 0.0000000000000d, 0.00000000000000d, 0.000000000000000d, 0.0000000000000000d, 0.00000000000000000d, 0.000000000000000000d, 0.0000000000000000000d, 0.00000000000000000000d, 0.000000000000000000000d},
      {0.1d, 0.01d, 0.001d, 0.0001d, 0.00001d, 0.000001d, 0.0000001d, 0.00000001d, 0.000000001d, 0.0000000001d, 0.00000000001d, 0.000000000001d, 0.0000000000001d, 0.00000000000001d, 0.000000000000001d, 0.0000000000000001d, 0.00000000000000001d, 0.000000000000000001d, 0.0000000000000000001d, 0.00000000000000000001d, 0.000000000000000000001d},
      {0.2d, 0.02d, 0.002d, 0.0002d, 0.00002d, 0.000002d, 0.0000002d, 0.00000002d, 0.000000002d, 0.0000000002d, 0.00000000002d, 0.000000000002d, 0.0000000000002d, 0.00000000000002d, 0.000000000000002d, 0.0000000000000002d, 0.00000000000000002d, 0.000000000000000002d, 0.0000000000000000002d, 0.00000000000000000002d, 0.000000000000000000002d},
      {0.3d, 0.03d, 0.003d, 0.0003d, 0.00003d, 0.000003d, 0.0000003d, 0.00000003d, 0.000000003d, 0.0000000003d, 0.00000000003d, 0.000000000003d, 0.0000000000003d, 0.00000000000003d, 0.000000000000003d, 0.0000000000000003d, 0.00000000000000003d, 0.000000000000000003d, 0.0000000000000000003d, 0.00000000000000000003d, 0.000000000000000000003d},
      {0.4d, 0.04d, 0.004d, 0.0004d, 0.00004d, 0.000004d, 0.0000004d, 0.00000004d, 0.000000004d, 0.0000000004d, 0.00000000004d, 0.000000000004d, 0.0000000000004d, 0.00000000000004d, 0.000000000000004d, 0.0000000000000004d, 0.00000000000000004d, 0.000000000000000004d, 0.0000000000000000004d, 0.00000000000000000004d, 0.000000000000000000004d},
      {0.5d, 0.05d, 0.005d, 0.0005d, 0.00005d, 0.000005d, 0.0000005d, 0.00000005d, 0.000000005d, 0.0000000005d, 0.00000000005d, 0.000000000005d, 0.0000000000005d, 0.00000000000005d, 0.000000000000005d, 0.0000000000000005d, 0.00000000000000005d, 0.000000000000000005d, 0.0000000000000000005d, 0.00000000000000000005d, 0.000000000000000000005d},
      {0.6d, 0.06d, 0.006d, 0.0006d, 0.00006d, 0.000006d, 0.0000006d, 0.00000006d, 0.000000006d, 0.0000000006d, 0.00000000006d, 0.000000000006d, 0.0000000000006d, 0.00000000000006d, 0.000000000000006d, 0.0000000000000006d, 0.00000000000000006d, 0.000000000000000006d, 0.0000000000000000006d, 0.00000000000000000006d, 0.000000000000000000006d},
      {0.7d, 0.07d, 0.007d, 0.0007d, 0.00007d, 0.000007d, 0.0000007d, 0.00000007d, 0.000000007d, 0.0000000007d, 0.00000000007d, 0.000000000007d, 0.0000000000007d, 0.00000000000007d, 0.000000000000007d, 0.0000000000000007d, 0.00000000000000007d, 0.000000000000000007d, 0.0000000000000000007d, 0.00000000000000000007d, 0.000000000000000000007d},
      {0.8d, 0.08d, 0.008d, 0.0008d, 0.00008d, 0.000008d, 0.0000008d, 0.00000008d, 0.000000008d, 0.0000000008d, 0.00000000008d, 0.000000000008d, 0.0000000000008d, 0.00000000000008d, 0.000000000000008d, 0.0000000000000008d, 0.00000000000000008d, 0.000000000000000008d, 0.0000000000000000008d, 0.00000000000000000008d, 0.000000000000000000008d},
      {0.9d, 0.09d, 0.009d, 0.0009d, 0.00009d, 0.000009d, 0.0000009d, 0.00000009d, 0.000000009d, 0.0000000009d, 0.00000000009d, 0.000000000009d, 0.0000000000009d, 0.00000000000009d, 0.000000000000009d, 0.0000000000000009d, 0.00000000000000009d, 0.000000000000000009d, 0.0000000000000000009d, 0.00000000000000000009d, 0.000000000000000000009d}
    };

    public InputReader() {
      this(DEFAULT_STREAM, DEFAULT_BUFFER_SIZE);
    }

    public InputReader(int bufferSize) {
      this(DEFAULT_STREAM, bufferSize);
    }

    public InputReader(InputStream stream) {
      this(stream, DEFAULT_BUFFER_SIZE);
    }

    public InputReader(InputStream stream, int bufferSize) {
      if (stream == null || bufferSize <= 0) {
        throw new IllegalArgumentException();
      }
      buf = new byte[bufferSize];
      charBuffer = new char[128];
      this.bufferSize = bufferSize;
      this.stream = stream;
    }

    private byte read() throws IOException {

      if (numBytesRead == EOF) {
        throw new IOException();
      }

      if (bufIndex >= numBytesRead) {
        bufIndex = 0;
        numBytesRead = stream.read(buf);
        if (numBytesRead == EOF) {
          return EOF;
        }
      }

      return buf[bufIndex++];
    }
    
    private void doubleCharBufferSize() {
    char[] newBuffer = new char[charBuffer.length << 1];
    for (int i = 0; i < charBuffer.length; i++) {
      newBuffer[i] = charBuffer[i];
    }
    charBuffer = newBuffer;
  }
    private int readJunk(int token) throws IOException {

      if (numBytesRead == EOF) {
        return EOF;
      }

      do {

        while (bufIndex < numBytesRead) {
          if (buf[bufIndex] > token) {
            return 0;
          }
          bufIndex++;
        }

        numBytesRead = stream.read(buf);
        if (numBytesRead == EOF) {
          return EOF;
        }
        bufIndex = 0;

      } while (true);

    }

    public byte nextByte() throws IOException {
      return (byte) nextInt();
    }

    public int nextInt() throws IOException {

      if (readJunk(DASH - 1) == EOF) {
        throw new IOException();
      }
      int sgn = 1, res = 0;

      c = buf[bufIndex];
      if (c == DASH) {
        sgn = -1;
        bufIndex++;
      }

      do {

        while (bufIndex < numBytesRead) {
          if (buf[bufIndex] > SPACE) {
            res = (res << 3) + (res << 1);
            res += ints[buf[bufIndex++]];
          } else {
            bufIndex++;
            return res * sgn;
          }
        }

        numBytesRead = stream.read(buf);
        if (numBytesRead == EOF) {
          return res * sgn;
        }
        bufIndex = 0;

      } while (true);

    }

    public void close() throws IOException {
      stream.close();
    }
  }
  
  public static void main(String[] args) throws IOException {
    int T = in.nextInt();
    PrintWriter out = new PrintWriter(System.out);
    for (int tt = 0; tt < T; tt++) {
      int n = in.nextInt();
      Seg[] segs = new Seg[n];
      for (int i = 0; i < n; i++) {
        segs[i] = new Seg(in.nextInt(), in.nextInt());
      }
      TreeSet<Integer> xs = new TreeSet<>();
      for (Seg s : segs) {
        xs.add(s.l);
      }
      for (Seg s : segs) {
        xs.add(s.r);
      }
      HashMap<Integer, Integer> compress = new HashMap<>();
      for (int i : xs) {
        compress.put(i, compress.size());
      }

      for (Seg s : segs) {
        s.l = compress.get(s.l);
        s.r = compress.get(s.r);
      }

      BIT bit = new BIT(compress.size() + 1);
      Event[] events = new Event[2 * n];
      int index = 0;
      for (Seg s : segs) {
        events[index++] = new Event(s.l, s.r, true);
        events[index++] = new Event(s.l, s.r, false);
      }
      Arrays.sort(events);
      int ans = 0;
      for (Event e : events) {
        if (e.start) {
          bit.update(e.x2, 1);
        } else {
          ans = Math.max(ans, bit.query(e.x1, compress.size()));
        }
      }
      out.println(n - ans);
    }
    out.close();
  }

  static class Seg {

    int l, r;

    public Seg(int l, int r) {
      this.l = l;
      this.r = r;
    }
  }

  static class Event implements Comparable<Event> {

    int x1, x2;
    boolean start;

    public Event(int x1, int x2, boolean start) {
      this.x1 = x1;
      this.x2 = x2;
      this.start = start;
    }

    int x() {
      if (start) {
        return x1;
      }
      return x2;
    }

    public int compareTo(Event o) {
      if (x() != o.x()) {
        return Integer.compare(x(), o.x());
      }
      if (start == o.start) {
        return 0;
      }
      if (start) {
        return -1;
      }
      return 1;
    }
  }

  static class BIT {

    int n, tree[];

    public BIT(int N) {
      n = N;
      tree = new int[N + 1];
    }

    void update(int i, int val) {
      for (i++; i <= n; i += i & -i) {
        tree[i] += val;
      }
    }

    int read(int i) {
      int sum = 0;
      for (i++; i > 0; i -= i & -i) {
        sum += tree[i];
      }
      return sum;
    }

    // query sum of [l, r] inclusive
    int query(int l, int r) {
      return read(r) - read(l - 1);
    }

    // if the BIT is a freq array, returns the index of the
    // kth item (0-indexed), or n if there are <= k items.
    int getKth(int k) {
      if (k < 0) {
        return -1;
      }
      int i = 0;
      for (int pw = Integer.highestOneBit(n); pw > 0; pw >>= 1) {
        if (i + pw <= n && tree[i + pw] <= k) {
          k -= tree[i += pw];
        }
      }
      return i;
    }
  }

  static void ruffle_sort(int[] a) {
    // shandom_ruffle
    Random r = new Random();
    int n = a.length;
    for (int i = 0; i < n; i++) {
      int oi = r.nextInt(i);
      int temp = a[i];
      a[i] = a[oi];
      a[oi] = temp;
    }

    // sort
    Arrays.sort(a);
  }

}
