Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.

After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.

Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of 

$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$

Help Monocarp to calculate the maximum possible value of f(a).

Input

The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.

The first line of each test case contains one integer n (1 ≤ n ≤ 100).

The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).

The third line contains one integer m (1 ≤ m ≤ 100).

The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).

Output

For each test case, print one integer — the maximum possible value of f(a).

Example

Input


4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0


Output


13
13
0
0

Note

In the explanations for the sample test cases, red elements are marked as bold.

In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].

In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].

In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].

In the fourth test case, one of the possible sequences a is [0, 0].
import java.util.*;
import java.lang.Math;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.io.*;
import java.math.BigInteger;
import java.io.FileWriter;
 
public class CodeForces2 {
 
	static class FastReader
 
	{
		BufferedReader br;
		StringTokenizer st;
 
		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
 
		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}
 
		int nextInt() {
			return Integer.parseInt(next());
		}
 
		long nextLong() {
			return Long.parseLong(next());
		}
 
		double nextDouble() {
			return Double.parseDouble(next());
		}
 
		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}
 
	static FastReader f = new FastReader();
 
	static void print(String s) {
		System.out.print(s);
	}
 
	static void print(boolean s) {
		System.out.print(s);
	}
 
	static boolean isPrime(long n) {
		// Corner cases
		if (n <= 1)
			return false;
		if (n <= 3)
			return true;
 
		// This is checked so that we can skip
		// middle five numbers in below loop
		if (n % 2 == 0 || n % 3 == 0)
			return false;
 
		for (int i = 5; i * i <= n; i = i + 6)
			if (n % i == 0 || n % (i + 2) == 0)
				return false;
 
		return true;
	}
 
	static long[] inArr(long a[], int n) {
		for (int i = 0; i < n; i++)
			a[i] = f.nextLong();
		return (a);
	}
 
	static void printSubsets(int set[]) {
		int n = set.length;
		Arrays.sort(set);
		for (int i = 0; i < n; i++) {
 
		}
		HashMap<Integer, Integer> hm = new HashMap<>();
		for (int i = 0; i < (1 << n); i++) {
			for (int j = 0; j < n; j++) {
				if ((i & (1 << j)) > 0) {
					if (hm.get(set[j]) == null) {
						hm.put(set[j], 0);
					}
					hm.put(set[j], hm.get(set[j]) + 1);
 
				}
			}
 
		}
	}
 
	static long gcd(long a, long b) {
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
 
	static long lcm(long a, long b) {
		return (a * b) / gcd(a, b);
	}
 
	static long power(long x, long y, long p) {
 
		// Initialize result
		long res = 1;
 
		// Update x if it is more than or
		// equal to p
		x = x % p;
 
		while (y > 0) {
 
			// If y is odd, multiply x
			// with result
			if (y % 2 == 1)
				res = (res * x) % p;
 
			// y must be even now
			y = y >> 1; // y = y/2
			x = (x * x) % p;
		}
 
		return res;
	}
 
	static long modInverse(long n, long p) {
		return power(n, p - 2, p);
	}
 
	static long nCrModPFermat(int n, int r) {
		long p = 1000000007;
 
		// Base case
		if (r == 0)
			return 1;
 
		// Fill factorial array so that we
		// can find all factorial of r, n
		// and n-r
		long[] fac = new long[n + 1];
		fac[0] = 1;
 
		for (int i = 1; i <= n; i++)
			fac[i] = fac[i - 1] * i % p;
 
		return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
	}
 
	public static void main(String args[]) throws Exception {
		BufferedWriter w = new BufferedWriter(new OutputStreamWriter(System.out));
		Random rand = new Random();
		int t = f.nextInt();
		while (t-- != 0) 
		{
			int n=f.nextInt();
			long a[]=new long[n];
			inArr(a, n);
			int m=f.nextInt();
			long b[]=new long[m];
			inArr(b, m);	
			long preA[]=new long[n+1];preA[0]=0;preA[1]=a[0];
			long preB[]=new long[m+1];preB[0]=0;preB[1]=b[0];
			for(int i=2;i<=n;i++){
				preA[i]=preA[i-1]+a[i-1];
			}
			for(int i=2;i<=m;i++){
				preB[i]=preB[i-1]+b[i-1];
			}
			// for(int i=0;i<=n;i++){
			// 	w.write(preA[i]+" ");
			// }
			// w.write("\n");
			// for(int i=0;i<=m;i++){
			// 	w.write(preB[i]+" ");
			// }
			// w.write("\n");
			
			long max=0;
			for(int i=0;i<n+1;i++){
				for(int j=0;j<m+1;j++){
					max=Math.max(preA[i]+preB[j],max);
				}
			}
			w.write(max+"\n");
		}
 
		w.flush();
 
	}
}
