#pragma GCC optimize("Ofast")

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

using ll = long long;
using ld = long double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

constexpr int S = 1'000'000'000;

template<int N>
void solve(int n, vector<int> w) {
    mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
    using bs = bitset<N>;
    // static bs dp[51][51];
    vector<vector<bs>> dp(n / 2 + 1, vector<bs>(n / 2 + 1));

    while (true) {
        vector<int> a;
        vector<int> b;
        ll sum_a = 0;
        ll sum_b = 0;

        vector<int> p(n);
        iota(all(p), 0);
        shuffle(all(p), rng);

        for (int i = 0; i < n / 2; i++) {
            a.push_back(p[i]);
            sum_a += w[a.back()];
            b.push_back(p[n / 2 + i]);
            sum_b += w[b.back()];
        }

        for (int it = 0; it < 100; it++) {
            bool found = false;
            for (int r = 0; r < len(a); r++) {
                // ll nsum_a = sum_a - w[a[r]];
                // if (abs(S - sum_a) > abs(S - nsum_a)) {
                //     b.push_back(a[r]);
                //     a.erase(a.begin() + r);

                //     sum_a = nsum_a;
                //     sum_b = 2 * S - sum_a;
                //     found = true;
                // }

                for (int q = 0; q < len(b); q++) {
                    // {
                    //     ll nsum_a = sum_a + w[b[q]];
                    //     if (abs(S - sum_a) > abs(S - nsum_a)) {
                    //         a.push_back(b[q]);
                    //         b.erase(b.begin() + q);

                    //         sum_a = nsum_a;
                    //         sum_b = 2 * S - sum_a;
                    //         found = true;
                    //     }
                    // }

                    {
                        ll nsum_a = sum_a - w[a[r]] + w[b[q]];
                        if (abs(S - sum_a) > abs(S - nsum_a)) {
                            int i = a[r];
                            int j = b[q];
                            a.erase(a.begin() + r);
                            b.erase(b.begin() + q);
                            a.push_back(j);
                            b.push_back(i);

                            sum_a = nsum_a;
                            sum_b = 2 * S - sum_a;
                            found = true;
                        }
                    }
                }
            }

            if (!found) {
                break;
            }
        }

        if (a.empty() || b.empty() || abs(sum_a - S) >= N) {
            continue;
        }

        if (sum_a < sum_b) {
            swap(sum_a, sum_b);
            swap(a, b);
        }

        auto cmp = [&](int i, int j) {
            return w[i] < w[j];
        };

        sort(all(a), cmp);
        sort(all(b), cmp);

        for (int i = 0; i <= len(a); i++) {
            for (int j = 0; j <= len(b); j++) {
                dp[i][j].reset();
            }
        }
        dp[0][0][N / 2] = true;

        for (int i = 0; i <= len(a); i++) {
            for (int j = 0; j <= len(b); j++) {
                if (i + 1 <= len(a)) {
                    dp[i + 1][j] |= dp[i][j];
                }
                if (j + 1 <= len(b)) {
                    dp[i][j + 1] |= dp[i][j];
                }
                if (i + 1 <= len(a) && j + 1 <= len(b)) {
                    int diff = w[a[i]] - w[b[j]];
                    if (diff >= 0) {
                        dp[i + 1][j + 1] |= dp[i][j] << diff;
                    } else {
                        dp[i + 1][j + 1] |= dp[i][j] >> (-diff);
                    }
                }
            }
        }

        int res = N / 2 + (S - sum_b);
        if (res >= 0 && res < N && dp[len(a)][len(b)][res]) {
            set<int> ans(all(a));
            for (int i = len(a), j = len(b); i + j > 0;) {
                if (i > 0 && dp[i - 1][j][res]) {
                    i--;
                    continue;
                }
                if (j > 0 && dp[i][j - 1][res]) {
                    j--;
                    continue;
                }
                res -= w[a[i - 1]] - w[b[j - 1]];
                ans.erase(a[i - 1]);
                ans.insert(b[j - 1]);
                i--;
                j--;
            }

            cout << len(ans) << ' ';
            ll real_sum = 0;
            for (auto x : ans) {
                real_sum += w[x];
                cout << x + 1 << ' ';
            }
            assert(real_sum == S);
            cout << '\n';
            return;
        }
        // cout << "WRONG" << endl;

        // auto solve = [&](const vector<int> &st) {
        //     int n = len(st);
        //     vector<bs> possible(n + 1);
        //     possible[0][0] = 1;
        //     for (int i = 0; i < n; i++) {
        //         possible[i + 1] = possible[i] | (possible[i] << w[st[i]]);
        //     }
        //     return possible;
        // };

        // auto pa = solve(a);
        // auto pb = solve(b);

        // for (int d = 0; d < N; d++) {
        //     if (!pa.back()[d]) {
        //         continue;
        //     }

        //     ll need = S - (sum_a - d);
        //     if (0 <= need && need < N && pb.back()[need]) {
        //         cout << "SIIUU" << endl;
        //         return 0;
        //     }
        // }
        // cout << "Wrong" << endl;
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);

    int n;
    cin >> n;
    vector<int> w(n);
    for (auto &x : w) {
        cin >> x;
    }

    if (n <= 23) {
        for (int mask = 0; mask < (1 << n); mask++) {
            ll cur_sum = 0;
            for (int i = 0; i < n; i++) {
                if (mask >> i & 1) {
                    cur_sum += w[i];
                }
            }

            if (cur_sum == S) {
                cout << __builtin_popcount(mask) << ' ';
                ll real_sum = 0;
                for (int i = 0; i < n; i++) {
                    if (mask >> i & 1) {
                        cout << i + 1 << ' ';
                    }
                }
                cout << '\n';
                return 0;
            }
        }
        assert(false);
    }

    if (n <= 44) {
        unordered_set<ll> st;

        const int HALF = n / 2;
        for (int mask = 0; mask < (1 << HALF); mask++) {
            ll sum = 0;
            for (int i = 0; i < HALF; i++) {
                if (mask >> i & 1) {
                    sum += w[i];
                }
            }
            st.insert(sum);
        }

        vector<int> v;
        for (int mask = 0; mask < (1 << (n - HALF)); mask++) {
            ll sum = 0;
            v.clear();
            for (int i = HALF; i < n; i++) {
                if (mask >> (i - HALF) & 1) {
                    sum += w[i];
                    v.push_back(i);
                }
            }

            if (st.count(S - sum)) {
                for (int mask = 0; mask < (1 << HALF); mask++) {
                   ll cur = 0;
                    for (int i = 0; i < HALF; i++) {
                        if (mask >> i & 1) {
                            cur += w[i];
                        }
                    }
                    if (cur + sum == S) {
                        for (int i = 0; i < HALF; i++) {
                            if (mask >> i & 1) {
                                v.push_back(i);
                            }
                        }
                    }
                }

                cout << len(v) << ' ';
                sort(all(v));
                for (auto x : v) {
                    cout << x + 1 << ' ';
                }
                cout << '\n';
                return 0;
            }
        }
        assert(false);
    }

    if (n <= 50) {
        solve<5'800'000>(n, w);
    } else if (n <= 60) {
        solve<4'000'000>(n, w);
    } else if (n <= 70) {
        solve<3'000'000>(n, w);
    } else if (n <= 80) {
        solve<2'000'000>(n, w);
    } else {
        solve<1'000'000 * 2 / 3>(n, w);
    }
}