import java.util.*;



public class Voyager {
	public static void main(String[] args){
		String input = "2\n"+
					   "2 3\n" + 
					   "1 1\n"+
					   "8 2\n"+
					   "2 2\n"+
					   "4 4\n"+
					   "7 3\n"+
					   "2 3\n"+
					   "1 1\n"+
					   "8 2\n"+
					   "2 2\n"+
					   "4 4\n"+
					   "7 4\n";
		Scanner s = new Scanner(input);
		int cases = s.nextInt();
		for(int i=0;i<cases;i++){
			int radius = s.nextInt();
			int noOfTowers = s.nextInt();
			//from point
			Coordinate source = new Coordinate( s.nextInt(), s.nextInt());
			//to point
			Coordinate dest = new Coordinate( s.nextInt(), s.nextInt());
			Coordinate[] towers = new Coordinate[noOfTowers];
			for(int t = 0;t<noOfTowers;t++){
				int x = s.nextInt();
				int y = s.nextInt();
				towers[t] = new Coordinate(x,y);
			}
			if(!isDestIn(dest,towers,radius)){
				System.out.println("-1");
			}else{
				process(towers,radius,source,dest);
			}						
		}
	}
	/*
	 * build the graph that represent the towers and their information
	 */
	public static void process(Coordinate[] towers, int radius, Coordinate src, Coordinate dest){
		Map<Integer,Node> tNodes = new HashMap<Integer,Node>();
		// starting point might be in the intersection of two towers
		List<Integer> startingTowers = findStartingPoint(src, towers, radius);
		for(int i=0;i<towers.length;i++){
			Node ni = tNodes.get(i);
			if(!tNodes.containsKey(i)){				
				ni = new Node(i, towers[i],radius); tNodes.put(i,ni);				
			}			
			for(int j=i+1;j<towers.length;j++){
				Node nj = tNodes.get(j);
				if(!tNodes.containsKey(j)){
					nj = new Node(j,towers[j],radius);tNodes.put(j,nj);					
				}				
				if(isDisjointCircles( towers[i],towers[j],radius)) continue;
				Coordinate[] cc =intersection(towers[i],towers[j],radius); 
				for(int k = 0;k<cc.length;k++){
					ni.add(cc[k], j);
					nj.add(cc[k],i);
				}
			}
		}
		for(int t : startingTowers){
			path.clear();
			tPath.clear();
			voyage(src, dest,t, tNodes );
			
		}
		System.out.println(minDist);
	}
	
	static List<Coordinate> path = new ArrayList<Coordinate>();
	// this is extra to tell you which towers we traveled
	static List<Integer> tPath = new ArrayList<Integer>();
	static double distance = Double.MAX_VALUE;
	static double minDist = distance;	
	public static void computeMinimum(){
		double total = 0;
		for(int i=0;i<path.size()-1;i++){
			total+= path.get(i).distance(path.get(i+1));
		}
		if(minDist > total) minDist = total;
	}
	
	public static void voyage(Coordinate src, Coordinate dest,
								int fromTower, Map<Integer,Node> map ){
		voyage(src,dest, map.get(fromTower),map);
	}
	
	
	public static void voyage(Coordinate src, Coordinate dest, 
							Node fromNode, Map<Integer,Node> map ){
		//did I reach my destination?
		if( fromNode.hasPoint(dest)){
			path.add(src);
			path.add(dest);
			computeMinimum();
			//clean up
			if(!tPath.isEmpty()){
				tPath.remove(tPath.size()-1);
				path.remove(path.size()-1);
			}
			return;
		}
		// keep track of the coordinates we have already visited
		path.add( src);
		//keep track of the towers we have already visited
		tPath.add( fromNode.tower);
		//get the list of towers we can travel to
		List<Integer> lstOfTowers = fromNode.getTowers();
		
		for(int i=0;i<lstOfTowers.size();i++){
			int curTower = lstOfTowers.get(i);
			List<Coordinate> lstOfPoints = fromNode.getPoints(curTower);
			for(int j=0;j<lstOfPoints.size();j++){
				Coordinate co = lstOfPoints.get(j);
				//skip any previously visited coordinate
				if(path.indexOf(co) != -1) continue;				
				voyage( co, dest, map.get(curTower),map);
			}
		}
		
	}
	
