class DisjointSetUnion {
public:
    void initialize(int numberOfElements) {
        parent.resize(numberOfElements);
        for (int i = 0; i < numberOfElements; ++i)
            parent[i] = i;
    }

    int findRoot(int element) {
        if (parent[element] != element)
            parent[element] = findRoot(parent[element]);
        return parent[element];
    }

    void unite(int element1, int element2) {
        int root1 = findRoot(element1);
        int root2 = findRoot(element2);
        if (root1 != root2)
            parent[root1] = root2;
    }

private:
    vector<int> parent;
};

string solve(vector<string>& words) {
    int wordCount = words.size();

    DisjointSetUnion dsu;
    dsu.initialize(26);
    vector<int> inDegrees(26, 0);
    vector<int> outDegrees(26, 0);
    vector<bool> isConnected(26, false);

    string result;
    for (int k = 0; k < wordCount; ++k) {
        int start = words[k][0] - 'a';
        int end = words[k].back() - 'a';
        outDegrees[start]++;
        inDegrees[end]++;
        dsu.unite(start, end);
        isConnected[start] = isConnected[end] = true;

        int root = dsu.findRoot(start);
        unordered_set<int> roots;
        for (int i = 0; i < 26; ++i) {
            if (isConnected[i] && (inDegrees[i] > 0 || outDegrees[i] > 0))
                roots.insert(dsu.findRoot(i));
        }

        if (roots.size() > 1) {
            result.push_back('0');
            continue;
        }

        vector<int> differences;
        for (int i = 0; i < 26; ++i) {
            if (isConnected[i] && (inDegrees[i] > 0 || outDegrees[i] > 0))
                differences.push_back(outDegrees[i] - inDegrees[i]);
        }

        if (!differences.empty()) {
            int maxDifference = *max_element(differences.begin(), differences.end());
            int minDifference = *min_element(differences.begin(), differences.end());
            if (!((maxDifference == 0 && minDifference == 0) || (maxDifference == 1 && minDifference == -1 && count(differences.begin(), differences.end(), 1) == 1 && count(differences.begin(), differences.end(), -1) == 1))) {
                result.push_back('0');
                continue;
            }
        }

        result.push_back('1');
    }

    return result;
}

int countGoodSubsets(std::vector<int>& numbers) {
    int maskArray[31] = {-1, 0, 1, 2, -1, 4, 3, 8, -1, -1, 5, 16, -1, 32, 9, 6, -1, 64, -1, 128, -1, 10, 17, 256, -1, -1, 33, -1, -1, 512, 7 };
    int dp[1025] = {1}, count[31] = {};
    
    for (int i = 0; i < numbers.size(); ++i)
        ++count[numbers[i]];
    
    for (int i = 2; i <= 30; ++i) {
        if (maskArray[i] > -1) {
            for (int mi = maskArray[i], mj = 0; mj < 1024; ++mj) {
                if ((mi & mj) == 0) {
                    dp[mi | mj] = (dp[mi | mj] + (long long)count[i] * dp[mj]) % 1000000007;
                }
            }
        }
    }
    
    int result = std::accumulate(begin(dp) + 1, end(dp), 0, [](int sum, int num) { return (sum + num) % 1000000007; });
    
    while (--count[1] >= 0)
        result = (result << 1) % 1000000007;
    
    return result;
}

#include <bits/stdc++.h>
using namespace std;

int main() {
    int num_items, num_groups;
    cin >> num_items >> num_groups;

    vector<int> items(num_items);
    for (int i = 0; i < num_items; ++i) {
        cin >> items[i];
    }

    vector<int> group_sizes(num_groups);
    for (int i = 0; i < num_groups; ++i) {
        cin >> group_sizes[i];
    }

    sort(items.rbegin(), items.rend());

    int max_profit = 0;
    int idx = 0;
    for (int i = 0; i < num_groups; ++i) {
        int group_size = group_sizes[i];
        while (idx < num_items && group_size > 0) {
            max_profit += items[idx];
            idx++;
            group_size--;
        }
    }

    cout << max_profit << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int main()
{
    int numElements;
    cin >> numElements;
    vector<int64_t> minCost(numElements + 2, 0x3f3f3f3f3f3f3f3f);
    minCost[0] = 0;
    vector<int> range(numElements + 2), elementCost(numElements + 2);

    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> range[i];
    }
    for (int i = 1; i <= numElements + 1; i++)
    {
        cin >> elementCost[i];
    }

    for (int i = 1; i <= numElements + 1; i++)
    {
        if (range[i] == 0)
            continue;

        int nextIdx = min(i + range[i], numElements + 1);
        int prevIdx = max(i - range[i] - 1, 0);
        int64_t prevElementCost = elementCost[prevIdx];
        for (int j = prevIdx + 1; j <= nextIdx; j++)
        {
            minCost[j] = min(minCost[j], minCost[prevIdx] + elementCost[i]);
        }
    }

    cout << ((minCost[numElements + 1] < 0x3f3f3f3f3f3f3f3f) ? minCost[numElements + 1] : -1) << "\n";
}

#include <iostream>
using namespace std;

int findMaximum(int a, int b)
{
    return a > b ? a : b;
}

int findMinimum(int a, int b)
{
    return a < b ? a : b;
}

