#include <bits/stdc++.h>
using namespace std;
bool canPartitionRecursive(vector<vector<int>> &dp, const vector<int> &num, int sum,
                           int currentIndex) {
      // base check
      if (sum == 0) {
            return true;
      }
      if (num.empty() || currentIndex >= num.size()) {
            return false;
      }

      // if we have not already processed a similar problem
      if (dp[currentIndex][sum] == -1) {
            // recursive call after choosing the number at the currentIndex
            // if the number at currentIndex exceeds the sum, we shouldn't process this
            if (num[currentIndex] <= sum) {
                  if (canPartitionRecursive(dp, num, sum - num[currentIndex], currentIndex + 1)) {
                        dp[currentIndex][sum] = 1;
                        return true;
                  }
            }

            // recursive call after excluding the number at the currentIndex
            dp[currentIndex][sum] = canPartitionRecursive(dp, num, sum, currentIndex + 1) ? 1 : 0;
      }

      return dp[currentIndex][sum] == 1 ? true : false;
}

void solve() {
      int n;
      cin >> n;
      vector<int> a(n);
      int sum = 0;
      int ind = 0;
      int mini = 2001;
      int ii = 0;
      vector<pair<int, int>> v(n);
      for (int i = 0; i < n; i++) {
            cin >> a[i];
            sum += a[i];
            if (a[i] % 2)
                  ind = i + 1;
      }
      sort(v.begin(), v.end());
      if (sum % 2) {
            cout << 0;
            return;
      }

      vector<vector<int>> dp(n, vector<int>(sum, -1));
      if (!canPartitionRecursive(dp, a, sum / 2 , 0)) {
            cout << 0;
            return;
      }

      for (int i = 0; i < n; i++) {
            int val = a[i];

            int lsum = sum - a[i];
            if (lsum % 2) {
                  cout << 1 << '\n' << i + 1;
                  return;
            }
            vector<int> temp;
            for(int j = 0; j < n; j++) {
                  if( i == j ) {continue;
                  }
                  temp.push_back(a[j]);
            }
            vector<vector<int>> ldp(n - 1, vector<int>(lsum, -1));
            if (!canPartitionRecursive(ldp, temp, lsum / 2 , 0)) {
                  cout << 1 << '\n' << i + 1;
                  return;
            }
      }
}
int32_t main() {
      ios_base::sync_with_stdio(0); cin.tie(0);
      int t = 1;
      for (int i = 0; i < t; i++) {
            solve();
      }
      return 0;
}