description: On a circle lie 2n distinct points, with the following property: however you choose 3 chords that connect 3 disjoint pairs of points, no point strictly inside the circle belongs to all 3 chords. The points are numbered 1,   2,   ...,   2n in clockwise order.
  
  Initially, k chords connect k pairs of points, in such a way that all the 2k endpoints of these chords are distinct.
  
  You want to draw n - k additional chords that connect the remaining 2(n - k) points (each point must be an endpoint of exactly one chord).
  
  In the end, let x be the total number of intersections among all n chords. Compute the maximum value that x can attain if you choose the n - k chords optimally.
  
  Note that the exact position of the 2n points is not relevant, as long as the property stated in the first paragraph holds.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases. Then t test cases follow.
  
  The first line of each test case contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — half the number of points and the number of chords initially drawn.
  
  Then k lines follow. The i-th of them contains two integers x_i and y_i (1 ≤ x_i,   y_i ≤ 2n, x_i ≠ y_i) — the endpoints of the i-th chord. It is guaranteed that the 2k numbers x_1,   y_1,   x_2,   y_2,   ...,   x_k,   y_k are all distinct.
  
  Output
  
  For each test case, output the maximum number of intersections that can be obtained by drawing n - k additional chords.
  
  Example
  
  Input
  
  
  4
  4 2
  8 2
  1 5
  1 1
  2 1
  2 0
  10 6
  14 6
  2 20
  9 10
  13 18
  15 12
  11 7
  
  
  Output
  
  
  4
  0
  1
  14
  
  Note
  
  In the first test case, there are three ways to draw the 2 additional chords, shown below (black chords are the ones initially drawn, while red chords are the new ones):
  
  <image>
  
  We see that the third way gives the maximum number of intersections, namely 4.
  
  In the second test case, there are no more chords to draw. Of course, with only one chord present there are no intersections.
  
  In the third test case, we can make at most one intersection by drawing chords 1-3 and 2-4, as shown below:
  
  <image>
