Mr. Kitayuta has just bought an undirected graph with n vertices and m edges. The vertices of the graph are numbered from 1 to n. Each edge, namely edge i, has a color ci, connecting vertex ai and bi.

Mr. Kitayuta wants you to process the following q queries.

In the i-th query, he gives you two integers - ui and vi.

Find the number of the colors that satisfy the following condition: the edges of that color connect vertex ui and vertex vi directly or indirectly.

Input

The first line of the input contains space-separated two integers - n and m(2 ≤ n ≤ 105, 1 ≤ m ≤ 105), denoting the number of the vertices and the number of the edges, respectively.

The next m lines contain space-separated three integers - ai, bi(1 ≤ ai < bi ≤ n) and ci(1 ≤ ci ≤ m). Note that there can be multiple edges between two vertices. However, there are no multiple edges of the same color between two vertices, that is, if i ≠ j, (ai, bi, ci) ≠ (aj, bj, cj).

The next line contains a integer- q(1 ≤ q ≤ 105), denoting the number of the queries.

Then follows q lines, containing space-separated two integers - ui and vi(1 ≤ ui, vi ≤ n). It is guaranteed that ui ≠ vi.

Output

For each query, print the answer in a separate line.

Examples

Input

4 5
1 2 1
1 2 2
2 3 1
2 3 3
2 4 3
3
1 2
3 4
1 4


Output

2
1
0


Input

5 7
1 5 1
2 5 1
3 5 1
4 5 1
1 2 2
2 3 2
3 4 2
5
1 5
5 1
2 5
1 5
1 4


Output

1
1
1
1
2

Note

Let's consider the first sample. 

<image> The figure above shows the first sample. 

  * Vertex 1 and vertex 2 are connected by color 1 and 2. 
  * Vertex 3 and vertex 4 are connected by color 3. 
  * Vertex 1 and vertex 4 are not connected by any single color. 


import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;



	
	
public class Solution  {
	
	static class FastScanner{
		BufferedReader s;
		StringTokenizer st;
		
		
		public FastScanner(){
			st = new StringTokenizer("");
			s = new BufferedReader(new InputStreamReader(System.in));
		}
		
		public FastScanner(File f) throws FileNotFoundException{
			st = new StringTokenizer("");
			s = new BufferedReader (new FileReader(f));
		}
		
		public int nextInt() throws IOException{
			if(st.hasMoreTokens())
				return Integer.parseInt(st.nextToken());
			else{
				st = new StringTokenizer(s.readLine());
				return nextInt();
			}
		}
		
		public double nextDouble() throws IOException{
			if(st.hasMoreTokens())
				return Double.parseDouble(st.nextToken());
			else{
				st = new StringTokenizer(s.readLine());
				return nextDouble();
			}
		}
		
		public long nextLong() throws IOException{
			if(st.hasMoreTokens())
				return Long.parseLong(st.nextToken());
			else{
				st = new StringTokenizer(s.readLine());
				return nextLong();
			}
		}
		
		public String nextString() throws IOException{
			if(st.hasMoreTokens())
				return st.nextToken();
			else{
				st = new StringTokenizer(s.readLine());
				return nextString();
			}
			
		}
		public String readLine() throws IOException{
			return s.readLine();
		}
		
		public void close() throws IOException{
			s.close();
		}
		
	}
	
	
	
	
	//FastScanner s = new FastScanner(new File("input.txt"));       copy inside void solve
    //PrintWriter ww = new PrintWriter(new FileWriter("output.txt"));
    static FastScanner s = new FastScanner();   
    static PrintWriter ww = new PrintWriter(new OutputStreamWriter(System.out));
	
    public static void main(String args[])throws IOException{
    	//Main ob=new Main();
    	Solution ob=new Solution();
		ob.solve();
			ww.close();
    }
    ///////////////////////////////////
static class UF{
		
	    private int[] id;    
	    private byte[] rank;  
	    public UF(int N) {
	        id = new int[N];
	        rank = new byte[N];
	        for (int i = 0; i < N; i++) {
	            id[i] = i;
	            rank[i] = 1;
	        }
	    }

	    public int find(int p) {
	        while (p != id[p]) {
	            id[p] = id[id[p]];    // path compression by halving
	            p = id[p];
	        }
	        return p;
	    }

	    public boolean connected(int p, int q) {
	        return find(p) == find(q);
	    }


	    public void union(int p, int q) {
	        int i = find(p);
	        int j = find(q);
	        if (i == j) return;

	        // make root of smaller rank point to root of larger rank
	        if(rank[i] > rank[j]){
	        	rank[i]+=rank[j];
	        	id[j]=i;
	        }
	        
	        else{
	        	rank[j]+=rank[i];
	        	id[i]=j;
	        }
	        
	        
	    }
	    
}
       
     
    //////////////////////////////
	
   
    void solve() throws IOException{
    	int n=s.nextInt();
    	int m=s.nextInt();
    	
    	UF ob[]=new UF[m+1];
    	for(int i=0;i<=m;i++){
    		ob[i]=new UF(n+1);
    	}
    	
    	for(int i=0;i<m;i++){
    		int a=s.nextInt();
    		int b=s.nextInt();
    		int c=s.nextInt();
    		ob[c].union(a, b);
    	}
    	int q=s.nextInt();
    	for(int i=0;i<q;i++){
    		int a=s.nextInt();
    		int b=s.nextInt();
    		int cnt=0;
    		for(int j=1;j<=m;j++){
    			if(ob[j].connected(a, b))
    				cnt++;
    		}
    		ww.println(cnt);
    	}
    	    
    
    	
    	
    	
    			
    	
 
    		
    } //solve
    
}