public void solve(int testNumber, FastScanner in, FastPrinter out) {
int n = in.nextInt();
int p = in.nextInt();
int m = in.nextInt();
Query[] qs = new Query[m];
int[] z = new int[4 * m + 10];
int cn = 0;
for (int i = 0; i < m; i++) {
int time = in.nextInt();
int type = in.next().equals("save") ? 0 : 1;
int a = in.nextInt();
int b = in.nextInt();
qs[i] = new Query(time, type, a, b);
if (type == 0) {
z[cn++] = a - 1;
z[cn++] = b;
} else {
--a;
z[cn++] = a - b + 1;
z[cn++] = a;
z[cn++] = a + b;
}
}
z[cn++] = 0;
z[cn++] = n;
z = Arrays.copyOf(z, cn);
z = ArrayUtils.sortAndUnique(z);
int[] cnt = new int[z.length - 1];
{
for (int i = 0; i < z.length - 1; i++) {
cnt[i] = z[i + 1] - z[i];
}
}
SegmentTree tree = new SegmentTree(cnt);
int last = 0;
double all = 0;
for (int i = 0; i < m; i++) {
int time = qs[i].time;
tree.addValue(0, cnt.length, 1. * p * (time - last), 0);
last = time;
if (qs[i].type == 0) {
int l = qs[i].a - 1;
int r = qs[i].b;
l = Arrays.binarySearch(z, l);
r = Arrays.binarySearch(z, r);
double sum = tree.getSum(l, r);
all += sum;
out.println(all);
tree.setZero(l, r);
} else {
int index = qs[i].a - 1;
int d = qs[i].b;
double x = all / (2 * SegmentTree.sum(d) + d);
int id = Arrays.binarySearch(z, index);
tree.addValue(Arrays.binarySearch(z, index - d + 1), id, x, x);
tree.addValue(id, Arrays.binarySearch(z, index + d), d * x, -x);
all = 0;
}
}
}
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
int t = sc.nextInt();
while (t-- > 0) {
int n = sc.nextInt();
int N = 1;
while (N < 100001) N <<= 1; // padding
SegmentTree st = new SegmentTree(N + 1);
int ans = 0;
for (int i = 0; i < n; i++) {
int l = sc.nextInt(), r = sc.nextInt(), h = sc.nextInt();
int tm = st.query(l, r - 1, h);
st.update_range(l, r - 1, h);
ans += tm;
}
out.println(ans);
}
out.flush();
out.close();
}
public void solve(int testNumber, FastScanner in, FastPrinter out) {
int n = in.nextInt();
int m = in.nextInt();
int c = in.nextInt();
int[] x = new int[n];
for (int i = 0; i < n; i++) {
x[i] = in.nextInt();
}
double[] prob = new double[n];
for (int i = 0; i + 1 < n; i++) {
prob[i] = in.nextInt() * .01;
}
SegmentTree tree = new SegmentTree(n - 1);
for (int i = 0; i + 1 < n; i++) {
tree.set(i, -.5 * (x[i + 1] - x[i]) + prob[i] * c);
}
double answer = 0;
for (int i = 0; i < m; i++) {
int a = in.nextInt() - 1;
int b = in.nextInt() - 1;
double profit = tree.getMin(a, b);
profit = -profit;
answer += profit;
}
out.println(answer);
}
public SegmentTree build(int start, int end) {
if (start > end) {
return null;
}
SegmentTree root = new SegmentTree(start, end);
if (start == end) {
return root;
}
int mid = start + ((end - start) >> 1);
root.left = build(start, mid);
root.right = build(mid + 1, end);
return root;
}
public void update(SegmentTree root, int p) {
if (root == null) {
return;
}
if (root.start == p && root.end == p) {
root.count++;
return;
}
int mid = root.start + ((root.end - root.start) >> 1);
if (mid >= p) {
update(root.left, p);
} else {
update(root.right, p);
}
root.count = 0;
if (root.left != null) {
root.count += root.left.count;
}
if (root.right != null) {
root.count += root.right.count;
}
}
/**
* @param pages: an array of integers
* @param k: an integer
* @return: an integer
*/
public int copyBooks(int[] pages, int k) {
// write your code here
// dp[i][j] means firt i books assigned to j peopler, need smallest minutes.
// dp[i][j] = Math.max(dp[p-1][j-1] , cost[p][i]) where p<i;
// Initialization:
// dp[i][1] = cost[1][i];
if(pages == null || pages.length == 0 ) return 0;
if(k == 0) return Integer.MAX_VALUE;
int size = pages.length;
// Build a Segment_Tree to support the range sum query
SegmentTree st = new SegmentTree(pages);
int [][] dp = new int[size+1][k+1];
// Initialization:
for(int i = 1; i <= size; i++) {
dp[i][1] = st.query(st.root, 0,i-1);
}
// Fill the dp
for(int j = 2; j <= k; j++) {
dp[i][j] = Integer.MAX_VALUE;
for(int i = 1 ; i <= size; i++) {
for(int p = 1; p < i; p++) {
dp[i][j] = Math.min(dp[i][j], Math.max(dp[p-1][j-1], st.query(st.root, p-1,i-1)));
}
}
}
return dp[size][k];
}
