p160.ans1
======================
4
1 4

=================
p160.ans2
======================
1


=================
p160.cpp
======================
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
}

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
}

int n, m;
vector<int> a;

void read() {
    cin >> n >> m;
    a.resize(n);
    cin >> a;
}

void solve() {
    // Subset-product maximisation modulo m via DP over reachable remainders.
    // dp[i][j] is true if some subset of the first i levers has product == j
    // (mod m), starting from the empty product 1. take[i][j] marks that the
    // best way to reach remainder j after i levers used lever i. We compute
    // the largest reachable remainder, then walk the take/dp tables backwards
    // to recover which levers were pulled, and print them in ascending order.

    vector<vector<bool>> dp(n + 1, vector<bool>(m, false));
    vector<vector<bool>> take(n + 1, vector<bool>(m, false));
    dp[0][1] = true;

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            if(dp[i][j]) {
                dp[i + 1][j] = true;
                dp[i + 1][(j * a[i]) % m] = true;
                take[i + 1][(j * a[i]) % m] = true;
            }
        }
    }

    int max_score = 0;
    for(int j = m - 1; j >= 0; j--) {
        if(dp[n][j]) {
            max_score = j;
            break;
        }
    }

    vector<int> levers;
    int curr = max_score;
    for(int i = n; i > 0; i--) {
        if(take[i][curr]) {
            levers.push_back(i);
            for(int j = 0; j < m; j++) {
                if(dp[i - 1][j] && (j * a[i - 1]) % m == curr) {
                    curr = j;
                    break;
                }
            }
        }
    }

    reverse(levers.begin(), levers.end());
    cout << max_score << '\n';
    cout << levers << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}

=================
p160.in1
======================
4 6
1 2 3 4

=================
p160.in2
======================
4 4
4 4 4 4

=================
statement.txt
======================
160. Magic Multiplying Machine
time limit per test: 0.5 sec.
memory limit per test: 65536 KB
input: standard input
output: standard output



Well known Las-Vegas casino "Big Jo" has recently introduced the new playing machine, called Magic Multiplying Machine (MMM). MMM has N levers and one big red button. Each lever is marked with some integer number ranging from 1 to M, thus i-th lever is marked with number ai.
A player who wishes to play on MMM inserts a coin into a special slot. After that she chooses some levers and pulls them. After she has made her choice, she presses the big red button. MMM blinks all its lights, rings its bells, plays diRerent tunes and after that declares whether the player has won the game.
The algorithm for determining whether the player has won is the following. If the player has pulled some subset S in {1, 2, ... ,N} of levers, her score is the product of numbers that these levers are marked with, taken modulo M (if the player has pulled no levers, her score is 1):


The player has won the game if her score is maximal possible for the given machine.
Given the description of some MMM determine which levers should be pulled to win the game.

Input
The first line of the input file contains two integer numbers 1 <= N <= 10000 and 2 <= M <= 1 000. The second line contains N integer numbers a1, a2, ..., aN ranging from 1 to M.

Output
In the first line of the output file print one integer number - the score that should be obtained to win the game. In the second line print in ascending order the numbers of levers that should be pulled to obtain this score (levers are numbered starting from one). If there are several solutions, output any one.

Sample test(s)

Input
Sample input #1
4 6
1 2 3 4

Sample input #2
4 4
4 4 4 4

Output
Sample output #1
4
1 4

Sample output #2
1

Note
Author:	Andrew Lopatin, Nikolay Durov
Resource:	ACM ICPC 2002-2003 NEERC, Northern Subregion
Date:	November, 2002








=================
