#include <bits/stdc++.h>   using namespace std;   vector<int> primes;   int prime_marker[1000000];   void PrecomputePrimes() {     const int MAX_PRIME = 1000000;     for (int i = 2; i * i < MAX_PRIME; ++i) {       for (int j = i; i * j < MAX_PRIME; ++j) {         prime_marker[i * j] = 1;       }     }     for (int i = 2; i < MAX_PRIME; ++i) {       if (prime_marker[i]) continue;       primes.push_back(i);     }   }   vector<int64_t> prime_factors;   vector<int> factor_max_power;   void ComputePrimeFactors(int64_t val) {     for (int i = 0; i < primes.size(); ++i) {       if (val % primes[i] == 0) {         prime_factors.push_back(primes[i]);         factor_max_power.push_back(0);         while (val % primes[i] == 0) {           val /= primes[i];           factor_max_power.back()++;         }       }     }     if (val > 1000000) {       prime_factors.push_back(val);       factor_max_power.push_back(1);     }   }   vector<int64_t> arr;   vector<int> cofactor_power;   void ComputeCofactorPower(int64_t val) {     cofactor_power.resize(prime_factors.size());     for (int i = 0; i < prime_factors.size(); ++i) {       cofactor_power[i] = 0;       if (val % prime_factors[i] == 0) {         while (val % prime_factors[i] == 0) {           val /= prime_factors[i];           cofactor_power[i]++;         }       }     }   }   vector<int> basis;   void InitializeBasis() {     basis.resize(prime_factors.size());     basis[0] = 1;     for (int i = 1; i < prime_factors.size(); ++i) {       basis[i] = basis[i - 1] * (factor_max_power[i - 1] + 1);     }   }   void MapToIndices(int hash, vector<int>* indices) {     for (int i = basis.size() - 1; i >= 0; --i) {       (*indices)[i] = hash / basis[i];       hash -= (*indices)[i] * basis[i];     }   }   int IndicesToHash(const vector<int>& indices) {     int hash = 0;     for (int i = 0; i < indices.size(); ++i) {       hash += indices[i] * basis[i];     }     return hash;   }   vector<vector<int>> hash_indices;   void InitHashIndices(int max_hash) {     hash_indices.resize(max_hash, vector<int>(basis.size()));     for (int i = 0; i < max_hash; ++i) {       MapToIndices(i, &hash_indices[i]);     }   }   struct DpState {     int length = 100000;     int64_t cost = 0;     int parent;     bool is_chosen = false;     DpState(int length, int64_t cost, int parent, bool is_chosen)         : length(length), cost(cost), parent(parent), is_chosen(is_chosen) {}     DpState() {}     bool operator<(const DpState& other) const {       if (length == other.length) return cost < other.cost;       return length < other.length;     }   };   DpState dp[1003][7000];   void UpdateDP(int cur, int hash, const vector<int>& indices) {     if (cur == 0) {       if (hash == 0) {         dp[cur][hash] = DpState{0, 0, -1, false};         return;       }       bool is_divisible = true;       for (int i = 0; i < indices.size(); ++i) {         if (indices[i] > cofactor_power[i]) {           is_divisible = false;           break;         }       }       if (is_divisible) {         dp[cur][hash] = DpState{1, arr[cur], -1, true};       }       return;     }     vector<int> prev_indices(indices.size());     for (int i = 0; i < indices.size(); ++i) {       prev_indices[i] = max(0, indices[i] - cofactor_power[i]);     }     int prev_hash = IndicesToHash(prev_indices);     DpState state1 = {dp[cur - 1][prev_hash].length + 1,                       dp[cur - 1][prev_hash].cost + arr[cur], prev_hash, true};     DpState state2 = {dp[cur - 1][hash].length, dp[cur - 1][hash].cost, hash,                       false};     if (state1 < state2) {       dp[cur][hash] = state1;     } else {       dp[cur][hash] = state2;     }   }   int main() {     int n;     int64_t k;     PrecomputePrimes();     scanf( %d , &n);     cin >> k;     int64_t val;     for (int i = 0; i < n; ++i) {       cin >> val;       arr.push_back(val);     }     if (k == 1) {       int lowest_index = 0;       for (int i = 1; i < n; ++i) {         if (arr[i] < arr[lowest_index]) lowest_index = i;       }       printf( 1 n%d n , lowest_index + 1);       return 0;     }     ComputePrimeFactors(k);     InitializeBasis();     int max_hash = basis.back() * (factor_max_power.back() + 1);     InitHashIndices(max_hash);     for (int i = 0; i < n; ++i) {       ComputeCofactorPower(arr[i]);       for (int hash = 0; hash < max_hash; ++hash) {         UpdateDP(i, hash, hash_indices[hash]);       }     }     int cur_hash = max_hash - 1;     if (dp[n - 1][cur_hash].length >= 100000) {       printf( -1 n );       return 0;     }     printf( %d n , dp[n - 1][cur_hash].length);     for (int i = n - 1; i >= 0; --i) {       if (dp[i][cur_hash].is_chosen) {         printf( %d  , i + 1);       }       cur_hash = dp[i][cur_hash].parent;     }     printf(  n );     return 0;   }   