import java.math.*;
import java.util.*;
import java.io.*;

public class R {

    public static BigInteger kgv(LinkedList<BigInteger> list) {

	Iterator<BigInteger> it = list.iterator();
	BigInteger a = it.next();
	BigInteger b = it.next();
	BigInteger gcd = a.gcd(b);
	BigInteger kgv = (a.multiply(b)).divide(gcd);
	while (it.hasNext()) {
	    a = kgv;
	    b = it.next();
	    gcd = a.gcd(b);
	    kgv = (a.multiply(b)).divide(gcd);
	}
	return kgv;
    }


    public static BigInteger chinese(BigInteger[] c, BigInteger[] k) {

	BigInteger[] a = new BigInteger[c.length];
	for (int i = 0; i < c.length; i++) {
	    a[i] = k[i].mod(c[i]);
	}
	for (int i = 0; i < c.length; i++) {
	    for (int j = i+1; j < c.length; j++) {
		BigInteger gcd = c[i].gcd(c[j]);
		BigInteger x = a[i].mod(gcd);
		BigInteger y = a[j].mod(gcd);
		if (x.compareTo(y) != 0) {
		    BigInteger solve = new BigInteger("-1");
		    return solve;
		}
	    }
	}
	LinkedList<BigInteger[]> kongruenzen = new LinkedList<BigInteger[]>();
	boolean[] marked = new boolean[c.length];
	for (int i = 0; i < c.length; i++) {
	    BigInteger rest = a[i];
	    if (marked[i]) continue;
	    LinkedList<BigInteger> cs = new LinkedList<BigInteger>();
	    for (int j = 0; j < c.length; j++) {
		if (rest.compareTo(a[j]) == 0 && !marked[j]) {
		    marked[j] = true;
		    cs.add(c[j]);
		}
	    }
	    BigInteger gcd;
	    BigInteger kgv;
	    if (cs.size() > 1) {
		kgv = kgv(cs);
	    }
	    else {
		kgv = cs.getFirst();
	    }
	    BigInteger[] kong = {kgv, rest};
	    kongruenzen.add(kong);
	}
	BigInteger[][] kongs = new BigInteger[kongruenzen.size()][2];
	Iterator<BigInteger[]> it = kongruenzen.iterator();
	int index = 0;
	while (it.hasNext()) {
	    BigInteger[] temp = it.next();
	    kongs[index][0] = temp[0];
	    kongs[index][1] = temp[1];
	    index++;
	}
	BigInteger grossM = new BigInteger("1");
	BigInteger[] M = new BigInteger[kongruenzen.size()];
	BigInteger[] m = new BigInteger[kongruenzen.size()];
	for (int i = 0; i < kongs.length; i++) {
	    grossM = grossM.multiply(kongs[i][0]);
	}
	for (int i = 0; i < kongs.length; i++) {
	    m[i] = kongs[i][0];
	    M[i] = grossM.divide(m[i]);
	}
	BigInteger[] e = new BigInteger[kongs.length];
	BigInteger[] stsave;
	for (int i = 0; i < kongs.length; i++) {
	    stsave = extended(m[i], M[i]);
	    e[i] = stsave[1].multiply(M[i]);
	}
	BigInteger sum = new BigInteger("0");
	BigInteger kgv = new BigInteger("1");
	for (int i = 0; i < kongs.length; i++) {
	    sum = sum.add(e[i].multiply(kongs[i][1]));
	    kgv = kgv.multiply(kongs[i][0]);
	}
	BigInteger[] x = new BigInteger[c.length];
	boolean allpositive = false;
	BigInteger zero = new BigInteger("0");
	while (sum.compareTo(zero) < 0) {
	    sum = sum.add(kgv);
	}
	while (!allpositive) {
	    allpositive = true;
	    for (int i = 0; i < c.length; i++) {
		x[i] = (sum.subtract(k[i])).divide(c[i]);
		if (x[i].compareTo(zero) < 0) {
		    allpositive = false;
		    sum = sum.add(kgv);
		    break;
		}
	    }
	}
	return sum; 
    }

    public static BigInteger[] extended(BigInteger a, BigInteger b) {

	BigInteger[][] euklid = new BigInteger[100][5];
	BigInteger zero = new BigInteger("0");
	euklid[0][0] = a;
	euklid[0][1] = b;
	int index = 0;

	while (b.compareTo(zero) > 0) {
	    euklid[index][2] = euklid[index][0].divide(euklid[index][1]);
	    BigInteger rest = a.mod(b);
	    a = b;
	    b = rest;
	    index++;
	    euklid[index][0] = a;
	    euklid[index][1] = b;
	}
	euklid[index][3] = new BigInteger("1");
	euklid[index][4] = new BigInteger("0");
	index--;
	for (int i = index; i >= 0; i--) {
	    euklid[i][3] = euklid[i+1][4];
	    euklid[i][4] = euklid[i+1][3].subtract(euklid[i][2].multiply(euklid[i+1][4]));
	}
	for (index = 0; index < 10; index++) {
	}
	BigInteger[] result = {euklid[0][3], euklid[0][4]};
	return result;
    }


    public static void main(String[] args) {
	
	int n;
	Scanner s = new Scanner(System.in);
	n = s.nextInt();
	for (int i = 0; i < n; i++) {
	    int m = s.nextInt();
	    BigInteger[] c = new BigInteger[m];
	    BigInteger[] k = new BigInteger[m];
	    for (int j = 0; j < m; j++) {
		k[j] = s.nextBigInteger();
		c[j] = s.nextBigInteger();
		k[j] = k[j].add(s.nextBigInteger());
	    }
	    if (m == 1) {
		System.out.println(k[0]);
		continue;
	    }
	    BigInteger solve = chinese(c, k);
	    BigInteger minus = new BigInteger("-1");
	    if (solve.compareTo(minus) == 0) {
		System.out.println("inconsistent");
	    }
	    else {
		System.out.println(solve);
	    }
	}
    }
}