#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<cassert>
#include<string>
#include<vector>
#include<algorithm>
#include<ctime>

using namespace std;
#define MEM(a,b) memset(a,(b),sizeof(a))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define MIN(a,b)  ((a) < (b) ? (a) : (b))
#define MP make_pair
#define pb push_back
#define maxo 1000
#define maxb 16
#define maxt 5
typedef  long long  LL;
typedef pair<LL,LL> pl;
typedef pair<LL,int> pli;
typedef pair<int,int> pi;
typedef vector<int> vi;


unsigned long long pw[105][100];

inline LL getmask(LL x) { return ((LL)1<<x); }
inline int  VAL(LL n,int b,int x) { return (n/pw[b][x])%b ; }

LL maxv=getmask(60);

inline int getDigits(LL n,int b)
{
    int ret=0;
    while(pw[b][ret]-1<n) ++ret;
    return ret;
}
inline int isPal(LL s,int b,int l)
{
    for(int i=0;i<l/2;i++) if(VAL(s,b,i)!=VAL(s,b,l-1-i)) return 0;
    return 1;
}
struct node
{
    vector< pair< int,int > > next;
};

class PalindromeBases
{
public:
   int b1,b2,maxPow[100];
   vector<LL> A,B,ans;
   vector<node> TA,TB;

    void init()
    {
       for(int i=2,j;i<=maxb;i++)
       {
           pw[i][0] =  1;
           for(j=1;pw[i][j-1]<maxv/i;j++) pw[i][j]=(pw[i][j-1]*i);
           maxPow[i]=j-1;
           pw[i][j]=(pw[i][j-1]*i);
       }
    }

    vector<LL> solve(int _b1,int _b2)
    {
        ans.clear();
        b1=_b1;b2=_b2;
        for(int l1=3;;l1++)
        {
            int d=(l1+3)/4,e=(l1-d*2+1)/2; //d = length of 1st and 4th part, e=length of 2nd and 3rd part

            A.clear(); gen(0,d,l1-1,0,A,0); // generate b1 palindromes considering 1st and 4th part
            B.clear(); gen(0,e,l1-1-d,d,B,0); // generate b1 palindromes considering 2nd and 3rd part

            if(A.empty() || B.empty()) break;

            sort(A.begin(),A.end());
            sort(B.begin(),B.end());

			// get possible length ranges when b1 palindrome has length=l1
            LL minu=A[0]+B[0];
            LL maxu=min(maxv,A[A.size()-1]+B[B.size()-1]);
            int l2min = getDigits(minu,b2);
            int l2max = getDigits(maxu,b2);

            for(int l2=l2min;l2<=l2max;l2++)
            {
				 // compute the trie with prefix,suffix info from the 2sets of palindromes
                calcPart(l2,A,TA);
                calcPart(l2,B,TB);
                solve(0,0,0,0,0,l2,0,0);
            }
            if((int)ans.size()>=maxo) break;  // already got 1000 first palindromes
        }

        for(int i=1;i<pw[b1][2];i++) // generate the palindromes less b1^2 by simple BF
        {
            if(isPal(i,b1,getDigits(i,b1)) &&
               isPal(i,b2,getDigits(i,b2))) ans.pb(i);
        }
        sort(ans.begin(),ans.end());
        return ans;
    }

