// Arup Guha
// 9/3/2016
// Solution to 2016 UCF Locals Problem: Bouncing Bunnies

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

public class bunnies {

	public static int n;
	public static int[] temp;
	public static int[] humid;

	public static void main(String[] args) throws Exception {

		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		int numCases = Integer.parseInt(stdin.readLine());

		// Process all cases.
		for (int loop=1; loop<=numCases; loop++) {

			// Set up arrays.
			n = Integer.parseInt(stdin.readLine());
			temp = new int[n];
			humid = new int[n];

			// Read in temperatures.
			StringTokenizer tok = new StringTokenizer(stdin.readLine());
			for (int i=0; i<n; i++)
				temp[i] = Integer.parseInt(tok.nextToken());

			// Read in humidities.
			tok = new StringTokenizer(stdin.readLine());
			for (int i=0; i<n; i++)
				humid[i] = Integer.parseInt(tok.nextToken());

			// We care about the sum of each hill's temperature and humidity, so we store that information
			// so that we can access it quick enough.
			HashMap<Integer,Integer> sumMap = new HashMap<Integer,Integer>();
			int[] sumLookup = new int[n];
			int id = 0;
			for (int i=0; i<n; i++) {
				int sum = temp[i] + humid[i];
				if (!sumMap.containsKey(sum))
					sumMap.put(sum, id++);
				sumLookup[i] = sumMap.get(sum);
			}

			// Now, for each sum, we store all the indexes that map to that sum. We index sumList not with the sum
			// itself but our "code" for the sum that is in between 0 and id-1.
			HashSet[] sumLists = new HashSet[sumMap.size()];
			for (int i=0; i<sumMap.size(); i++)
				sumLists[i] = new HashSet<Integer>();
			for (int i=0; i<n; i++)
				sumLists[sumLookup[i]].add(i);

			// We care about the difference of each hill's temperature and humidity, so we store that information
			// so that we can access it quick enough.
			HashMap<Integer,Integer> diffMap = new HashMap<Integer,Integer>();
			int[] diffLookup = new int[n];
			id = 0;
			for (int i=0; i<n; i++) {
				int diff = temp[i] - humid[i];
				if (!diffMap.containsKey(diff))
					diffMap.put(diff, id++);
				diffLookup[i] = diffMap.get(diff);
			}

			// Now, for each difference, we store all the indexes that map to that sum. We index sumList not with the sum
			// itself but our "code" for the sum that is in between 0 and id-1.
			HashSet[] diffLists = new HashSet[diffMap.size()];
			for (int i=0; i<diffMap.size(); i++)
				diffLists[i] = new HashSet<Integer>();
			for (int i=0; i<n; i++)
				diffLists[diffLookup[i]].add(i);

			// Now we can run a BFS that will be fast enough.
			LinkedList<Integer> q = new LinkedList<Integer>();
			q.offer(0);
			int[] dist = new int[n];

			Arrays.fill(dist, -1);
			dist[0] = 0;

			// Typical BFS.
			while (q.size() > 0) {

				// Get the next item and its sum and difference codes.
				int item = q.poll();
				int sumCode = sumLookup[item];
				int diffCode = diffLookup[item];

				// We can now get out.
				if (item == n-1) break;

				// Add in everyone who can be reached from item by adding.
				Iterator<Integer> iter = ((HashSet<Integer>)sumLists[sumCode]).iterator();
				while (iter.hasNext()) {
					int x = iter.next();
					if (dist[x] == -1) {
						dist[x] = dist[item]+1;
						q.offer(x);
					}
				}

				// This is important for run time, so we do go through this whole list again.
				sumLists[sumCode].clear();

				// Add in everyone who can be reached from item by subtracting.
				iter = ((HashSet<Integer>)diffLists[diffCode]).iterator();
				while (iter.hasNext()) {
					int x = iter.next();
					if (dist[x] == -1) {
						dist[x] = dist[item]+1;
						q.offer(x);
					}
				}

				// This is important for run time, so we do go through this whole list again.
				diffLists[diffCode].clear();

			}

			// Ta da!
			System.out.println("Field #"+loop+": "+dist[n-1]+"\n");
		}
	}
}