	/*
	 * @return an array of points for the intersections points 
	 * between towers located at  c1 and c2.
	 * get the formula from some geometry book
	 */
	public static Coordinate[] intersection(Coordinate c1, Coordinate c2, double r){
		// at most there are 2 points of intersections...
		double d = c1.distance(c2);
		double sq = (4 * r * r  - d * d ) * (d * d);
		double xp1 = (c1.x/2 + c2.x/2);
		double xp2 = ((c2.y - c1.y) * Math.sqrt(sq)) / (2 * d * d);
		
		double yp1 = (c1.y/2 + c2.y/2);
		double yp2 = ((c2.x - c1.x) * Math.sqrt(sq)) / (2 * d * d);
		
		Coordinate i1 = new Coordinate( xp1 + xp2, yp1 - yp2);
		Coordinate i2 = new Coordinate( xp1 - xp2, yp1 + yp2);
		int N = 2;
		if( i1.equals(i2)) N = 1;
		Coordinate[] cc = new Coordinate[N];
		cc[0] = i1;
		if(N ==2) cc[1] = i2;
		return cc;
	}
	/*
	 * print the towers coordinates...
	 */
	public static void printTowers(Coordinate[] arr){
		for(Coordinate c : arr){
			System.out.println(c);
		}
	}
	/*
	 * @return true if the dest point is inside any of the tower ranges.
	 * other wise it returns false; 
	 */
	public static boolean isDestIn(Coordinate dest, Coordinate[] towers, int radius){
		for(Coordinate c : towers){
			if( Coordinate.isInCircle(dest,c,radius)) return true;
		}
		return false;
	}
	/*
	 * @return the list of towers that the source point exist in. There might be mor than one
	 * tower in which the starting point exist in.
	 */
	public static List<Integer> findStartingPoint(Coordinate src, Coordinate[] towers, int radius){
		List<Integer> lst = new ArrayList<Integer>();
		for(int i=0;i<towers.length;i++){
			if(towers[i].distance(src) <= radius) lst.add(i);
		}
		return lst;
	}
	
	public static boolean isDisjointCircles(Coordinate c1, Coordinate c2, double r){
		return c2.distance(c1) > 2*r;
	}
}

class Coordinate{
	double x;
	double y;
	Coordinate(double x, double y){
		this.x = x;
		this.y = y;		
	}
	
	public String toString(){
		return "(" + x + "," + y + ")";
	}
	public boolean equals(Object o){
		if(o instanceof Coordinate){
			Coordinate c = (Coordinate) o;
			return c.x ==x && c.y == y;
		}else return false;
	}
	
	public double distance(Coordinate c){
		double dx = c.x - this.x;
		double dy = c.y - this.y;
		return Math.sqrt( dx * dx + dy * dy);
	}
	public static boolean isInCircle(Coordinate xy, Coordinate c, double r){
		return xy.distance(c) <= r;
	}
}
/*
 * class to represent each tower information
 */
class Node{
	Map<Integer,List<Coordinate>> map = 
			new HashMap<Integer,List<Coordinate>>();	
	int  tower ;
	Coordinate center;
	double radius;
	
	public Node(int tower, Coordinate center, double radius){
		this.tower = tower;
		this.center = center;
		this.radius = radius;
	}
	public List<Coordinate> getPoints(int _tower){
		return map.get(_tower);
	}
	
	public List<Integer> getTowers(){
		Iterator<Integer> iter = map.keySet().iterator();
		List<Integer> list = new ArrayList<Integer>();
		while(iter.hasNext()) list.add( iter.next());
		return list;
	}
	
	public void add(Coordinate c, int _tower){
		List<Coordinate> list = map.get(_tower);
		if(list == null){
			list = new ArrayList<Coordinate>();
		}
		if(list.indexOf(c) == -1){
			list.add( c);
		}
		map.put(_tower,list);
	}
	
	//public List<Coordinate> getList(){ return lst;}
	public String toString(){
		return " tower " + tower + " lst:" + map;
	}
	public boolean equals(Object o){
		Node n = (Node) o;
		return n.tower == tower;
	}
	public int hashCode(){
		return tower;
	}
	public boolean hasPoint(Coordinate p){
		return Coordinate.isInCircle(p, center, radius);
	}
}