int main()
{
    int numRows, numCols;
    cin >> numRows >> numCols;

    int maximumValue = -0x3f3f3f3f;
    int result = -0x3f3f3f3f;
    for (int i = 0; i < numRows; i++)
    {
        for (int j = 0; j < numCols; j++)
        {
            int cellValue;
            cin >> cellValue;
            int currentDifference = maximumValue - cellValue;
            result = findMaximum(result, currentDifference);
            maximumValue = findMaximum(maximumValue, cellValue);
        }
    }
    cout << result << "\n";
}

#include <iostream>
#include <string>
using namespace std;

int main()
{
    int numElements;
    cin >> numElements;
    char prevChar, currentChar;
    cin >> currentChar;
    string result;

    for (int i = 2; i <= numElements; i++)
    {
        prevChar = currentChar;
        cin >> currentChar;
        if (currentChar == '*')
        {
            continue;
        }
        if (currentChar == '_' || currentChar == 'D')
        {
            if (prevChar == '*')
            {
                result.push_back('J');
            }
            else
            {
                result.push_back('W');
            }
        }
    }
    if (numElements == 1)
    {
        result = 'W';
    }
    cout << result << endl;
}

#include <bits/stdc++.h>
using namespace std;

using pii = pair<int, int>;
#define ll long long
#define test_cases  \
    int t;           \
    cin >> t;        \
    while (t--)
#define read_array              \
    int arr[n];                 \
    for (int i = 0; i < n; i++) \
    cin >> arr[i]

bool comparePair(pii p1, pii p2)
{
    if (p1.first < p2.first)
        return false;
    else if (p1.first > p2.first)
        return true;
    return p1.second < p2.second;
}

void findSolution()
{
    int numElements;
    cin >> numElements;
    int k;
    cin >> k;
    read_array;
    for (int i = 0; i < numElements; i++)
        arr[i] %= k;
    vector<int> ans;
    for (int i = 0; i < numElements; i++)
        if (arr[i] == 0)
            ans.push_back(i + 1);
    vector<pii> v(numElements);
    for (int i = 0; i < numElements; i++)
        v[i].first = arr[i], v[i].second = i + 1;
    sort(v.begin(), v.end(), comparePair);
    for (auto i : v)
        if (i.first != 0)
            ans.push_back(i.second);
    for (int k : ans)
        cout << k << ' ';
    cout << endl;
}

signed main()
{
    test_cases
    findSolution();
    return 0;
}

#include <iostream>
#include <vector>
using namespace std;

int calculateMaxRewards(int numDays, vector<int>& rewardValues, vector<int>& rewardReductions, vector<int>& rewardDays) {
    vector<int> maxRewards(numDays + 1, 0);

    for (int i = 1; i <= numDays; ++i) {
        maxRewards[i] = rewardValues[i - 1];
        for (int j = 1; j < i; ++j) {
            int remainingDays = rewardDays[i - j - 1] - (i - j);
            if (remainingDays > 0) {
                maxRewards[i] = max(maxRewards[i], maxRewards[j] + rewardValues[i - 1] - rewardReductions[i - 1] * remainingDays);
            }
        }
    }

    int overallMaxReward = 0;
    for (int i = 1; i <= numDays; ++i) {
        overallMaxReward = max(overallMaxReward, maxRewards[i]);
    }

    return overallMaxReward;
}

int main() {
    int numDays;
    cin >> numDays;

    vector<int> rewardValues(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardValues[i];
    }

    vector<int> rewardReductions(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardReductions[i];
    }

    vector<int> rewardDays(numDays);
    for (int i = 0; i < numDays; ++i) {
        cin >> rewardDays[i];
    }

    int maxReward = calculateMaxRewards(numDays, rewardValues, rewardReductions, rewardDays);
    cout << maxReward << endl;

    return 0;
}

unordered_map<string, int> memo;

int minCost(const vector<int>& lst, int x, int y, int pos, int curr, int count) {
    int minm = INT_MAX;
    string key = to_string(pos) + "|" + to_string(count);

    if (memo.find(key) != memo.end()) {
        return memo[key];
    }

    if (pos >= lst.size() && count == 0) {
        return curr;
    }

    if (pos >= lst.size()) {
        return minm;
    }

    if (count == 0) {
        return curr;
    }

    int c = minCost(lst, x, y, pos + y, lst[pos] + curr, count - 1);
    int s = minCost(lst, x, y, pos + 1, 0, x);
    minm = min(minm, min(c, s));
    memo[key] = minm;
    return minm;
}

int minRehabCost(const vector<int>& lst, int x, int y) {
    memo.clear();
    return minCost(lst, x, y, 0, 0, x);
} 

int solution(int N, vector<int>& A, vector<int>& B) {
    vector<vector<int>> graph(N);
    vector<int> edgesCount(N, 0);

    for (int i = 0; i < A.size(); i++) {
        edgesCount[A[i]]++;
        edgesCount[B[i]]++;
        graph[A[i]].push_back(B[i]);
        graph[B[i]].push_back(A[i]);
    }

    queue<int> q;
    for (int i = 0; i < N; i++) {
        if (edgesCount[i] <= 1) {
            q.push(i);
        }
    }

    int seconds = 0;
    while (!q.empty()) {
        int size = q.size();
        while (size > 0) {
            int vertex = q.front();
            q.pop();
            for (int neighbor : graph[vertex]) {
                if (edgesCount[neighbor] > 0) {
                    edgesCount[neighbor]--;
                    if (edgesCount[neighbor] == 1) {
                        q.push(neighbor);
                    }
                }
            }
            edgesCount[vertex] = 0;
            size--;
        }
        seconds++;
    }

    return seconds;
}