solution: 
  
  import java.util.*;
  import java.io.*;
  
  public class C {
  	static StringBuilder sb;
  	static dsu dsu;
  	static long fact[];
  	static int mod = (int) (1e9 + 7);
  
  	static class Pair implements Comparable<Pair> {
  		int x;
  		int y;
  
  		Pair(int x, int y) {
  			this.x = x;
  			this.y = y;
  		}
  
  		public int compareTo(Pair o) {
  			return (int) (this.x - o.x);
  
  		}
  
  	}
  
  	static void solve() {
  		int n = i();
  		int k = i();
  
  		HashSet<Integer> set = new HashSet<>();
  		for (int i = 0; i < n; i++) {
  			set.add(2 * i + 1);
  			set.add(2 * i + 2);
  		}
  
  		ArrayList<Pair> end = new ArrayList<>();
  		for (int i = 0; i < k; i++) {
  			int x = i();
  			int y = i();
  			if (x > y) {
  				int temp = x;
  				x = y;
  				y = temp;
  			}
  
  			end.add(new Pair(x, y));
  			set.remove(x);
  			set.remove(y);
  		}
  
  		List<Integer> rem = new ArrayList<>();
  
  		for (int p : set) {
  			rem.add(p);
  		}
  
  		Collections.sort(rem);
  
  		for (int i = 0; i < rem.size() / 2; i++) {
  			end.add(new Pair(rem.get(i), rem.get(i + rem.size() / 2)));
  		}
  
  		Collections.sort(end);
  
  		int count = 0;
  		for (int i = 0; i < end.size(); i++) {
  			for (int j = i + 1; j < end.size(); j++) {
  				if (end.get(j).y > end.get(i).y && end.get(i).y > end.get(j).x) {
  					count++;
  				}
  			}
  		}
  		sb.append(count + "\n");
  
  	}
  
  	public static void main(String[] args) {
  		sb = new StringBuilder();
  		int test = i();
  		while (test-- > 0) {
  			solve();
  		}
  		System.out.println(sb);
  
  	}
  
  	/*
  	 * fact=new long[(int)1e6+10]; fact[0]=fact[1]=1; for(int i=2;i<fact.length;i++)
  	 * { fact[i]=((long)(i%mod)1L(long)(fact[i-1]%mod))%mod; }
  	 */
  //**************NCR%P******************	 
  	static long ncr(int n, int r) {
  		if (r > n)
  			return (long) 0;
  
  		long res = fact[n] % mod;
  		// System.out.println(res);
  		res = ((long) (res % mod) * (long) (p(fact[r], mod - 2) % mod)) % mod;
  		res = ((long) (res % mod) * (long) (p(fact[n - r], mod - 2) % mod)) % mod;
  		// System.out.println(res);
  		return res;
  
  	}
  
  	static long p(long x, long y)// POWER FXN //
  	{
  		if (y == 0)
  			return 1;
  
  		long res = 1;
  		while (y > 0) {
  			if (y % 2 == 1) {
  				res = (res * x) % mod;
  				y--;
  			}
  
  			x = (x * x) % mod;
  			y = y / 2;
  
  		}
  		return res;
  	}
  
  //**************END******************
  
  	// *************Disjoint set
  	// union*********//
  	static class dsu {
  		int parent[];
  
  		dsu(int n) {
  			parent = new int[n];
  			for (int i = 0; i < n; i++)
  				parent[i] = -1;
  		}
  
  		int find(int a) {
  			if (parent[a] < 0)
  				return a;
  			else {
  				int x = find(parent[a]);
  				parent[a] = x;
  				return x;
  			}
  		}
  
  		void merge(int a, int b) {
  			a = find(a);
  			b = find(b);
  			if (a == b)
  				return;
  			parent[b] = a;
  		}
  	}
  
  //**************PRIME FACTORIZE **********************************//
  	static TreeMap<Integer, Integer> prime(long n) {
  		TreeMap<Integer, Integer> h = new TreeMap<>();
  		long num = n;
  		for (int i = 2; i <= Math.sqrt(num); i++) {
  			if (n % i == 0) {
  				int nt = 0;
  				while (n % i == 0) {
  					n = n / i;
  					nt++;
  				}
  				h.put(i, nt);
  			}
  		}
  		if (n != 1)
  			h.put((int) n, 1);
  		return h;
  
  	}
  
  //****CLASS PAIR ************************************************
  
  //****CLASS PAIR **************************************************
  
  	static class InputReader {
  		private InputStream stream;
  		private byte[] buf = new byte[1024];
  		private int curChar;
  		private int numChars;
  		private SpaceCharFilter filter;
  
  		public InputReader(InputStream stream) {
  			this.stream = stream;
  		}
  
  		public int read() {
  			if (numChars == -1)
  				throw new InputMismatchException();
  			if (curChar >= numChars) {
  				curChar = 0;
  				try {
  					numChars = stream.read(buf);
  				} catch (IOException e) {
  					throw new InputMismatchException();
  				}
  				if (numChars <= 0)
  					return -1;
  			}
  			return buf[curChar++];
  		}
  
  		public int Int() {
  			int c = read();
  			while (isSpaceChar(c))
  				c = read();
  			int sgn = 1;
  			if (c == '-') {
  				sgn = -1;
  				c = read();
  			}
  			int res = 0;
  			do {
  				if (c < '0' || c > '9')
  					throw new InputMismatchException();
  				res *= 10;
  				res += c - '0';
  				c = read();
  			} while (!isSpaceChar(c));
  			return res * sgn;
  		}
  
  		public String String() {
  			int c = read();
  			while (isSpaceChar(c))
  				c = read();
  			StringBuilder res = new StringBuilder();
  			do {
  				res.appendCodePoint(c);
  				c = read();
  			} while (!isSpaceChar(c));
  			return res.toString();
  		}
  
  		public boolean isSpaceChar(int c) {
  			if (filter != null)
  				return filter.isSpaceChar(c);
  			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  		}
  
  		public String next() {
  			return String();
  		}
  
  		public interface SpaceCharFilter {
  			public boolean isSpaceChar(int ch);
  		}
  	}
  
  	static class OutputWriter {
  		private final PrintWriter writer;
  
  		public OutputWriter(OutputStream outputStream) {
  			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
  		}
  
  		public OutputWriter(Writer writer) {
  			this.writer = new PrintWriter(writer);
  		}
  
  		public void print(Object... objects) {
  			for (int i = 0; i < objects.length; i++) {
  				if (i != 0)
  					writer.print(' ');
  				writer.print(objects[i]);
  			}
  		}
  
  		public void printLine(Object... objects) {
  			print(objects);
  			writer.println();
  		}
  
  		public void close() {
  			writer.close();
  		}
  
  		public void flush() {
  			writer.flush();
  		}
  	}
  
  	static InputReader in = new InputReader(System.in);
  	static OutputWriter out = new OutputWriter(System.out);
  
  	public static long[] sort(long[] a2) {
  		int n = a2.length;
  		ArrayList<Long> l = new ArrayList<>();
  		for (long i : a2)
  			l.add(i);
  		Collections.sort(l);
  		for (int i = 0; i < l.size(); i++)
  			a2[i] = l.get(i);
  		return a2;
  	}
  
  	public static int[] sort(int[] a2) {
  		int n = a2.length;
  		ArrayList<Integer> l = new ArrayList<>();
  		for (int i : a2)
  			l.add(i);
  		Collections.sort(l);
  		for (int i = 0; i < l.size(); i++)
  			a2[i] = l.get(i);
  		return a2;
  	}
  
  	public static long pow(long x, long y) {
  		long res = 1;
  		while (y > 0) {
  			if (y % 2 != 0) {
  				res = (res * x);// % modulus;
  				y--;
  
  			}
  			x = (x * x);// % modulus;
  			y = y / 2;
  		}
  		return res;
  	}
  
  //GCD___+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  	public static long gcd(long x, long y) {
  		if (x == 0)
  			return y;
  		else
  			return gcd(y % x, x);
  	}
  	// ******LOWEST COMMON MULTIPLE
  	// *********************************************
  
  	public static long lcm(long x, long y) {
  		return (x * (y / gcd(x, y)));
  	}
  
  //INPUT PATTERN********************************************************
  	public static int i() {
  		return in.Int();
  	}
  
  	public static long l() {
  		String s = in.String();
  		return Long.parseLong(s);
  	}
  
  	public static String s() {
  		return in.String();
  	}
  
  	public static int[] readArrayi(int n) {
  		int A[] = new int[n];
  		for (int i = 0; i < n; i++) {
  			A[i] = i();
  		}
  		return A;
  	}
  
  	public static long[] readArray(long n) {
  		long A[] = new long[(int) n];
  		for (int i = 0; i < n; i++) {
  			A[i] = l();
  		}
  		return A;
  	}
  
  }