	// compute the Trie from the b1 numbers from A, store the Trie in nodes,
    // the nodes in the Trie corresponds to a valid number with a particular prefix,suffix in base b2 and should be in A
    // the edges of the Trie corresponds to a pair of digits, that makes the next prefix,suffix
    void calcPart(int l,vector<LL> &A,vector<node> &nodes)
    {
        nodes.clear();
        nodes.pb(node());

        for(int i=0;i<A.size();i++)
        {
            LL x=A[i];
			LL y=0; // the current prefix,suffix part of the number
            int now=0; // the current node in Trie
            if(x>pw[b2][l]-1) break;

            for(int j=0;j<=l/2;j++)
            {
                if(j==l/2 && !(l&1)) continue;
                int a=VAL(x,b2,l-1-j),b=VAL(x,b2,j); // get the digits in b2

                y += pw[b2][l-1-j]*a; // add from left part
                if( j != l-1-j) y += pw[b2][j]*b; // add from right part

                int dig=a*b2+b,next=-1;

                for(int k=0;k<nodes[now].next.size() && next<0;k++) // check if the edge already exists in Trie
                    if(nodes[now].next[k].first==dig) next=nodes[now].next[k].second;
                if(next<0) // edge does not exist, so make a new edge and node
                {
                    next=nodes.size();
                    nodes.pb(node());
                    nodes[now].next.pb(MP(dig,next));
                }
                now=next;
            }
        }
    }


    void solve(int pos,LL num1,LL num2,int cfw,int cback,int l,int node1,int node2)
    {
        if(pos==(l+1)/2)
        {
            if(cfw==cback) ans.pb(num1+num2);
            return;
        }
		// a....b
        // c....d
        // e....e
        for(int j=0;j<TA[node1].next.size();j++)
            for(int k=0;k<TB[node2].next.size();k++)
        {

            int a=TA[node1].next[j].first/b2,b=TA[node1].next[j].first%b2;
            int c=TB[node2].next[k].first/b2,d=TB[node2].next[k].first%b2;

            int next1 = TA[node1].next[j].second;
            int next2 = TB[node2].next[k].second;

            if(pos==l/2 && l%2)
            {
                if((a+c+cback)/b2==cfw)
                     solve(pos+1,num1+pw[b2][pos]*a,num2+pw[b2][pos]*c,0,0,l,next1,next2);
                continue;
            }
            LL nnum1 = num1 + pw[b2][l-1-pos]*a + pw[b2][pos]*b;
            LL nnum2 = num2 + pw[b2][l-1-pos]*c + pw[b2][pos]*d;

            int e=(b+d+cback)%b2;
            int ncfw= (a+c)%b2==e ? 0 : (a+c+1)%b2==e ? 1 : -1;
            int dig = TB[node2].next[k].first;

            if(ncfw==-1 ) continue;
            if(!pos && !e) continue;
            if((a+c+ncfw)/b2==cfw)
                solve(pos+1,nnum1,nnum2,ncfw,(b+d+cback)/b2,l,next1,next2);
        }
    }

	// generates the palindromes in base b1 and store in the list A, pl = length
    // leftOffset and rightOffset is used to denote the part(total 4) of the palindrome
    void gen(int pos,int pl,int leftOffset,int rightOffset,vector<LL> &A,LL x)
    {

        if(pos==pl)
        {
            if(x) A.push_back(x);
            if(rightOffset==0 && isPal(x,b2,getDigits(x,b2)))
                ans.pb(x);
            return;
        }
        int l=leftOffset-pos,r=rightOffset+pos;

        for(int i=0;i<b1;i++)
        {
            if(!i && !pos && !rightOffset) continue;
            if(i && (l>maxPow[b1] || pw[b1][l]>maxv/i) ) return;
            LL nx= x + pw[b1][l]*i;
            if(l!=r) nx += pw[b1][r]*i;
            if(nx>maxv) break;
            gen(pos+1,pl,leftOffset,rightOffset,A,nx);
        }
    }
};

PalindromeBases pal;

int main()
{
	int T,b1,b2;

    pal.init();

	cin>>T;
	assert(T>=1 && T<=maxt);

	while(T--)
    {
        cin>>b1>>b2;
        assert(2<=b1  && b1<b2 && b2<=maxb);
        vector<LL> res = pal.solve(b1,b2);
        for(int i=0;i<MIN(res.size(),maxo);i++)
        {
            if(i) printf(" ");
            printf("%lld",res[i]);
        }
        printf("\n");
     }
	return 0;
}