// Alex Coleman
// 2/21/2017
// Solution to 2017 FHSPS Playoff Questions: Counting, Just

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class counting_coleman {
	
	// Necessary constants.
	static final long MOD = (long) 1e9 + 7;
	static final int P_COUNT = 25;

	static long[] divs, rev;
	static long[][] memo;
	static int[][] divdivs;

	public static void main(String[] args) {
		
		Scanner in = new Scanner(System.in);
		int T = in.nextInt();
		
		// Process all cases.
		while (T-- > 0) {
			
			// Get input.
			long n = in.nextLong();

			// Make list of divisors of n.
			ArrayList<Long> dlist = new ArrayList<>();
			for (long i = 1; i * i <= n; i++) {
				if (n % i == 0) {
					dlist.add(i);
					if (i * i != n) {
						dlist.add(n / i);
					}
				}
			}

			// Store and store into an array.
			Collections.sort(dlist);
			divs = new long[dlist.size()];
			for (int i = 0; i < dlist.size(); i++)
				divs[i] = dlist.get(i);

			// Store divisors of divisors here.
			divdivs = new int[divs.length][];
			
			// Do this in a straight forward manner - run time is fast.
			for (int i = 0; i < divs.length; i++) {
				ArrayList<Integer> list = new ArrayList<>();
				long v1 = divs[i];
				for (int j = 0; j <= i; j++) {
					long v2 = divs[j];
					if (v1 % v2 == 0) {
						list.add(j);
					}
				}
				divdivs[i] = new int[list.size()];
				for (int j = 0; j < list.size(); j++)
					divdivs[i][j] = list.get(j);
			}

			// Set up the memo table and solve.
			memo = new long[P_COUNT][dlist.size()];
			for (long[] arr : memo)
				Arrays.fill(arr, -1);
			long ans = solve(dlist.size() - 1, 0);
			System.out.println(ans);
		}
	}

	static long solve(int div, int primeIdx) {
		
		// Filled up a solution, return 1 if valid, 0 otherwise.
		if (primeIdx == P_COUNT) {
			if (div == 0)
				return 1;
			return 0;
		}
		
		// Solved this case before.
		if (memo[primeIdx][div] != -1)
			return memo[primeIdx][div];
			
		// Try each possible divisor in the current slot.
		long ans = 0;
		for (int d : divdivs[div]) {
			ans += solve(d, primeIdx + 1);
		}
		
		// Mod store and return.
		ans %= MOD;
		return memo[primeIdx][div] = ans;
	}
}