T = int(input())
for _ in range(T):
    N = int(input())
    ans = []
    for factor in range(9, 1, -1):
        while N % factor == 0:
            N //= factor
            ans.append(str(factor))
    if N == 1 and ans:
        print(''.join(ans[::-1]))
    elif N == 1:
        print(1)
    else:
        print(-1)

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        int N;
        scanf("%d", &N);
        string ans;
        for (int factor=9; factor>1; factor--) {
            while (N % factor == 0) {
                N /= factor;
                ans += '0' + factor;
            }
        }
        reverse(ans.begin(), ans.end());
        if (N == 1 && ans.length())
            cout << ans << endl;
        else if (N==1)
            cout << 1 << endl;
        else
            cout << -1 << endl;
    }
    return 0;
}

g.sort()
s.sort()
ans = 0
while s and g:
  if s[-1] >= g[-1]:
    ans += 1
    del g[-1], s[-1]
  else:
    del g[-1]
return ans

g.sort(reverse=True)
s.sort(reverse=True)
ans = 0
while s and g:
  if s[-1] >= g[-1]:
    ans += 1
    del g[-1], s[-1]
  else:
    del s[-1]
return ans

sort(g.begin(), g.end());
sort(s.begin(), s.end());
int ans = 0;
while (!s.empty() && !g.empty()) {
  if (s.back() >= g.back()) {
    ans += 1;
    s.pop_back(), g.pop_back();
  } else {
    g.pop_back();
  }
}
return ans;

sort(g.begin(), g.end(), greater<int>());
sort(s.begin(), s.end(), greater<int>());
int ans = 0;
while (!s.empty() && !g.empty()) {
  if (s.back() >= g.back()) {
    ans += 1;
    s.pop_back(), g.pop_back();
  } else {
    s.pop_back();
  }
}
return ans;

while True:
  n = int(input())
  if n == 0:
    break
  V = [] 
  for _ in range(n):
    C, E = map(int, input().split())
    V.append((E, C))
  V.sort(reverse=True)
  now_time, ans = 0, 0
  for E, C in V:
    now_time += C
    ans = max(ans, now_time + E)
  print(ans)

intervals.sort(key = lambda a: a[1])
cur_r = -float('inf')
ans = 0
for l, r in intervals:
  if cur_r <= l:
    cur_r = r
    ans += 1
return len(intervals) - ans

sort(intervals.begin(), intervals.end(), 
     [](auto &a, auto &b) {
       return a[1] < b[1];
     });
int current_end = -50000, chosen = 0;
for (auto &interval : intervals) {
  if (current_end <= interval[0]) {
    current_end = interval[1];
    chosen ++;
  }
}
return intervals.size() - chosen;

from queue import PriorityQueue
while True:
    n = int(input())
    if n == 0:
        break
    Q = PriorityQueue()
    for v in map(int, input().split()):
        Q.put(v)

    cost = 0
    while Q.qsize() > 1:
        A, B = Q.get(), Q.get()
        cost += A+B
        Q.put(A+B)
    print(cost)

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n, x;
    while (cin>>n && n != 0) {
        priority_queue<long long> Q;
        while(n--) {
            cin>>x;
            Q.push(-x);
        }
        long long ans=0, A, B;
        while (Q.size() != 1) {
            A = -Q.top(); Q.pop();
            B = -Q.top(); Q.pop();
            ans += A + B;
            Q.push(-(A + B));
        }
        cout << ans << endl;
    }
}

import heapq
while True:
    n = int(input())
    if n == 0:
        break
    Q = list(map(int, input().split()))
    heapq.heapify(Q)

    cost = 0
    while len(Q) > 1:
        A, B = heapq.heappop(Q), heapq.heappop(Q)
        cost += A+B
        heapq.heappush(Q, A+B)
    print(cost)

priority_queue<int> Q;
stations.push_back(vector<int> {target, 0});
sort(stations.begin(), stations.end());
int reach = startFuel, used = 0;
for (auto station : stations) {
  // 如果走不到下個加油站，
  // 就從後悔清單拿到可以走到為止
  while (!Q.empty() && reach < station[0]) {
    reach += Q.top();
    used += 1;
    Q.pop();
  }
  // 已經到達target或者到不了下個加油站，結束。
  if (reach >= target || reach < station[0])
    break;
  Q.push(station[1]);
}
return reach >= target ? used : -1;

reach, used = startFuel, 0
stations.append([target, 0])
stations.sort()
# Heapq is min heap by default. 
# We need *-1 to negate values.
Q = []
for position, fuel in stations:
  # 如果走不到下個加油站，
  # 就從後悔清單拿到可以走到為止
  while Q and reach < position:
    reach += -heapq.heappop(Q)
    used += 1
    # 已經到達target或者到不了下個加油站，結束。
    if reach >= target or reach < position:
      break
    heapq.heappush(Q, -fuel)
return used if reach >= target else -1

TODO

#include <stdio.h>
#include <algorithm>
int ary[50001], n, k;
bool is_ok(int x){
    int last = -x-1, now_put = 0;  
    for(int i=0; i<n; i++){
        if(last + x < ary[i]){
            now_put ++;
            last = ary[i];
            if(now_put > k){
                return false;
            }
        }
    }
    return true;
}
int main(){
    scanf("%d%d", &n, &k);
    for(int i=0; i<n; i++)
        scanf("%d", &ary[i]);
    std::sort(ary, ary+n);
    int L=0, R=1000000000;
    while(R-L != 1){
        int mid = (L+R) / 2;
        if(is_ok(mid))
            R = mid;
        else
            L = mid;
    }
    printf("%d\n", R);
    return 0;
}

struct SegTree {
    // min number, it's index
    pair<int, int> min_info;
    SegTree *L, *R;
    SegTree(SegTree *L, SegTree *R, pair<int, int> min_info={INT_MAX, -1}):
        L(L), R(R), min_info(min_info){} 
    void pull() {
        min_info = min(L->min_info, R->min_info);
    }
};

SegTree* build(int L, int R, vector<int>& A) {
    // [l, r]
    if (L == R)
        return new SegTree(NULL, NULL, {A[L], L});
    int M = (L + R) / 2;
    SegTree *now = new SegTree(build(L, M, A), build(M+1, R, A));
    now->pull();
    return now;
}

pair<int, int> query(SegTree* root, int L, int R, int x, int y) {
    if (R < x || y < L) return {INT_MAX, -1};
    if (x <= L && R <= y) return root->min_info;
    int M = (L + R) / 2;
    return min(query(root->L, L, M, x, y), query(root->R, M+1, R, x, y));
}

class Solution {
public:
    int dc(SegTree *root, int x, int y, int N) {
        auto [min_v, min_idx] = query(root, 0, N-1, x, y);
        if (min_idx == -1)
            return INT_MIN;
        return max({
            (y - x + 1) * min_v,
            dc(root, x, min_idx-1, N),
            dc(root, min_idx+1, y, N)
        });
    }
    int largestRectangleArea(vector<int>& heights) {
        // Special Case:
        bool flag = true;
        for (auto h: heights)
            if (h != heights[0]) {
                flag = false;
                break;
            }
        if (flag)
            return heights[0] * heights.size();
        SegTree *root = build(0, heights.size()-1, heights);
        return dc(root, 0, heights.size()-1, heights.size());
    }
};

vector<pair<int, int>> order;
for (int i = 0; i < heights.size(); i++) {
	order.push_back({heights[i], i});
}
sort(order.begin(), order.end());
int ans = 0;
set<pair<int, int>> intervals{{0, heights.size()}};
for (auto &[height, idx] : order) {
  auto it = --intervals.lower_bound({idx, INT_MAX});
  ans = max(ans, height * (it->second - it->first));
  intervals.insert({it->first, idx});
  intervals.insert({idx+1, it->second});
  intervals.erase(it);
}
return ans;

struct node {
  node *prev, *next;
  int h, w;
  node(int h, int w): 
    h(h), w(w), prev(NULL), next(NULL) {}
  int merge(set<node *> &deleted) {
    // left
    while (prev && h <= prev->h) {
      w += prev->w;
      node *tmp = prev;
      if (prev->prev)
        prev->prev->next = this;
      prev = prev->prev;
      deleted.insert(tmp);
      delete tmp;
    }
    // right
    while (next && h <= next->h) {
      w += next->w;
      node *tmp = next;
      if (next->next)
        next->next->prev = this;
      next = next->next;
      deleted.insert(tmp);
      delete tmp;
    }
    return w * h;
  }
};

vector<pair<int, node *>> order;
for (int i = 0; i < heights.size(); i++) {
  node *cur = new node(heights[i], 1);
  if (i) {
    order.back().second->next = cur;
    cur->prev = order.back().second;
  }
  order.push_back({heights[i], cur});
}
sort(order.begin(), order.end());
reverse(order.begin(), order.end());
int ans = 0;
set<node *> deleted;
for (auto &[h, cur] : order) {
  if (deleted.find(cur) == deleted.end()) {
    ans = max(ans, cur->merge(deleted));
  }
}
return ans;

TODO

TODO

boss = [i for i in range(len(nums))]
size = [1 for _ in nums]
ans = 0
def find_boss(i):
	if boss[i] != i:
		boss[i] = find_boss(boss[i])
	return boss[i]
def merge(i, j):
	i, j = find_boss(i), find_boss(j)
	if i != j:
	if nums[i] > nums[j]:
		i, j = j, i
	boss[j] = i
	size[i] += size[j]

ary = sorted([(num, i) for i, num in enumerate(nums)]

for num, i in reversed(ary):
	if i > 0 and nums[i-1] >= nums[i]:
		merge(i-1, i)
	if i+1 < len(nums) and nums[i+1] >= nums[i]:
		merge(i, i+1)
	I = find_boss(i)
	ans = max(ans, nums[I] * size[I])
return ans

// Terminate all
heights.push_back(0);
deque<pair<int, int>> Q;
int ans = 0;
for (int i = 0; i < heights.size(); i++) {
  // Pop
  pair<int, int> cur{heights[i], i};
  while (!Q.empty() && Q.back() > cur) {
    ans = max(ans, Q.back().first * (i - Q.back().second));
    cur.second = Q.back().second;
    Q.pop_back();
  }
  Q.push_back(cur);
}
return ans;

nums.append(0)
q = deque()
ans = 0
for i, height in enumerate(nums):
  cur = [height, i]
  while q and q[-1] > cur:
    ans = max(ans, q[-1][0] * (i-q[-1][1]))
    cur[1] = q[-1][1]
    q.pop()
    q.append(cur)
return ans