Baby Ehab was toying around with arrays. He has an array $$$a$$$ of length $$$n$$$. He defines an array to be good if there's no way to partition it into $$$2$$$ subsequences such that the sum of the elements in the first is equal to the sum of the elements in the second. Now he wants to remove the minimum number of elements in $$$a$$$ so that it becomes a good array. Can you help him?A sequence $$$b$$$ is a subsequence of an array $$$a$$$ if $$$b$$$ can be obtained from $$$a$$$ by deleting some (possibly zero or all) elements. A partitioning of an array is a way to divide it into $$$2$$$ subsequences such that every element belongs to exactly one subsequence, so you must use all the elements, and you can't share any elements.

The first line contains an integer $$$n$$$ ($$$2 \le n \le 100$$$) — the length of the array $$$a$$$. The second line contains $$$n$$$ integers $$$a_1$$$, $$$a_2$$$, $$$\ldots$$$, $$$a_{n}$$$ ($$$1 \le a_i \le 2000$$$) — the elements of the array $$$a$$$.

The first line should contain the minimum number of elements you need to remove. The second line should contain the indices of the elements you're removing, separated by spaces. We can show that an answer always exists. If there are multiple solutions, you can print any.

NoteIn the first example, you can partition the array into $$$[6,9]$$$ and $$$[3,12]$$$, so you must remove at least $$$1$$$ element. Removing $$$3$$$ is sufficient.In the second example, the array is already good, so you don't need to remove any elements.

# from sys import stdin,stdout
# input=stdin.readline
import math
import sys
# t=int(input())
from collections import Counter,defaultdict
import bisect
def func(n,set):
    s = sum(set)
    if s%2:
        return False
    s = s//2
    subset =([[False for i in range(s + 1)]
            for i in range(n + 1)])

    for i in range(n + 1):
        subset[i][0] = True

    for i in range(1, s + 1):
         subset[0][i]= False

    for i in range(1, n + 1):
        for j in range(1, s + 1):
            if j<set[i-1]:
                subset[i][j] = subset[i-1][j]
            if j>= set[i-1]:
                subset[i][j] = (subset[i-1][j] or
                                subset[i - 1][j-set[i-1]])

    return subset[n][s]
def check(a,flag = 0):
    for i in a:
        if i%2:
            if not flag:
                return False
            else:
                return a.index(i)
    return True
n = int(input())
a = list(map(int,input().split(' ')))
aTemp = [i for i in a]
if not func(n,a):
    print(0)
else:
    while (check(aTemp)):
        aTemp = [i//2 for i in aTemp]
    print(1)
    print(check(aTemp,1)+1)

import sys

n = int(input())
array = [int(x) for x in input().split()]
if sum(array) % 2 == 0:
    s = 1
    for i in array:
        s |= s << i

    if s & (1 << (sum(array)//2)):
        b = [x & -x for x in array]
        i = b.index(min(b))
        print(f"1\n{i+1}")
        sys.exit()
print(0)

import sys
import os
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
n = int(input())
l = list(map(int, input().split()))
sum1 = sum(l)
if sum1%2 == 1:
    print(0)
else:
    prev_dict = {}
    prev_dict[0] = True
    new_dict = prev_dict.copy()
    for i in range(n):
        for val in prev_dict:
            if val + l[i] not in new_dict:
                new_dict[val + l[i]] = True
        prev_dict = new_dict.copy()
    if sum1//2 not in new_dict:
        print(0)
    else:
        found = -1
        for i in range(n):
            if l[i]%2 == 1:
                save = i + 1
                found = 1
                break
        if found == 1:
            print(1)
            print(save)
        else:
            check = 4
            save = -1
            while True:
                for i in range(n):
                    if l[i]%check != 0:
                        save = i + 1
                        break
                if save > -1:
                    break
                else:
                    check *= 2
            print(1)
            print(save)

n = int(input())
arr = list(map(int, input().split()))

if sum(arr) & 1:
    print(0)
else:
    even, odd = 0, 0
    for i in arr:
        if i & 1:
            odd += 1
        else:
            even += 1
    target = sum(arr) // 2
    n = len(arr)
    dp = [[False for i in range(target + 1)] for j in range(n + 1)]
    for i in range(n + 1):
        dp[i][0] = True
    for i in range(1, n + 1):
        for j in range(1, target + 1):
            if arr[i - 1] > j:
                dp[i][j] = dp[i - 1][j]
            else:
                dp[i][j] = dp[i - 1][j] or dp[i - 1][j - arr[i - 1]]
    if dp[n][target]:
        if odd:
            for i in range(len(arr)):
                if arr[i] & 1:
                    print(1)
                    print(i + 1)
                    exit()
        else:
            min_index = 10 ** 9
            ans = -1
            for i in range(len(arr)):
                for j in range(32):
                    if arr[i] & (1 << j):
                        if j < min_index:
                            min_index = min(min_index, j)
                            ans = i + 1
                            break
            print(1)
            print(ans)
    else:
        print(0)

def ii():  return int(input())
def si():  return input()
def mi():  return map(int,input().strip().split(" "))
def msi(): return map(str,input().strip().split(" "))
def li():  return list(mi())

n = ii()
l = li()

s = sum(l)
if(s%2):
    print(0)
else:
    dp = []
    ss = s
    s = s//2
    for i in range(n+1):
        dp.append([0]*(s+1))
    for i in range(n+1):
        dp[i][0] = 1

    for i in range(1,n+1):
        for j in range(1,s+1):
            if(l[i-1]<=j):
                dp[i][j] = dp[i-1][j-l[i-1]] or dp[i-1][j]

            else:
                dp[i][j] = dp[i-1][j]
    if(dp[n][s]==0):
    	print(0)
    else:
	    for i in range(n):
	        if(l[i]%2==0 and dp[n][(ss-l[i])//2] == 0):
	            print(1)
	            print(i+1)

	            break
	        elif(l[i]%2):
	        	print(1)
	        	print(i+1)

	        	break

import math
def check(n,l):
    s = sum(l)
    if s%2!=0:
        return True
    dp = [[False]*n for i in range(s//2+1)]
    for i in range(n):
        for j in range(s//2+1):
            if i==0:
                if j==0 or j==l[0]:
                    dp[j][i]=True
                continue
            if j==0:
                dp[j][i]=True
                continue
            if j>=l[i]:
                dp[j][i] = dp[j][i-1] or dp[j-l[i]][i-1]
            else:
                dp[j][i] = dp[j][i-1]
    return not dp[-1][-1]

n = int(input())
l = [int(i) for i in input().split()]
l1 = [math.log2(i&-i) for i in l]
v = l1.index(min(l1))
for i in range(n):
    l[i] = int(l[i]/2**l1[v])
if check(n,l)==True:
    print(0)
else:
    print(1)
    print(v+1)

import math
t = int(input())
a = list(map(int, input().split()))
d = math.gcd(a[0], a[1])
for i in range(2, len(a)):
    d = math.gcd(d, a[i])
for i in range(len(a)):
    a[i] = a[i]//d
total = sum(a)
if total % 2 == 1:
    print(0)
else:
    target = total//2
    dp = [False] * (target+1)
    dp[0] = True
    for v in a:
        for i in range(target, v - 1, -1):
            dp[i] = dp[i] or dp[i - v]
    if dp[target]:
        j = 0
        while a[j] % 2 == 0:
            j += 1
        print(1)
        print(j + 1)
    else:
        print(0)

from sys import stdin

def read_int():
    return int(stdin.readline())

def read_ints():
    return map(int, stdin.readline().split(' '))

n = read_int()
a = list(read_ints())
s = sum(a)
if s % 2 == 1:
    print(0)
    exit(0)

dp = [False] * (s // 2 + 1)
dp[0] = True
for ai in a:
    for j in range(s // 2, ai - 1, -1):
        dp[j] = dp[j] or dp[j - ai]
if not dp[s // 2]:
    print(0)
    exit(0)

while True:
    if sum(a) % 2 == 1:
        print(0)
        exit(0)
    else:
        odd = -1
        for i in range(n):
            if a[i] % 2 == 1:
                print(1)
                print(i + 1)
                exit(0)
        a = [x // 2 for x in a]

import functools, math, sys

input = sys.stdin.readline

def knapsack(capacity, utility, weight):
    backpack = [[0 for i in range(capacity + 1)] for j in range(2)]
    for i in range(len(weight)):
        if i % 2 == 0:
            for j in range(capacity + 1):
                if weight[i] <= j:
                    backpack[1][j] = max(utility[i] + backpack[0][j - weight[i]], backpack[0][j])
                else:
                    backpack[1][j] = backpack[0][j]
        else:
            for j in range(capacity + 1):
                if weight[i] <= j:
                    backpack[0][j] = max(utility[i] + backpack[1][j - weight[i]], backpack[1][j])
                else:
                    backpack[0][j] = backpack[1][j]
    if not len(weight) % 2:
        return backpack[0][capacity]
    else:
        return backpack[1][capacity]

n, values = int(input()), [int(i) for i in input().split()]
tot, tar = sum(values), sum(values) // 2
if tot % 2 or knapsack(tar, values, values) != tar:
    print(0)
    sys.exit()
gcd = functools.reduce(math.gcd, values)
values = [values[i] // gcd for i in range(n)]
for i in range(n): # remove
    if values[i] % 2:
        print(1)
        print(i + 1)
        sys.exit()

import math
def fun(a,n):
    d=[{} for i in range(n)]
    d[0][0]=True
    d[0][a[0]]=True

    d[-1][sum(a)//2]=False

    for i in range(n-1):
        for j in d[i]:
            d[i+1][j+a[i+1]]=True
            d[i+1][j]=True
    #print(d)
    return d[-1][sum(a)//2]

n=int(input())
a=[int(x) for x in input().split()]

if sum(a)%2==1:
    print(0)

else:
    if fun(a,n):
        print(1)
        mn=int(math.log(a[0],2))
        ans=0
        for i in range(n):
            t=0
            while a[i]%2==0:
                a[i]=a[i]//2
                t+=1
            if t<mn:
                mn=t
                ans=i

        print(ans+1)

    else:
        print(0)

def zip_sorted(a,b):

	# sorted  by a
	a,b = zip(*sorted(zip(a,b)))
	# sorted by b
	sorted(zip(a, b), key=lambda x: x[1])

	return a,b

def number_to_list(a):

	b = []

	while a>=1:

		c = a%10

		a = int(a/10)

		b.append(c)

	return list(reversed(b))

def str_list_to_int_list(a):

	a = list(map(int,a))

	return a

def make_1d_array(n,inti= 0):

	a = [inti for _ in range(n)]

	return a

def make_2d_array(n,m,inti= 0):

	a = [[inti for _ in range(m)] for _ in range(n)]

	return a

def make_3d_array(n,m,k,inti= 0):

	a = [[[inti for _ in range(k)] for _ in range(m)] for _ in range(n)]

	return a

def gcd(a,b):

	if(b==0):
		return a

	else:
		return gcd(b,a%b);

import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input()))

# def solve(sum1,dp):

# 	prev = [[] for i in range(sum1+1)]

# 	for i in range(n):

# 		dp = [prev[j] for j in range(sum1+1)]

# 		for j in range(sum1+1):

'''

#########################
#	Optimizations
#
#	1)	loop from backwards thus only one loop required
#	2)	memeroization of only required index of ans
#
#########################

n, = I()
a   = I()
sum1 = sum(a)

if sum1%2==0:

	sum1 = sum1//2

	dp = [False]*(sum1+1)
	dp[0] = True
	# ans = [[] for j in range(sum1+1)]
	from collections import defaultdict
	ans = defaultdict(list)
	for i in range(n):
		for j in range(sum1,-1,-1):
			if j-a[i]>=0:
				if dp[j-a[i]]:
					if dp[j]:
						if len(ans[j])>(len(ans[j-a[i]])+1):
							ans[j] = ans[j-a[i]]+[i+1]
					else:
						ans[j] = ans[j-a[i]]+[i+1]
				dp[j] = dp[j] or dp[j-a[i]]

	# print(ans)

	idx = -1

	# print(dp[sum1],ans[sum1])

	if dp[sum1]:

		min1 = 10**10

		for i in ans:

			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

				if len(ans[i])<min1:

					min1 = len(ans[i])

					idx  = i

		print(len(ans[idx]))
		print(*ans[idx])

	else:

		print(0)

else:

	print(0)

'''

#########################
#	Optimizations
#
#	2)	memeroization of only required index of ans
#
#########################

n, = I()
a   = I()
sum1 = sum(a)

if sum1%2==0:

	sum1 = sum1//2

	prev = [False]*(sum1+1)
	prev[0] = True
	# ans = [[] for j in range(sum1+1)]
	from collections import defaultdict
	# ans = defaultdict(list)
	ans = defaultdict(list)
	for i in range(n):
		dp  = prev.copy()
		ans1= ans.copy()
		for j in range(sum1+1):
			if j-a[i]>=0:
				if prev[j-a[i]]:
					if dp[j]:
						if len(ans[j])>(len(ans[j-a[i]])+1):
							ans1[j] = ans[j-a[i]]+[i+1]
					else:
						ans1[j] = ans[j-a[i]]+[i+1]
				dp[j] = dp[j] or prev[j-a[i]]
		prev = dp.copy()
		ans  = ans1.copy()

	# print(ans)

	idx = -1

	# print(dp[sum1],ans[sum1])

	if dp[sum1]:

		min1 = 10**10

		for i in ans:

			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

				if len(ans[i])<min1:

					min1 = len(ans[i])

					idx  = i

		print(len(ans[idx]))
		print(*ans[idx])

	else:

		print(0)

else:

	print(0)

#########################
#	Optimizations
#
#	1)	None
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	prev = [False]*(sum1+1)
# 	prev[0] = True
# 	prev_a = [[] for j in range(sum1+1)]
# 	# from collections import defaultdict
# 	for i in range(n):
# 		dp = prev.copy()
# 		dp_a = [prev_a[j] for j in range(len(prev_a))]
# 		for j in range(sum1+1):
# 			if j-a[i]>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if len(dp_a[j])>(len(prev_a[j-a[i]])+1):
# 							dp_a[j] = prev_a[j-a[i]]+[i+1]
# 					else:
# 						dp_a[j] = prev_a[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or prev[j-a[i]]
# 		prev = dp.copy()
# 		prev_a = [dp_a[j] for j in range(len(dp_a))]

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in range(sum1+1):

# 			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(dp_a[i])<min1:

# 					min1 = len(dp_a[i])

# 					idx  = i

# 		print(len(dp_a[idx]))
# 		print(*dp_a[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#
#	WA
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	dp = [False]*(sum1+1)
# 	dp[0] = True
# 	dp_a = [[] for j in range(sum1+1)]
# 	# from collections import defaultdict
# 	for i in range(n):
# 		for j in range(sum1,-1,-1):
# 			if j-a[i]>=0:
# 				if dp[j-a[i]]:
# 					if dp[j]:
# 						if len(dp_a[j])>(len(dp_a[j-a[i]])+1):
# 							dp_a[j] = dp_a[j-a[i]]+[i+1]
# 					else:
# 						dp_a[j] = dp_a[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or dp[j-a[i]]

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in range(sum1+1):

# 			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(dp_a[i])<min1:

# 					min1 = len(dp_a[i])

# 					idx  = i

# 		print(len(dp_a[idx]))
# 		print(*dp_a[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#
#	WA of contest
#	after changing it gives TLE
#########################

# import sys
# input = sys.stdin.readline
# I = lambda : list(map(int,input().split()))
# S = lambda : list(map(str,input()))

# n, = I()
# a   = I()
# sum1 = sum(a)
# if sum1%2==0:
# 	sum1 = sum1//2
# 	prev = [[False,10**10] for i in range(sum1+1)]
# 	ans  = [[] for i in range(sum1+1)]
# 	prev[0] = [True,0]
# 	for i in range(n):
# 		dp = [[prev[j][k] for k in range(len(prev[j]))] for j in range(sum1+1)]
# 		ans1 = [[ans[j][k] for k in range(len(ans[j]))] for j in range(sum1+1)]
# 		for j in range(sum1+1):
# 			if (j-a[i])>=0:
# 				if prev[j-a[i]][0]:
# 					if dp[j][0]:
# 						if (prev[j-a[i]][1]+1)<dp[j][1]:
# 							ans1[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans1[j] = ans[j-a[i]]+[i+1]
# 					dp[j][1] = min(dp[j][1],prev[j-a[i]][1]+1)
# 					dp[j][0] = True
# 		prev = [[dp[j][k] for k in range(len(dp[j]))]  for j in range(sum1+1)]
# 		ans = [[ans1[j][k] for k in range(len(ans1[j]))] for j in range(sum1+1)]
# 	if prev[sum1][0]:
# 		min1 = prev[sum1][1]
# 		idx = sum1
# 		for i in range(sum1+1):
# 			if prev[i][0] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2][0]==False):
# 				if min1>prev[i][1]:
# 					idx = i
# 				min1 = min(min1,prev[i][1])
# 		print(len(ans[idx]))
# 		print(*ans[idx])
# 	else:
# 		print(0)
# else:
# 	print(0)

#########################
#
#	WA of contest
# pass

#########################

# n, = I()
# a   = I()
# sum1 = sum(a)
# if sum1%2==0:
# 	sum1 = sum1//2
# 	prev = [False for i in range(sum1+1)]
# 	ans  = [[] for i in range(sum1+1)]
# 	prev[0] = True
# 	for i in range(n):
# 		dp = prev.copy()
# 		ans1 = [ans[j] for j in range(sum1+1)]
# 		for j in range(sum1+1):
# 			if (j-a[i])>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if (len(ans[j-a[i]])+1)<len(ans1[j]):
# 							ans1[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans1[j] = ans[j-a[i]]+[i+1]
# 					dp[j] = True
# 		prev = dp.copy()
# 		ans = [ans1[j] for j in range(sum1+1)]
# 	if prev[sum1]:
# 		min1 = 10**10
# 		idx = -1
# 		for i in range(sum1+1):
# 			if prev[i] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2]==False):
# 				if min1>len(ans[i]):
# 					idx = i
# 				min1 = min(min1,len(ans[i]))
# 		print(len(ans[idx]))
# 		print(*ans[idx])
# 	else:
# 		print(0)
# else:
# 	print(0)

# 1)	less loop while copying
# 2)	always intilize with -1
# 3)

#########################
#
#	WA of contest
# pass

#########################

# n, = I()
# a   = I()
# sum1 = sum(a)
# if sum1%2==0:
# 	sum1 = sum1//2
# 	prev = [False for i in range(sum1+1)]
# 	prev1 = [0 for i in range(sum1+1)]
# 	ans  = [[] for i in range(sum1+1)]
# 	prev[0] = (True,0)
# 	for i in range(n):
# 		dp = prev.copy()
# 		dp1 = prev1.copy()
# 		ans1 = [ans[j][:] for j in range(sum1+1)]
# 		for j in range(sum1+1):
# 			if (j-a[i])>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if (len(ans[j-a[i]])+1)<len(ans1[j]):
# 							ans1[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans1[j] = ans[j-a[i]]+[i+1]
# 					dp[j] = True
# 		prev = dp.copy()
# 		prev1 = dp1.copy()
# 		ans = [ans1[j] for j in range(sum1+1)]
# 	if prev[sum1]:
# 		min1 = 10**10
# 		idx = -1
# 		for i in range(sum1+1):
# 			if prev[i] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2]==False):
# 				if min1>len(ans[i]):
# 					idx = i
# 				min1 = min(min1,len(ans[i]))
# 		print(len(ans[idx]))
# 		print(*ans[idx])
# 	else:
# 		print(0)
# else:
# 	print(0)

import os,sys,math
from io import BytesIO, IOBase
from collections import defaultdict,deque,OrderedDict
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(input()))
def In():return(map(int,input().split()))
def ln():return list(map(int,input().split()))
def Sn():return input().strip()
from array import array
BUFSIZE = 8192
#complete the main function with number of test cases to complete greater than x
def find_gt(a, x):
    i = bi.bisect_left(a, x)
    if i != len(a):
        return i
    else:
        return len(a)
def CountTrailingZeros(n):

    bit = bin(n)[2:]
    bit = bit[::-1]
    zero = 0;
    for i in range(len(bit)):
        if (bit[i] == '0'):
            zero += 1
        else:
            break

    return zero
def solve():
    Max=2000*100
    n=I()
    dp=array('b')
    dp=[False]*Max
    dp[0]=True
    l=list(In())
    total=0
    for x in l:
        total+=x
        for j in range(len(dp)-x-1,-1,-1):
            if not dp[j]:continue
            dp[j+x]=True

    if (not dp[total//2]) or (total%2!=0):
        print(0)
        return
    trail=31
    for x in l:
        trail=min(trail,CountTrailingZeros(x))
    ans=-2
    for i in range(n):
        if l[i]%(1<<trail+1)!=0:
            ans=i
    print(1)
    print(ans+1)

    pass

def main():
    T=1
    for i in range(T):
        solve()

M = 998244353
P = 1000000007

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == '__main__':
    main()

y = lambda x: x>>1

def subsetSum(l, i, target_sum, memo=dict()):
	key = i, target_sum
	if key in memo:
		return memo[key]

	if target_sum == 0:
		return True
	if i == len(l):
		return False

	to_return = subsetSum(l, i+1, target_sum, memo) or subsetSum(l, i+1, target_sum-l[i], memo)
	memo[key] = to_return
	return to_return

def make_good(l):
	for i in range(len(l)):
		if l[i] & 1:	# odd
			return i+1	# 1-based index

	# all items are even
	return(make_good(list(map(y, l))))

if __name__ == '__main__':
	n = int(input())
	l = list(map(int, input().split()))

	if sum(l) & 1==1 or not subsetSum(l, 0, sum(l)//2):
		print(0)

	else:

		res = make_good(l)
		print(1)
		print(res)

def zip_sorted(a,b):

	# sorted  by a
	a,b = zip(*sorted(zip(a,b)))
	# sorted by b
	sorted(zip(a, b), key=lambda x: x[1])

	return a,b

def number_to_list(a):

	b = []

	while a>=1:

		c = a%10

		a = int(a/10)

		b.append(c)

	return list(reversed(b))

def str_list_to_int_list(a):

	a = list(map(int,a))

	return a

def make_1d_array(n,inti= 0):

	a = [inti for _ in range(n)]

	return a

def make_2d_array(n,m,inti= 0):

	a = [[inti for _ in range(m)] for _ in range(n)]

	return a

def make_3d_array(n,m,k,inti= 0):

	a = [[[inti for _ in range(k)] for _ in range(m)] for _ in range(n)]

	return a

def gcd(a,b):

	if(b==0):
		return a

	else:
		return gcd(b,a%b);

import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input()))

# def solve(sum1,dp):

# 	prev = [[] for i in range(sum1+1)]

# 	for i in range(n):

# 		dp = [prev[j] for j in range(sum1+1)]

# 		for j in range(sum1+1):

'''

#########################
#	Optimizations
#
#	1)	loop from backwards thus only one loop required
#	2)	memeroization of only required index of ans
#
#########################

n, = I()
a   = I()
sum1 = sum(a)

if sum1%2==0:

	sum1 = sum1//2

	dp = [False]*(sum1+1)
	dp[0] = True
	# ans = [[] for j in range(sum1+1)]
	from collections import defaultdict
	ans = defaultdict(list)
	for i in range(n):
		for j in range(sum1,-1,-1):
			if j-a[i]>=0:
				if dp[j-a[i]]:
					if dp[j]:
						if len(ans[j])>(len(ans[j-a[i]])+1):
							ans[j] = ans[j-a[i]]+[i+1]
					else:
						ans[j] = ans[j-a[i]]+[i+1]
				dp[j] = dp[j] or dp[j-a[i]]

	# print(ans)

	idx = -1

	# print(dp[sum1],ans[sum1])

	if dp[sum1]:

		min1 = 10**10

		for i in ans:

			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

				if len(ans[i])<min1:

					min1 = len(ans[i])

					idx  = i

		print(len(ans[idx]))
		print(*ans[idx])

	else:

		print(0)

else:

	print(0)

'''

#########################
#	Optimizations
#
#	2)	memeroization of only required index of ans
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	prev = [False]*(sum1+1)
# 	prev[0] = True
# 	# ans = [[] for j in range(sum1+1)]
# 	from collections import defaultdict
# 	# ans = defaultdict(list)
# 	ans = defaultdict(list)
# 	for i in range(n):
# 		dp = prev.copy()
# 		for j in range(sum1+1):
# 			if j-a[i]>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if len(ans[j])>(len(ans[j-a[i]])+1):
# 							ans[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans[j] = ans[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or prev[j-a[i]]
# 		prev = dp.copy()

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in ans:

# 			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(ans[i])<min1:

# 					min1 = len(ans[i])

# 					idx  = i

# 		print(len(ans[idx]))
# 		print(*ans[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#	Optimizations
#
#	1)	None
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	prev = [False]*(sum1+1)
# 	prev[0] = True
# 	prev_a = [[] for j in range(sum1+1)]
# 	# from collections import defaultdict
# 	for i in range(n):
# 		dp = prev.copy()
# 		dp_a = [prev_a[j] for j in range(len(prev_a))]
# 		for j in range(sum1+1):
# 			if j-a[i]>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if len(dp_a[j])>(len(prev_a[j-a[i]])+1):
# 							dp_a[j] = prev_a[j-a[i]]+[i+1]
# 					else:
# 						dp_a[j] = prev_a[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or prev[j-a[i]]
# 		prev = dp.copy()
# 		prev_a = [dp_a[j] for j in range(len(dp_a))]

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in range(sum1+1):

# 			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(dp_a[i])<min1:

# 					min1 = len(dp_a[i])

# 					idx  = i

# 		print(len(dp_a[idx]))
# 		print(*dp_a[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#	Optimizations
#
#	1)	loop from backwards thus only one loop required
#
#########################

n, = I()
a   = I()
sum1 = sum(a)

if sum1%2==0:

	sum1 = sum1//2

	dp = [False]*(sum1+1)
	dp[0] = True
	dp_a = [[] for j in range(sum1+1)]
	# from collections import defaultdict
	for i in range(n):
		for j in range(sum1,-1,-1):
			if j-a[i]>=0:
				if dp[j-a[i]]:
					if dp[j]:
						if len(dp_a[j])>(len(dp_a[j-a[i]])+1):
							dp_a[j] = dp_a[j-a[i]]+[i+1]
					else:
						dp_a[j] = dp_a[j-a[i]]+[i+1]
				dp[j] = dp[j] or dp[j-a[i]]

	# print(ans)

	idx = -1

	# print(dp[sum1],ans[sum1])

	if dp[sum1]:

		min1 = 10**10

		for i in range(sum1+1):

			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

				if len(dp_a[i])<min1:

					min1 = len(dp_a[i])

					idx  = i

		print(len(dp_a[idx]))
		print(*dp_a[idx])

	else:

		print(0)

else:

	print(0)

n=int(input())
a=list(map(int,input().split()))
s=sum(a)
if s%2==1:
    print(0)
else:
    s=s//2
    dp=[[False for i in range(s+1)]for _ in range(len(a)+1)]
    for i in range(len(dp)):
        dp[i][0]=True
    for i in range(1,len(a)+1):
        for j in range(1,s+1):
            if j>=a[i-1]:
                dp[i][j]=dp[i-1][j] or dp[i-1][j-a[i-1]]
            else:
                dp[i][j]=dp[i-1][j]
    if not dp[n][s]:
        print(0)
    else:
        f=0
        for i in range(len(a)):
            if a[i]%2==1:
                print(1)
                print(i+1)
                f=1
                break
        if f==0:
            f=1
            while(f):
                for i in range(len(a)):
                    if a[i]%2==1:
                        print(1)
                        print(i+1)
                        f=0
                        break
                    a[i]=a[i]//2

# import sys
# sys.stdin=open('input.txt','r')
# sys.stdout=open('output.txt','w')
import sys
import math
def input(): return sys.stdin.readline().strip("\n")
def I():    return (input())
def II():    return (int(input()))
def MI():    return (map(int,input().split()))
def LI():    return (list(map(int,input().split())))
def findPartition(arr, n,s):
	if s % 2 == 1:
		return False
	# print(s)
	for i in range(0, n + 1):
		part[0][i] = True
	for i in range(1, s // 2 + 1):
		part[i][0] = False
	for i in range(1, s // 2 + 1):
		for j in range(1, n + 1):
			part[i][j] = part[i][j - 1]
			if i >= arr[j - 1]:
				part[i][j] = (part[i][j] or part[i - arr[j - 1]][j - 1])
	return part[s // 2][n]

n = II()
a = LI()
s = 0
i, j = 0, 0
for i in range(n):
	s += a[i]
# print(s)
part = [[True for i in range(n + 1)]for j in range(s // 2 + 1)]
if findPartition(a,n,s) == False:
	print(0)
else:
	switch = 0
	while True:
		for i in range(n):
			if a[i] % 2 == 1:
				print(1)
				print(i+1)
				switch = 1
				break;
			a[i] = a[i] // 2
		if switch == 1:
			break;

from sys import stdin

def read_int():
    return int(stdin.readline())

def read_ints():
    return map(int, stdin.readline().split(' '))

n = read_int()
a = list(read_ints())
while True:
    s = sum(a)
    if s % 2 == 1:
        print(0)
        exit(0)
    h = 0
    dp = [False] * (s // 2 + 1)
    dp[0] = True
    for ai in a:
        for j in range(s // 2, ai - 1, -1):
            dp[j] = dp[j] or dp[j - ai]
    if not dp[s // 2]:
        print(0)
        exit(0)
    else:
        odd = -1
        for i in range(n):
            if a[i] % 2 == 1:
                print(1)
                print(i + 1)
                exit(0)
        a = [x // 2 for x in a]

"""
// Author : snape_here - Susanta Mukherjee

 """

from __future__ import division, print_function

import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def msi(): return map(str,input().split())
def mi(): return map(int,input().split())
def li(): return list(mi())
def lsi(): return list(msi())

def read():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def lcm(x, y):
    return (x*y)//(gcd(x,y))

mod=1000000007

def modInverse(b,m):
    g = gcd(b, m)
    if (g != 1):
        return -1
    else:
        return pow(b, m - 2, m)

def ceil2(x,y):
    if x%y==0:
        return x//y
    else:
        return x//y+1

def modu(a,b,m):

    a = a % m
    inv = modInverse(b,m)
    if(inv == -1):
        return -999999999
    else:
        return (inv*a)%m

from math import log,factorial,cos,tan,sin,radians,floor,sqrt,ceil

abc="abcdefghijklmnopqrstuvwxyz"

pi=3.141592653589793238

def gcd1(a):

    if len(a) == 1:
        return a[0]

    ans = a[0]
    for i in range(1,len(a)):
        ans = gcd(ans,a[i])

    return ans

def mykey(x):
    return x[1],-x[0]

def main():

    for _ in range(1):
        n=ii()
        a=li()
        a.insert(0,0)
        if sum(a)%2:
            print(0)
            exit()

        s = sum(a)

        dp = []
        for i in range(n+1):
            c = [0]*(200005)
            dp.append(c)

        dp[0][0] = 1
        for i in range(n):
            for j in range(200005):
                if dp[i][j]:
                    dp[i+1][j] = 1
                    dp[i+1][j+a[i+1]] = 1

        y = -1
        for i in range(n, 0, -1):
            if a[i]%2:
                y = i
                break

        if y==-1:
            l=[]
            for i in range(1,n+1):
                c = 0
                while a[i]%2==0:
                    a[i] //= 2
                    c += 1
                l.append(c)
            m = min(l)

            for i in range(n):
                if l[i]==m:
                    y = i+1
                    break

        x = s//2
        f = 0
        ans = 0
        for i in range(1,n+1):
            if dp[i][x]:
                f = 1
                ans = y
                break

        if f:
            print(1)
            print(ans)
        else:
            print(0)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    #read()
    main()

from os import path
import sys,time
mod = int(1e9 + 7)
# import re
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque
from itertools import combinations ,accumulate
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *
from functools import reduce
from operator import mul
star = lambda x: print(' '.join(map(str, x)))
grid = lambda  r :[lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
INF = float('inf')
if (path.exists('input.txt')):
    sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
import sys
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil
def st(): return list(stdin.readline().strip())
def inp():
    return int(stdin.readline())
def inlt():
    return list(map(int, stdin.readline().split()))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return map(int, stdin.readline().split())
def pr(n): return stdout.write(str(n)+"\n")
from copy import deepcopy
def subset_sum(a,n,target):
    dp = [[False for _ in range(target+1)]for _ in range(n+1)]
    for i in range(n+1):
        for j in range(target+1):
            if i==0:
                dp[i][j] = False
            if j==0:
                dp[i][j] = True
    for i in range(n+1):
        for j in range(target+1):
            if a[i-1]<=j:
                dp[i][j] = dp[i-1][j] or dp[i-1][j-a[i-1]]
            else:
                dp[i][j] = dp[i-1][j]
    return dp[n][target]
def solve():
    n = inp()
    a = inlt()
    if sum(a)%2:
        print(0)
    else:
        odd = False
        ind = 0
        if subset_sum(a,n,sum(a)//2):
            for i in range(n):
                if a[i]%2:
                    ind = i
                    odd = True
                    break
            if odd:
                print(1)
                print(ind+1)
            else:

                for j in range(13):
                    for i in range(n):
                        if a[i]%2:
                            print(1)
                            print(i+1)
                            return
                        else:
                            a[i]//=2
        else:
            print(0)

t = 1
#t = inp()
for _ in range(t):
    solve()

import sys
import io, os
#input = sys.stdin.buffer.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

def main():
    n = int(input())
    A = list(map(int, input().split()))

    M = sum(A)
    if M%2 == 1:
        print(0)
        exit()

    dp = [False]*(M+1)
    dp[0] = True
    for a in A:
        for j in reversed(range(M+1)):
            if not dp[j]:
                continue
            dp[j+a] = True

    if not dp[M//2]:
        print(0)
        exit()
    while True:
        B = []
        S = sum(A)
        for i, a in enumerate(A):
            if S%2 == 0:
                if a%2 == 1:
                    print(1)
                    print(i+1)
                    exit()
                else:
                    B.append(a//2)
            else:
                if a%2 == 0:
                    print(1)
                    print(i+1)
                    exit()
        else:
            A = B

if __name__ == '__main__':
    main()

#Code by Sounak, IIESTS
#------------------------------warmup----------------------------

import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading

#sys.setrecursionlimit(300000)
#threading.stack_size(10**8)

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

#-------------------------------------------------------------------------
#mod = 9223372036854775807
class SegmentTree:
    def __init__(self, data, default=0, func=lambda a, b: a+b):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

class SegmentTree1:
    def __init__(self, data, default=10**6, func=lambda a, b: min(a,b)):
        """initialize the segment tree with data"""
        self._default = default
        self._func = func
        self._len = len(data)
        self._size = _size = 1 << (self._len - 1).bit_length()

        self.data = [default] * (2 * _size)
        self.data[_size:_size + self._len] = data
        for i in reversed(range(_size)):
            self.data[i] = func(self.data[i + i], self.data[i + i + 1])

    def __delitem__(self, idx):
        self[idx] = self._default

    def __getitem__(self, idx):
        return self.data[idx + self._size]

    def __setitem__(self, idx, value):
        idx += self._size
        self.data[idx] = value
        idx >>= 1
        while idx:
            self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
            idx >>= 1

    def __len__(self):
        return self._len

    def query(self, start, stop):
        if start == stop:
            return self.__getitem__(start)
        stop += 1
        start += self._size
        stop += self._size

        res = self._default
        while start < stop:
            if start & 1:
                res = self._func(res, self.data[start])
                start += 1
            if stop & 1:
                stop -= 1
                res = self._func(res, self.data[stop])
            start >>= 1
            stop >>= 1
        return res

    def __repr__(self):
        return "SegmentTree({0})".format(self.data)

MOD=10**9+7
class Factorial:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorials = [1, 1]
        self.invModulos = [0, 1]
        self.invFactorial_ = [1, 1]

    def calc(self, n):
        if n <= -1:
            print("Invalid argument to calculate n!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.factorials):
            return self.factorials[n]
        nextArr = [0] * (n + 1 - len(self.factorials))
        initialI = len(self.factorials)
        prev = self.factorials[-1]
        m = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = prev * i % m
        self.factorials += nextArr
        return self.factorials[n]

    def inv(self, n):
        if n <= -1:
            print("Invalid argument to calculate n^(-1)")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        p = self.MOD
        pi = n % p
        if pi < len(self.invModulos):
            return self.invModulos[pi]
        nextArr = [0] * (n + 1 - len(self.invModulos))
        initialI = len(self.invModulos)
        for i in range(initialI, min(p, n + 1)):
            next = -self.invModulos[p % i] * (p // i) % p
            self.invModulos.append(next)
        return self.invModulos[pi]

    def invFactorial(self, n):
        if n <= -1:
            print("Invalid argument to calculate (n^(-1))!")
            print("n must be non-negative value. But the argument was " + str(n))
            exit()
        if n < len(self.invFactorial_):
            return self.invFactorial_[n]
        self.inv(n)  # To make sure already calculated n^-1
        nextArr = [0] * (n + 1 - len(self.invFactorial_))
        initialI = len(self.invFactorial_)
        prev = self.invFactorial_[-1]
        p = self.MOD
        for i in range(initialI, n + 1):
            prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
        self.invFactorial_ += nextArr
        return self.invFactorial_[n]

class Combination:
    def __init__(self, MOD):
        self.MOD = MOD
        self.factorial = Factorial(MOD)

    def ncr(self, n, k):
        if k < 0 or n < k:
            return 0
        k = min(k, n - k)
        f = self.factorial
        return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
mod=10**9+7
omod=998244353
#-------------------------------------------------------------------------
prime = [True for i in range(10)]
pp=[0]*10
def SieveOfEratosthenes(n=10):
    p = 2
    c=0
    while (p * p <= n):

        if (prime[p] == True):
            c+=1
            for i in range(p, n+1, p):
                pp[i]+=1
                prime[i] = False
        p += 1
#---------------------------------Binary Search------------------------------------------
def binarySearch(arr, n, key):
    left = 0
    right = n-1
    mid = 0
    res=0
    while (left <= right):
        mid = (right + left)//2
        if (arr[mid][0] > key):
            right = mid-1
        else:
            res=mid
            left = mid + 1
    return res
#---------------------------------running code------------------------------------------
def check(a,k):
    s=set([0])
    for i in range (len(a)):
        s1=set()
        for j in s:
            s1.add(a[i]+j)
        s=s.union(s1)
        if k in s:
            return True
    return False

for _ in range (1):
    n=int(input())
    a=list(map(int,input().split()))
    s=sum(a)
    d=defaultdict(int)
    for i in a:
        d[i]+=1
    mnd,mxd=min(d.values()),max(d.values())
    occ=0
    if s%2:
        print(0)
        continue
    if check(a,s//2)==False:
        print(0)
        continue
    mn,mx=min(a),max(a)
    m,o=0,0
    i1,i2,i3,i4=[0]*4
    for i in range (n):
        if a[i]%2:
            o=i+1
        elif (a[i]//2)%2:
            m=i+1
        if a[i]==mn:
            i1=i+1
        if a[i]==mx:
            i2=i+1
        if a[i]==mnd:
            i3=i+1
        if a[i]==mxd:
            i4=i+1
    print(1)
    if o:
        print(o)
    elif m:
        print(m)
    else:
        if check(list(a[:i1-1]+a[i1:]),(s-mn)//2)==False:
            print(i1)
        elif check(list(a[:i2-1]+a[i2:]),(s-mx)//2)==False:
            print(i2)
        elif check(list(a[:i3-1]+a[i3:]),(s-mnd)//2)==False:
            print(i3)
        elif check(list(a[:i4-1]+a[i4:]),(s-mxd)//2)==False:
            print(i4)

"""**************************************************************\
                   BISMILLAHIR RAHMANIR RAHIM
****************************************************************
               AUTHOR NAME: MD. TAHURUZZOHA TUHIN
\**************************************************************"""

#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from math import gcd
from io import BytesIO, IOBase
from heapq import heappush,heappop,heapify
from collections import defaultdict, Counter, deque

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

# Start FASTIO
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

def prod(a, mod=10 ** 9 + 7):
    ans = 1
    for each in a:
        ans = (ans * each) % mod
    return ans

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def lcm(a, b): return a * b // gcd(a, b)

def binary(x, length=16):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def check_freq(x):
    freq = {}
    for c in set(x):
       freq[c] = x.count(c)
    return freq

def ii(): return int(input())
def si(): return input()
def mi(): return map(int, input().strip().split(" "))
def li(): return list(mi())
MAXX = 100000000

'''**************Solution is Here***********'''
def equalPartition(sm,N, arr):
        # code here
        s=sm
        #s has to be even for halves to exist
        # if s%2==1:
        #     return 0
        mat=[]
        # p=s//2
        p=sm

        #initialization of DP table
        for i in range(N+1):
            row=[]
            for j in range(p+1):
                if j==0:
                    row.append(1)
                elif i==0:
                    row.append(0)
                else:
                    row.append(2)
            mat.append(row)
       # print(mat)

        # DP table
        for i in range(1,N+1):
            for j in range(1,p+1):
                if arr[i-1]>j:
                    mat[i][j]=mat[i-1][j]

                else:
                    mat[i][j]=max(mat[i-1][j],mat[i-1][j-arr[i-1]])
        return mat[-1][-1]

def solve(arr,n):
    sm = sum(arr)
    if sm%2==1:
        return False
    return 1

def main():
    T = 1
    for _ in range(T):
        n = ii()
        A = li()
        # if (solve(a, n)) == True:
        #     ans = -1
        #     for i in range(n):
        #         b = [0]*n
        #         k = 0
        #         for j in range(n):
        #             if i==j:
        #                 continue
        #             b[k] = a[j]
        #             k += 1
        #         if (solve(b,k) == False):
        #             ans = i
        #             break
        #         # if (solve(b,k) == True):
        #         #     ans = i+1
        #         #     break
        #     print(1)
        #     print(ans+1)
        # n = int(input())
        # A = list(map(int,input().split()))
        s = sum(A)
        M = 2*10**5+1
        dp = [0]*(M+5)
        dp[0] = 1
        g = A[0]
        ind = 0
        for a in A:
            g = gcd(a,g)
            for j in range(M)[::-1]:
                if j+a <= M:
                    dp[j+a] |= dp[j]
        if s%2 or dp[s//2] == 0:
            print(0)
            exit()
        for i,a in enumerate(A,1):
            if (a//g)%2:
                print(1)
                print(i)
                exit()

        else:
            print(0)

# End FASTIO
if __name__ == "__main__":
    main()

def solve(arr):
    s = sum(arr)
    if s & 1:
        print(0)
        return
    half = s // 2
    dp = [False] * (half + 1)
    dp[0] = True
    for a in arr:
        if a > half:
            print(0)
            return
        for j in range(half, a - 1, -1):
            dp[j] = dp[j] or dp[j - a]
    if not dp[-1]:
        print(0)
        return

    found = [None] * 13
    for idx, a in enumerate(arr):
        for i in range(13):
            if not found[i] and (a >> i) & 1:
                found[i] = idx + 1
    for i in range(13):
        if found[i] is not None:
            print(1)
            print(found[i])
            return

# t = int(input())
# for _ in range(t):
    # n, k = [int(x) for x in input().split()]
n = int(input())
arr = [int(x) for x in input().split()]
solve(arr)

import math
import sys
import collections
import bisect
import time
import random
from itertools import permutations
def get_ints():return map(int, sys.stdin.readline().strip().split())
def get_list():return list(map(int, sys.stdin.readline().strip().split()))
def get_string():return sys.stdin.readline().strip()

def findPartition(arr, n):
	Sum = 0
	for i in range(n):
		Sum += arr[i]
	if (Sum % 2 != 0):
		return 0
	part = [0] * ((Sum // 2) + 1)
	for i in range((Sum // 2) + 1):
		part[i] = 0
	for i in range(n):
		for j in range(Sum // 2, arr[i] - 1, -1):
			if (part[j - arr[i]] == 1 or j == arr[i]):
				part[j] = 1
	return part[Sum // 2]
for t in range(1):
	n=int(input())
	arr=get_list()
	if findPartition(arr, n) == False:
		print(0)
		continue
	p=0
	for i in range(n):
		if arr[i]%2==1:
			print(1)
			print(i+1)
			p+=1
			break
	if p>0:
		continue
	for i in range(n):
		temp=arr[:i]+arr[i+1:]
		if findPartition(temp, n-1) == False:
			print(1)
			print(i+1)
			break

from sys import stdin, stdout

get_string = lambda: stdin.readline().strip(' ')
get_intmap = lambda: map( int, get_string().split(' ') )

def testcase():
    n = int(input())
    l = list(get_intmap())
    suml = sum(l)
    if suml % 2 == 1:# odd sum array cant be bipartitioned
        print(0); return
    #try to partition the even sum array by
    #doing a knapsack on half the sum as weight of sack
    dp = [0] * (suml + 5)
    dp[0] = 1
    for item in l:
        for ind in range(len(dp)-1,-1,-1):
            if dp[ind] == 1:
                dp[ind + item] = 1
    if dp[suml//2]:#knapsack success/ partition possible
        print(1)
        #find odd number or number with smallest possible Least significant bit
        min_lsb_pos = 32
        min_ind = -1
        for ind, i in enumerate(l):
            lsb_pos = 0
            while i & (1 << lsb_pos) == 0:
                lsb_pos += 1
            if min_lsb_pos > lsb_pos:
                min_lsb_pos = lsb_pos
                min_ind     = ind
        print(min_ind + 1)
    else:
        print(0)

testcase();quit()
for t in range(int(input())):
    testcase()

n = int(input())
a = [int(i) for i in input().split()]
sm = sum(a)
#print(sorted(a))
#print(sm)
if sm % 2==1:
    print(0)
else:
    target = sm // 2
    dp =[[0 for j in range(target + 1)] for i in range(n+1)]
    dp[0][0] = 1
    x =[]
    c ={0:[]}
    boo = True
    for i in range(1,n+1):
        for j in range(target):
            if dp[i-1][j]:
                dp[i][j] = 1
                if(j+a[i-1] <= target):
                    dp[i][j+a[i-1]] = 1

    #x = dp[-1][-1][-1]
    if(not dp[-1][-1]):
        print(0)
        exit()

    while(boo):
        for i in range(n):
            if a[i]%2:
                print(1)
                print(i+1)
                exit()
            a[i]/=2

def zip_sorted(a,b):

	# sorted  by a
	a,b = zip(*sorted(zip(a,b)))
	# sorted by b
	sorted(zip(a, b), key=lambda x: x[1])

	return a,b

def number_to_list(a):

	b = []

	while a>=1:

		c = a%10

		a = int(a/10)

		b.append(c)

	return list(reversed(b))

def str_list_to_int_list(a):

	a = list(map(int,a))

	return a

def make_1d_array(n,inti= 0):

	a = [inti for _ in range(n)]

	return a

def make_2d_array(n,m,inti= 0):

	a = [[inti for _ in range(m)] for _ in range(n)]

	return a

def make_3d_array(n,m,k,inti= 0):

	a = [[[inti for _ in range(k)] for _ in range(m)] for _ in range(n)]

	return a

def gcd(a,b):

	if(b==0):
		return a

	else:
		return gcd(b,a%b);

import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input()))

# def solve(sum1,dp):

# 	prev = [[] for i in range(sum1+1)]

# 	for i in range(n):

# 		dp = [prev[j] for j in range(sum1+1)]

# 		for j in range(sum1+1):

'''

#########################
#	Optimizations
#
#	1)	loop from backwards thus only one loop required
#	2)	memeroization of only required index of ans
#
#########################

n, = I()
a   = I()
sum1 = sum(a)

if sum1%2==0:

	sum1 = sum1//2

	dp = [False]*(sum1+1)
	dp[0] = True
	# ans = [[] for j in range(sum1+1)]
	from collections import defaultdict
	ans = defaultdict(list)
	for i in range(n):
		for j in range(sum1,-1,-1):
			if j-a[i]>=0:
				if dp[j-a[i]]:
					if dp[j]:
						if len(ans[j])>(len(ans[j-a[i]])+1):
							ans[j] = ans[j-a[i]]+[i+1]
					else:
						ans[j] = ans[j-a[i]]+[i+1]
				dp[j] = dp[j] or dp[j-a[i]]

	# print(ans)

	idx = -1

	# print(dp[sum1],ans[sum1])

	if dp[sum1]:

		min1 = 10**10

		for i in ans:

			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

				if len(ans[i])<min1:

					min1 = len(ans[i])

					idx  = i

		print(len(ans[idx]))
		print(*ans[idx])

	else:

		print(0)

else:

	print(0)

'''

#########################
#	Optimizations
#
#	2)	memeroization of only required index of ans
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	prev = [False]*(sum1+1)
# 	prev[0] = True
# 	# ans = [[] for j in range(sum1+1)]
# 	from collections import defaultdict
# 	# ans = defaultdict(list)
# 	ans = defaultdict(list)
# 	for i in range(n):
# 		dp = prev.copy()
# 		for j in range(sum1+1):
# 			if j-a[i]>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if len(ans[j])>(len(ans[j-a[i]])+1):
# 							ans[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans[j] = ans[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or prev[j-a[i]]
# 		prev = dp.copy()

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in ans:

# 			if dp[i]  and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(ans[i])<min1:

# 					min1 = len(ans[i])

# 					idx  = i

# 		print(len(ans[idx]))
# 		print(*ans[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#	Optimizations
#
#	1)	None
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	prev = [False]*(sum1+1)
# 	prev[0] = True
# 	prev_a = [[] for j in range(sum1+1)]
# 	# from collections import defaultdict
# 	for i in range(n):
# 		dp = prev.copy()
# 		dp_a = [prev_a[j] for j in range(len(prev_a))]
# 		for j in range(sum1+1):
# 			if j-a[i]>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if len(dp_a[j])>(len(prev_a[j-a[i]])+1):
# 							dp_a[j] = prev_a[j-a[i]]+[i+1]
# 					else:
# 						dp_a[j] = prev_a[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or prev[j-a[i]]
# 		prev = dp.copy()
# 		prev_a = [dp_a[j] for j in range(len(dp_a))]

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in range(sum1+1):

# 			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(dp_a[i])<min1:

# 					min1 = len(dp_a[i])

# 					idx  = i

# 		print(len(dp_a[idx]))
# 		print(*dp_a[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#
#	WA
#
#########################

# n, = I()
# a   = I()
# sum1 = sum(a)

# if sum1%2==0:

# 	sum1 = sum1//2

# 	dp = [False]*(sum1+1)
# 	dp[0] = True
# 	dp_a = [[] for j in range(sum1+1)]
# 	# from collections import defaultdict
# 	for i in range(n):
# 		for j in range(sum1,-1,-1):
# 			if j-a[i]>=0:
# 				if dp[j-a[i]]:
# 					if dp[j]:
# 						if len(dp_a[j])>(len(dp_a[j-a[i]])+1):
# 							dp_a[j] = dp_a[j-a[i]]+[i+1]
# 					else:
# 						dp_a[j] = dp_a[j-a[i]]+[i+1]
# 				dp[j] = dp[j] or dp[j-a[i]]

# 	# print(ans)

# 	idx = -1

# 	# print(dp[sum1],ans[sum1])

# 	if dp[sum1]:

# 		min1 = 10**10

# 		for i in range(sum1+1):

# 			if dp[i] and (i%2!=0 or dp[(2*sum1-i)//2]==False):

# 				if len(dp_a[i])<min1:

# 					min1 = len(dp_a[i])

# 					idx  = i

# 		print(len(dp_a[idx]))
# 		print(*dp_a[idx])

# 	else:

# 		print(0)

# else:

# 	print(0)

#########################
#
#	WA of contest
#	after changing it gives TLE
#########################

# import sys
# input = sys.stdin.readline
# I = lambda : list(map(int,input().split()))
# S = lambda : list(map(str,input()))

# n, = I()
# a   = I()
# sum1 = sum(a)
# if sum1%2==0:
# 	sum1 = sum1//2
# 	prev = [[False,10**10] for i in range(sum1+1)]
# 	ans  = [[] for i in range(sum1+1)]
# 	prev[0] = [True,0]
# 	for i in range(n):
# 		dp = [[prev[j][k] for k in range(len(prev[j]))] for j in range(sum1+1)]
# 		ans1 = [[ans[j][k] for k in range(len(ans[j]))] for j in range(sum1+1)]
# 		for j in range(sum1+1):
# 			if (j-a[i])>=0:
# 				if prev[j-a[i]][0]:
# 					if dp[j][0]:
# 						if (prev[j-a[i]][1]+1)<dp[j][1]:
# 							ans1[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans1[j] = ans[j-a[i]]+[i+1]
# 					dp[j][1] = min(dp[j][1],prev[j-a[i]][1]+1)
# 					dp[j][0] = True
# 		prev = [[dp[j][k] for k in range(len(dp[j]))]  for j in range(sum1+1)]
# 		ans = [[ans1[j][k] for k in range(len(ans1[j]))] for j in range(sum1+1)]
# 	if prev[sum1][0]:
# 		min1 = prev[sum1][1]
# 		idx = sum1
# 		for i in range(sum1+1):
# 			if prev[i][0] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2][0]==False):
# 				if min1>prev[i][1]:
# 					idx = i
# 				min1 = min(min1,prev[i][1])
# 		print(len(ans[idx]))
# 		print(*ans[idx])
# 	else:
# 		print(0)
# else:
# 	print(0)

#########################
#
#	WA of contest
# pass

#########################

# n, = I()
# a   = I()
# sum1 = sum(a)
# if sum1%2==0:
# 	sum1 = sum1//2
# 	prev = [False for i in range(sum1+1)]
# 	ans  = [[] for i in range(sum1+1)]
# 	prev[0] = True
# 	for i in range(n):
# 		dp = prev.copy()
# 		ans1 = [ans[j] for j in range(sum1+1)]
# 		for j in range(sum1+1):
# 			if (j-a[i])>=0:
# 				if prev[j-a[i]]:
# 					if dp[j]:
# 						if (len(ans[j-a[i]])+1)<len(ans1[j]):
# 							ans1[j] = ans[j-a[i]]+[i+1]
# 					else:
# 						ans1[j] = ans[j-a[i]]+[i+1]
# 					dp[j] = True
# 		prev = dp.copy()
# 		ans = [ans1[j] for j in range(sum1+1)]
# 	if prev[sum1]:
# 		min1 = 10**10
# 		idx = -1
# 		for i in range(sum1+1):
# 			if prev[i] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2]==False):
# 				if min1>len(ans[i]):
# 					idx = i
# 				min1 = min(min1,len(ans[i]))
# 		print(len(ans[idx]))
# 		print(*ans[idx])
# 	else:
# 		print(0)
# else:
# 	print(0)

# 1)	less loop while copying
# 2)	always intilize with -1
# 3)

#########################
#
#	WA of contest
# pass

#########################

n, = I()
a   = I()
sum1 = sum(a)
if sum1%2==0:
	sum1 = sum1//2
	prev = [False for i in range(sum1+1)]
	prev1 = [0 for i in range(sum1+1)]
	ans  = [[] for i in range(sum1+1)]
	prev[0] = (True,0)
	for i in range(n):
		dp = prev.copy()
		dp1 = prev1.copy()
		ans1 = [ans[j][:] for j in range(sum1+1)]
		for j in range(sum1+1):
			if (j-a[i])>=0:
				if prev[j-a[i]]:
					if dp[j]:
						if (len(ans[j-a[i]])+1)<len(ans1[j]):
							ans1[j] = ans[j-a[i]]+[i+1]
					else:
						ans1[j] = ans[j-a[i]]+[i+1]
					dp[j] = True
		prev = dp.copy()
		prev1 = dp1.copy()
		ans = [ans1[j] for j in range(sum1+1)]
	if prev[sum1]:
		min1 = 10**10
		idx = -1
		for i in range(sum1+1):
			if prev[i] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2]==False):
				if min1>len(ans[i]):
					idx = i
				min1 = min(min1,len(ans[i]))
		print(len(ans[idx]))
		print(*ans[idx])
	else:
		print(0)
else:
	print(0)

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    arr = list(map(int, input().split()))
    S = sum(arr)
    if S % 2:
        print(0)
        return

    dp = [False for _ in range(S + 1)]
    dp[arr[-1]] = True
    dp[0] = True

    for i in range(n - 2, -1, -1):
        for s in range(S + 1, 0, -1):
            if s - arr[i] >= 0 and dp[s - arr[i]]:
                dp[s] = dp[s-arr[i]]

    if not dp[S // 2]:
        print(0)
    else:
        cnt = float("inf")
        ans = 0
        for i in range(n):
            tmp = 0
            num = arr[i]
            while num and num % 2 == 0:
                num //= 2
                tmp += 1
            if tmp < cnt:
                cnt = tmp
                ans = i
        print(1)
        print(ans+1)
    return

solve()

def helper2(a,tar):
    pool = [0] * 200005
    pool[0] = 1
    for i in range(len(a)):
        child = []
        for j in range(tar):
            if pool[j] == 1:
                child.append(j+a[i])
        for c in child:
            pool[c]= 1

    return pool[tar] == 1

def helper(a):

    if sum(a) % 2 == 1:
        return -1

    if helper2(a,sum(a)//2):
        while True:
            for i in range(len(a)):
                if a[i] % 2 == 1:
                    return i
                a[i] = a[i] // 2
    else:
        return -1

#t = int(input())
#for i in range(t):
n = int(input())
a = list(map(int,input().split(" ")))
#print(len(a))
res = helper(a)
if res == -1:
    print(0)
    print()
else:
    print(1)
    print(res+1)

def partition(arr,n):
    s=sum(arr)//2
    if sum(arr)%2 !=0:
        return False
    else:
        dp=[[False for j in range(s+1)] for i in range(n+1)]
        for i in range(n+1):
            for j in range(s+1):
                if i==0:
                    dp[i][j]=False
                if j==0:
                    dp[i][j]=True
                elif j>=arr[i-1]:
                    dp[i][j]=dp[i-1][j-arr[i-1]] or dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j]
        return dp[n][s]
def solve(arr,n):
    count=0
    for i in range(n):
        if arr[i]%2:
            count+=1
            print(count)
            print(i+1)
            return

    # print(count)
    f=0
    while  f!=1:

        for k in range(n):
            arr[k]=arr[k]//2

            if arr[k]%2:
                print(1)
                print(k+1)
                f=1
                return

n=int(input())
arr=list(map(int,input().split()))
res=(partition(arr,n))
count=0
if res==False:
    print(0)
else:
    (solve(arr,n))

from functools import lru_cache

def gcd(a,b):
	if b==0:
		return(a)
	return(gcd(b,a%b))

@lru_cache(None)
def subsetSum(curSum,totalSum,idx,array):

	if idx>=len(array):
		return(False)

	if totalSum==2*curSum:
		return(True)

	if 2*curSum>totalSum:
		return(False)
	withVal=subsetSum(curSum+array[idx],totalSum,idx+1,array)
	if withVal:
		return(True)
	withOutVal=subsetSum(curSum,totalSum,idx+1,array)

	return(withOutVal)

n=int(input())
array=tuple(map(int,input().split()))
totalSum=sum(array)

if totalSum%2!=0 or  not subsetSum(0,totalSum,0,array):
	print(0)

else:
	for idx,val in enumerate(array):
		if val%2!=0:
			print(1)
			print(idx+1)
			break
	else:
		ansIdx=0
		ansCount=float('inf')
		for idx,val in enumerate(array):
			count=0
			while val%2==0:
				count+=1
				val=val/2
			if count<ansCount:
				ansCount=count
				ansIdx=idx
		print(1)
		print(ansIdx+1)

import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

def gcd(a, b):
    if a == 0:
        return b
    return gcd(b % a, a)

def lcm(a, b):
    return (a * b) / gcd(a, b)

mod = int(1e9) + 7

def power(k, n):
    if n == 0:
        return 1
    if n % 2:
        return (power(k, n - 1) * k) % mod
    t = power(k, n // 2)
    return (t * t) % mod

def totalPrimeFactors(n):
    count = 0
    if (n % 2) == 0:
        count += 1
        while (n % 2) == 0:
            n //= 2

    i = 3
    while i * i <= n:
        if (n % i) == 0:
            count += 1
            while (n % i) == 0:
                n //= i
        i += 2
    if n > 2:
        count += 1
    return count

# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
#     spf[1] = 1
#     for i in range(2, MAXN):
#         spf[i] = i
#     for i in range(4, MAXN, 2):
#         spf[i] = 2
#
#     for i in range(3, mt.ceil(mt.sqrt(MAXN))):
#         if (spf[i] == i):
#             for j in range(i * i, MAXN, i):
#                 if (spf[j] == j):
#                     spf[j] = i
#
#
# def getFactorization(x):
#     ret = 0
#     while (x != 1):
#         k = spf[x]
#         ret += 1
#         # ret.add(spf[x])
#         while x % k == 0:
#             x //= k
#
#     return ret

# Driver code

# precalculating Smallest Prime Factor
# sieve()

def main():
    n = int(input())
    arr = list(map(int, input().split()))
    k = sum(arr)
    if k % 2:
        print(0)
    else:
        Sum = k
        part = [0 for i in range((Sum // 2) + 1)]
        for i in range(n):
            for j in range(Sum // 2, arr[i] - 1, -1):
                if part[j - arr[i]] == 1 or j == arr[i]:
                    part[j] = 1
        #print(part)
        if part[Sum // 2] != 1:
            print(0)
        else:
            for i in range(n):
                if arr[i]%2==1 or part[Sum//2-(arr[i]//2)]==0:
                    f = i + 1
                    break
            print(1)
            print(f)

    return

if __name__ == "__main__":
    main()

n = int(input())
arr = list(map(int,input().split()))

dp = [[0 for _ in range(200001)] for __ in range(n + 1)]
dp[0][0] = 1
pref = [0 for i in range(n)]
pref[0] = arr[0]
for i in range(1,n):
    pref[i] = pref[i - 1] + arr[i]
for i in range(1,n + 1):
    for j in range(1,200001):
        if j > pref[i - 1]:
            break
        if j - arr[i - 1] >= 0:
            dp[i][j] = dp[i - 1][j - arr[i - 1]]|dp[i - 1][j]

s = sum(arr)
if s % 2 or not dp[n][s//2]:
    print(0)
else:
    for index,i in enumerate(arr):
        if i % 2:
            print(1)
            print(index + 1)
            exit()
    while True:
        for i in range(n):
            arr[i] = arr[i]//2
            if arr[i]%2:
                print(1)
                print(i + 1)
                exit()

import math, sys
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop

MOD = int(1e9) + 7

def main():
	n = int(input())
	arr = list(map(int, input().split()))

	total = sum(arr)
	if total % 2 != 0:
		print(0)
		return

	dp = [[0 for i in range(n + 1)] for j in range(total // 2 + 1)]

	for i in range(n):
		dp[0][i] = 1

	for i in range(1, total // 2 + 1):
		for j in range(1, n + 1):
			dp[i][j] = dp[i][j - 1]
			if i >= arr[j - 1]:
				dp[i][j] = dp[i][j] | dp[i - arr[j - 1]][j - 1]

	if dp[total // 2][n]:
		i = 0
		while True:
			if arr[i] % 2 == 1:
				print(1)
				print(i + 1)
				return

			arr[i] //= 2
			i += 1
			if i == n: i = 0
	else:
		print(0)

t = 1
# t = int(input())
for _ in range(t):
	main()

n = int(input())
l = list(map(int, input().split()))
sum1 = sum(l)
if sum1%2 == 1:
    print(0)
else:
    prev_dict = {}
    prev_dict[0] = True
    new_dict = prev_dict.copy()
    for i in range(n):
        for val in prev_dict:
            if val + l[i] not in new_dict:
                new_dict[val + l[i]] = True
        prev_dict = new_dict.copy()
    if sum1//2 not in new_dict:
        print(0)
    else:
        found = -1
        for i in range(n):
            if l[i]%2 == 1:
                save = i + 1
                found = 1
                break
        if found == 1:
            print(1)
            print(save)
        else:
            check = 4
            save = -1
            while True:
                for i in range(n):
                    if l[i]%check != 0:
                        save = i + 1
                        break
                if save > -1:
                    break
                else:
                    check *= 2
            print(1)
            print(save)

import functools, math, sys

input = sys.stdin.readline

def knapsack(capacity, utility, weight):
    backpack = [[0 for i in range(capacity + 1)] for j in range(2)]
    for i in range(len(weight)):
        if i % 2 == 0:
            for j in range(capacity + 1):
                if weight[i] <= j:
                    backpack[1][j] = max(utility[i] + backpack[0][j - weight[i]], backpack[0][j])
                else:
                    backpack[1][j] = backpack[0][j]
        else:
            for j in range(capacity + 1):
                if weight[i] <= j:
                    backpack[0][j] = max(utility[i] + backpack[1][j - weight[i]], backpack[1][j])
                else:
                    backpack[0][j] = backpack[1][j]
    return backpack[len(weight) % 2][capacity]

n, values = int(input()), [int(i) for i in input().split()]
tot, tar = sum(values), sum(values) // 2
if tot % 2 or knapsack(tar, values, values) != tar:
    print(0)
    sys.exit()
gcd = functools.reduce(math.gcd, values)
values = [values[i] // gcd for i in range(n)]
for i in range(n): # remove the odd one out
    if values[i] % 2:
        print(1)
        print(i + 1)
        sys.exit()

n = int(input())
a = list(map(int, input().split()))

S = sum(a)
dp = [False] * (S + 1)
dp[0] = True

for x in a:
    for y in range(S - x, -1, -1):
        dp[x + y] = dp[x + y] or dp[y]

if S % 2 == 1 or not dp[S // 2]:
    print(0)
    exit()

else:
    norm = 30
    res = -1
    for i, x in enumerate(a):
        cnt = 0
        while x & 1 == 0:
            cnt += 1
            x >>= 1
        if cnt < norm:
            norm = cnt
            res = i

    print(1)
    print(res + 1)

def fp(arr, n) :
    Sum = 0
    for i in range(n) :
        Sum += arr[i]
    if (Sum % 2 != 0) :
        return 0
    part = [0] * ((Sum // 2) + 1)
    for i in range((Sum // 2) + 1) :
        part[i] = 0
    for i in range(n) :
        for j in range(Sum // 2, arr[i] - 1, -1) :
            if (part[j - arr[i]] == 1 or j == arr[i]) :
                part[j] = 1
    return part[Sum // 2]

n = int(input())
arr = list(map(int,input().split()))
b = arr.copy()
flag = 0
if fp(arr,n)==True:
    while True:
        for i in range(n):
            if arr[i]&1:
                print(1)
                print(i+1)
                flag = 1
                break
            arr[i] //= 2
        if flag==1:
            break
else:
    print(0)

n = int(input())
arr = list(map(int, input().split()))

if sum(arr) & 1:
    print(0)
else:
    even, odd = 0, 0
    for i in arr:
        if i & 1:
            odd += 1
        else:
            even += 1
    target = sum(arr) // 2
    n = len(arr)
    dp = [[False for i in range(target + 1)] for j in range(n + 1)]
    for i in range(n + 1):
        dp[i][0] = True
    for i in range(1, n + 1):
        for j in range(1, target + 1):
            if arr[i - 1] > j:
                dp[i][j] = dp[i - 1][j]
            else:
                dp[i][j] = dp[i - 1][j] or dp[i - 1][j - arr[i - 1]]
    if dp[n][target]:
        if odd:
            for i in range(len(arr)):
                if arr[i] & 1:
                    print(1)
                    print(i + 1)
                    exit()
        else:
            min_index = 10 ** 9
            ans = -1
            for i in range(len(arr)):
                for j in range(32):
                    if arr[i] & (1 << j):
                        if j < min_index:
                            min_index = min(min_index, j)
                            ans = i + 1
                            break
            print(1)
            print(ans)
    else:
        print(0)

def solve(arr):
    s = sum(arr)
    if s & 1:
        print(0)
        return
    half = s // 2
    dp = [False] * (half + 1)
    dp[0] = True
    for a in arr:
        if a > half:
            print(0)
            return
        for j in range(half, a - 1, -1):
            dp[j] = dp[j] or dp[j - a]
    if not dp[-1]:
        print(0)
        return

    found = [None] * 13
    for idx, a in enumerate(arr):
        for i in range(13):
            if not found[i] and (a >> i) & 1:
                found[i] = idx + 1
    for i in range(13):
        if found[i] is not None:
            print(1)
            print(found[i])
            return

# t = int(input())
# for _ in range(t):
    # n, k = [int(x) for x in input().split()]
n = int(input())
arr = [int(x) for x in input().split()]
solve(arr)

#!/usr/bin/env python
#from __future__ import division, print_function
import math
import os
import sys
#from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import accumulate,combinations,permutations,combinations_with_replacement,product
from collections import *
#import timeit,time
#sys.setrecursionlimit(10**5)
M = 10 ** 9 + 7
import heapq

# print(math.factorial(5))
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
# sys.setrecursionlimit(10**6)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

def inp(): return sys.stdin.readline().rstrip("\r\n")  # for fast input

def out(var): sys.stdout.write(str(var))  # for fast output, always take string

def lis(): return list(map(int, inp().split()))

def stringlis(): return list(map(str, inp().split()))

def sep(): return map(int, inp().split())

def strsep(): return map(str, inp().split())

def fsep(): return map(float, inp().split())

def inpu(): return int(inp())

# -----------------------------------------------------------------

def regularbracket(t):
    p = 0
    for i in t:
        if i == "(":
            p += 1
        else:
            p -= 1
        if p < 0:
            return False
    else:
        if p > 0:
            return False
        else:
            return True
# -------------------------------------------------
def binarySearchcount(arr, n, key):
    left = 0
    right = n - 1
    count = 0
    while (left <= right):
        mid = int((right + left) / 2)
        # Check if middle element is
        # less than or equal to key
        if (arr[mid] <= key):
            count = mid + 1
            left = mid + 1
        # If key is smaller, ignore right half
        else:
            right = mid - 1
    return count

#--------------------------------------------------binery search
def binarySearch(arr, n, key):
    left = 0
    right = n - 1
    while (left <= right):
        mid = ((right + left) // 2)
        if arr[mid]==key:
            return mid
        if (arr[mid] <= key):
            left = mid + 1
        # If key is smaller, ignore right half
        else:
            right = mid - 1
    return -1
#-------------------------------------------------ternary search
def ternarysearch(arr,n,key):
    l,r=0,n-1
    while(l<=r):
        mid = (-l+r)//3 + l
        mid2 = mid + (-l+r)//3
        if arr[mid]==key:
            return mid
        if arr[mid2]==key:
            return mid2
        if arr[mid]>key:
            r=mid-1
        elif arr[mid2]<key:
            l=mid2+1
        else:
            l=mid+1
            r=mid2-1
    return -1
# ------------------------------reverse string(pallindrome)
def reverse1(string):
    pp = ""
    for i in string[::-1]:
        pp += i
    if pp == string:
        return True
    return False

# --------------------------------reverse list(paindrome)
def reverse2(list1):
    l = []
    for i in list1[::-1]:
        l.append(i)
    if l == list1:
        return True
    return False

def mex(list1):
    # list1 = sorted(list1)
    p = max(list1) + 1
    for i in range(len(list1)):
        if list1[i] != i:
            p = i
            break
    return p

def sumofdigits(n):
    n = str(n)
    s1 = 0
    for i in n:
        s1 += int(i)
    return s1

def perfect_square(n):
    s = math.sqrt(n)
    if s == int(s):
        return True
    return False

# -----------------------------roman
def roman_number(x):
    if x > 15999:
        return
    value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
    symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
    roman = ""
    i = 0
    while x > 0:
        div = x // value[i]
        x = x % value[i]
        while div:
            roman += symbol[i]
            div -= 1
        i += 1
    return roman

def soretd(s):
    for i in range(1, len(s)):
        if s[i - 1] > s[i]:
            return False
    return True

# print(soretd("1"))
# ---------------------------
def countRhombi(h, w):
    ct = 0
    for i in range(2, h + 1, 2):
        for j in range(2, w + 1, 2):
            ct += (h - i + 1) * (w - j + 1)
    return ct

def countrhombi2(h, w):
    return ((h * h) // 4) * ((w * w) // 4)

# ---------------------------------
def binpow(a, b):
    if b == 0:
        return 1
    else:
        res = binpow(a, b // 2)
    if b % 2 != 0:
        return res * res * a
    else:
        return res * res

# -------------------------------------------------------
def binpowmodulus(a, b, M):
    if b==1:
        return a%M
    if b==0:
        return 1
    if b%2==0:
        ans=binpowmodulus(a,b//2,M)
        return (ans*ans)%(M)
    else:
        ans=binpowmodulus(a,(b-1)//2,M)
        return ((ans*a)%M * ans)%M
# -------------------------------------------------------------
def coprime_to_n(n):
    result = n
    i = 2
    while (i * i <= n):
        if (n % i == 0):
            while (n % i == 0):
                n //= i
            result -= result // i
        i += 1
    if (n > 1):
        result -= result // n
    return result

def luckynumwithequalnumberoffourandseven(x,n,a):
    if x >= n and str(x).count("4") == str(x).count("7"):
        a.append(x)
    else:
        if x < 1e12:
            luckynumwithequalnumberoffourandseven(x * 10 + 4,n,a)
            luckynumwithequalnumberoffourandseven(x * 10 + 7,n,a)
    return a
#----------------------
def luckynum(x,l,r,a):
    if x>=l and x<=r:
        a.append(x)
    if x>r:
        a.append(x)
        return a
    if x < 1e10:
            luckynum(x * 10 + 4, l,r,a)
            luckynum(x * 10 + 7, l,r,a)
    return a

def luckynuber(x, n, a):
    p = set(str(x))
    if len(p) <= 2:
        a.append(x)
    if x < n:
        luckynuber(x + 1, n, a)
    return a

# ------------------------------------------------------interactive problems

def interact(type, x):
    if type == "r":
        inp = input()
        return inp.strip()
    else:
        print(x, flush=True)

# ------------------------------------------------------------------zero at end of factorial of a number
def findTrailingZeros(n):
    # Initialize result
    count = 0

    # Keep dividing n by
    # 5 & update Count
    while (n >= 5):
        n //= 5
        count += n

    return count

# -----------------------------------------------merge sort
# Python program for implementation of MergeSort
def mergeSort(arr):
    if len(arr) > 1:

        # Finding the mid of the array
        mid = len(arr) // 2

        # Dividing the array elements
        L = arr[:mid]

        # into 2 halves
        R = arr[mid:]

        # Sorting the first half
        mergeSort(L)

        # Sorting the second half
        mergeSort(R)

        i = j = k = 0

        # Copy data to temp arrays L[] and R[]
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        # Checking if any element was left
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# -----------------------------------------------lucky number with two lucky any digits
res = set()
def solven(p, l, a, b, n):  # given number
    if p > n or l > 10:
        return
    if p > 0:
        res.add(p)
    solven(p * 10 + a, l + 1, a, b, n)
    solven(p * 10 + b, l + 1, a, b, n)

# problem
"""
n = int(input())
for a in range(0, 10):
    for b in range(0, a):
        solve(0, 0)
print(len(res))
"""

# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index, d):
    print(*subset)
    s = sum(subset)
    d.append(s)
    for i in range(index, len(A)):
        # include the A[i] in subset.
        subset.append(A[i])

        # move onto the next element.
        subsetsUtil(A, subset, i + 1, d)

        # exclude the A[i] from subset and
        # triggers backtracking.
        subset.pop(-1)
    return d

def subsetSums(arr, l, r, d, sum=0):
    if l > r:
        d.append(sum)
        return
    subsetSums(arr, l + 1, r, d, sum + arr[l])

    # Subset excluding arr[l]
    subsetSums(arr, l + 1, r, d, sum)
    return d

def print_factors(x):
    factors = []
    for i in range(1, x + 1):
        if x % i == 0:
            factors.append(i)
    return (factors)

# -----------------------------------------------
def calc(X, d, ans, D):
    # print(X,d)
    if len(X) == 0:
        return

    i = X.index(max(X))
    ans[D[max(X)]] = d

    Y = X[:i]
    Z = X[i + 1:]

    calc(Y, d + 1, ans, D)
    calc(Z, d + 1, ans, D)

# ---------------------------------------

def factorization(n, l):
    c = n
    if prime(n) == True:
        l.append(n)
        return l
    for i in range(2, c):
        if n == 1:
            break
        while n % i == 0:
            l.append(i)
            n = n // i
    return l

# endregion------------------------------
def good(b):
    l = []
    i = 0
    while (len(b) != 0):
        if b[i] < b[len(b) - 1 - i]:
            l.append(b[i])
            b.remove(b[i])
        else:
            l.append(b[len(b) - 1 - i])
            b.remove(b[len(b) - 1 - i])
    if l == sorted(l):
        # print(l)
        return True
    return False

# arr=[]
# print(good(arr))
def generate(st, s):
    if len(s) == 0:
        return

    # If current string is not already present.
    if s not in st:
        st.add(s)

        # Traverse current string, one by one
        # remove every character and recur.
        for i in range(len(s)):
            t = list(s).copy()
            t.remove(s[i])
            t = ''.join(t)
            generate(st, t)
    return
#=--------------------------------------------longest increasing subsequence

def largestincreasingsubsequence(A):
    l = [1]*len(A)
    sub=[]
    for i in range(1,len(l)):
        for k in range(i):
            if A[k]<A[i]:
                sub.append(l[k])
        l[i]=1+max(sub,default=0)
    return max(l,default=0)

#----------------------------------Function to calculate Bitwise OR of sums of all subsequences
def findOR(nums, N):
    # Stores the prefix
    # sum of nums[]
    prefix_sum = 0
    # Stores the bitwise OR of
    # sum of each subsequence
    result = 0
    # Iterate through array nums[]
    for i in range(N):
        # Bits set in nums[i] are
        # also set in result
        result |= nums[i]
        # Calculate prefix_sum
        prefix_sum += nums[i]
        # Bits set in prefix_sum
        # are also set in result
        result |= prefix_sum
    # Return the result
    return result

def OR(a, n):
    ans = a[0]
    for i in range(1, n):
        ans |= a[i]
        #l.append(ans)
    return ans

def toString(List):
    return ''.join(List)
# Function to print permutations of string
# This function takes three parameters:
# 1. String
# 2. Starting index of the string
# 3. Ending index of the string.
def permute(a, l, r,p):
    if l == r:
        p.append(toString(a))
    else:
        for i in range(l, r + 1):
            a[l], a[i] = a[i], a[l]
            permute(a, l + 1, r,p)
            a[l], a[i] = a[i], a[l]  # backtrack
# Function to find square root of
# given number upto given precision
def squareRoot(number, precision):
    start = 0
    end, ans = number, 1
    # For computing integral part
    # of square root of number
    while (start <= end):
        mid = int((start + end) / 2)
        if (mid * mid == number):
            ans = mid
            break

        # incrementing start if integral
        # part lies on right side of the mid
        if (mid * mid < number):
            start = mid + 1
        # decrementing end if integral part
        # lies on the left side of the mid
        else:
            end = mid - 1
    # For computing the fractional part
    # of square root upto given precision
    increment = 0.1
    for i in range(0, precision):
        while (ans * ans <= number):
            ans += increment
        # loop terminates when ans * ans > number
        ans = ans - increment
        increment = increment / 10
    return ans

def countRectangles(l, w):
    squareSide = math.gcd(l, w)
    return int((l * w) / (squareSide * squareSide))

# Function that count the
# total numbersProgram between L
# and R which have all the
# digit same
def count_same_digit(L, R):
    tmp = 0
    ans = 0
    n = int(math.log10(R) + 1)
    for i in range(0, n):
        # tmp has all digits as 1
        tmp = tmp * 10 + 1
        for j in range(1, 10):

            if (L <= (tmp * j) and (tmp * j) <= R):
                #print(tmp*j)
                # Increment the required count
                ans += 1
    return ans
#----------------------------------print k closest number of a number in an array
def findCrossOver(arr, low, high, x):
    # Base cases
    if (arr[high] <= x):  # x is greater than all
        return high
    if (arr[low] > x):  # x is smaller than all
        return low
    # Find the middle point
    mid = (low + high) // 2
    if (arr[mid] <= x and arr[mid + 1] > x):
        return mid
    if (arr[mid] < x):
        return findCrossOver(arr, mid + 1, high, x)
    return findCrossOver(arr, low, mid - 1, x)
def Kclosest(arr, x, k, n,ans):
    # Find the crossover point
    l = findCrossOver(arr, 0, n - 1, x)
    r = l + 1
    count = 0
    if (arr[l] == x):
        l -= 1
    #print(l)
    while (l >= 0 and r < n and count < k):
        if (x - arr[l] < arr[r] - x):
            ans.append(arr[l])
            l -= 1
        else:
            ans.append(arr[r])
            r += 1
        count += 1
    while (count < k and l >= 0):
        ans.append(arr[l])
        l -= 1
        count += 1
    while (count < k and r < n):
        ans.append(arr[r])
        r += 1
        count += 1
    return ans
#---------------------------------------------------------------

def calcSum(arr, n, k):
    # Initialize sum = 0
    l=[]
    sum=0
    # Consider first subarray of size k
    # Store the sum of elements
    for i in range(k):
        sum += arr[i]

    # Print the current sum
    l.append(sum)

    # Consider every subarray of size k
    # Remove first element and add current
    # element to the window
    for i in range(k, n):
        # Add the element which enters
        # into the window and substract
        # the element which pops out from
        # the window of the size K
        sum = (sum - arr[i - k]) + arr[i]

        # Print the sum of subarray
        l.append(sum)

    return l

"""
def dfs(root,nodeVal,nodeConnection,visited):
    leftVal = nodeVal[root][0]
    rightVal = nodeVal[root][1]
    solution = []
    if nodeConnection[root]:
        visited.add(root)
        for i in nodeConnection[root]:
            if i not in visited:
                solution.append(dfs(i,nodeVal,nodeConnection,visited))
        # print("solution",solution)
        leftMax = 0
        rightMax = 0
        for i in solution:
            l, r = i
            leftMax += max(abs(leftVal - l[0]) + l[1], abs(leftVal - r[0]) + r[1])
            rightMax += max(abs(rightVal - l[0]) + l[1], abs(rightVal - r[0]) + r[1])
        # print(root,"return->",(leftVal,leftMax),(rightVal,rightMax))
        return ((leftVal, leftMax), (rightVal, rightMax))
    else:
        # ((left,maxVal),(right,maxVal))
        return ((leftVal, 0), (rightVal, 0))
"""
"""
def luckynumber(x,n,a):
    if x >0:
        a.append(x)
    if x>10**9:
        return a
    else:
        if x < 1e12:
            luckynumber(x * 10 + 4,n,a)
            luckynumber(x * 10 + 7,n,a)
def lcm(a,b):
    return (a*b)//math.gcd(a,b)

def query1(l, r):
    if l >= r:
        return -1
    print('?', l + 1, r + 1)
    sys.stdout.flush()
    return int(input()) - 1
def answer(p):
    print('!', p + 1)
    sys.stdout.flush()
    exit()

#---------------------count number of primes
"""
import math
MAX = 10**5
prefix = [0] * (MAX + 1)
def buildPrefix():
    prime = [1] * (MAX + 1)
    p = 2
    while (p * p <= MAX):
        if (prime[p] == 1):
            i = p * 2
            while (i <= MAX):
                prime[i] = 0
                i += p
        p += 1
    for p in range(2, MAX + 1):
        prefix[p] = prefix[p - 1]
        if (prime[p] == 1):
            prefix[p] += 1
def query(L, R):
    return prefix[R] - prefix[L - 1]
buildPrefix()

def maxSubArraySum(a, size):
    max_so_far = a[0]
    curr_max = a[0]
    for i in range(1, size):
        curr_max = max(a[i], curr_max + a[i])
        max_so_far = max(max_so_far, curr_max)
    return max_so_far

def solve(n,k):
    if n==1 and k==1:
        return 0
    mid=(2**(n-1))//2
    if k<=mid:
        return solve(n-1,k)
    else:
        return solve(n-1,k-(mid))==0

#------------------print subset of strings
def solvr(s,p):
    if len(s)==0:
        print(p,end=" ")
        return
    op1=p
    op2=p+s[0]
    s=s[1:]
    solvr(s,op1)
    solvr(s,op2)
    return
#-------------------------------------balanced paranthesis
def paranthesis(n,m,ans,l):
    if n==0 and m==0:
        print(ans)
        return
    if n!=0:
        op1=ans+"("
        paranthesis(n-1,m,op1,l)
    if m>n:
        op2=ans+")"
        paranthesis(n,m-1,op2,l)
"""
class node:
    def __init__(self,data):
        self.data=data
        self.next=None
class linkedlis:
    def __init__(self):
        self.head=None
    def printlis(self):
        temp=self.head
        while(temp):
            print(temp.data,end=" ")
            temp=temp.next
    def pushfirst(self,new_data):
        new_node=node(new_data)
        new_node.next=self.head
        self.head=new_node
    def pushmid(self,previous_node,new_data):
        new_node=node(new_data)
        if previous_node==None:
            print("call pushfirst function if it is the the start otherwise raise an error.")
        new_node.next=previous_node.next
        previous_node.next=new_node
    def pushlast(self,new_data):
        new_node=node(new_data)
        if self.head==None:
            self.head=new_node
            return
        last=self.head
        while(last.next!=None):
            last=last.next
        last.next=new_node
    def delete_node(self,key):
        pass
if __name__ == '__main__':
    l=linkedlis()
    l.head= node(1)
    p = node(2)
    pp = node(4)
    l.head.next = p
    p.next = pp
    #print(l.head)
    l.pushmid(p, 3)
    l.pushlast(5)
    l.pushfirst(0)
    #l.printlis()
    #print(l.head.data)
"""
"""
def main():
        n=1000
        l=[12]*1000
        sum=12*100
        dp=[[False]*(sum+1) for i in range(n+1)]
        for i in range(n+1):
            dp[i][0]=True
        for i in range(1,n+1):
            for j in range(1,sum+1):
                if j<l[i-1]:
                    dp[i][j]=dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j] or dp[i-1][j-l[i-1]]
        print(dp[n][sum])
if __name__ == '__main__':
    main()
"""
"""
def largestSubset(a, n):
    dp = [0 for i in range(n)]
    dp[n - 1] = 1
    for i in range(n - 2, -1, -1):
        mxm = 0
        for j in range(i + 1, n):
            if a[j] % a[i] == 0 or a[i] % a[j] == 0:
                mxm = max(mxm, dp[j])
        dp[i] = 1 + mxm
    # Return maximum value from dp[]
    return max(dp)
a = [4,6,12]
n = len(a)
print(largestSubset(a, n))
"""
"""
def rse(arr,n):
    stack=[]
    ans=[]
    for i in range(n-1,-1,-1):
        if len(stack)==0:
            ans.append(n)
        else:
            while(len(stack)!=0):
                if stack[-1][0]>=arr[i]:
                    stack.pop()
                else:
                    break
            if len(stack)==0:
                ans.append(n)
            else:
                ans.append(stack[-1][1])
        stack.append([arr[i],i])
    ans.reverse()
    return ans
def lse(arr,n):
    stack=[]
    ans=[]
    for i in range(n):
        if len(stack)==0:
            ans.append(-1)
        else:
            while(len(stack)!=0):
                if stack[-1][0]>=arr[i]:
                    stack.pop()
                else:
                    break
            if len(stack)==0:
                ans.append(-1)
            else:
                ans.append(stack[-1][1])
        stack.append([arr[i],i])
    return ans
"""
"""
def lcs(s,r):
    rr=len(r)
    ss=len(s)
    l=[[0]*(rr+1) for i in range(ss+1)]
    for i in range(ss+1):
        for j in range(rr+1):
            if i==0 and j==0:
                l[i][j]=0
            elif s[i-1]==r[j-1]:
                l[i][j]=l[i-1][j-1]+1
            else:
                l[i][j] =max(l[i-1][j],l[i][j-1])
    return l[ss][rr]
"""
def subsetsum(arr,sum,len):
    dp=[[False]*(sum+1) for i in range(len+1)]
    for i in range(len+1):
        dp[i][0]=True
    for i in range(1,len+1):
        for j in range(1,sum+1):
            if j==0:
                dp[i][j]=True
            elif arr[i-1]>j:
                dp[i][j]=dp[i-1][j]
            else:
                dp[i][j]=dp[i-1][j] or dp[i-1][j-arr[i-1]]
    #print(dp)
    return dp[len][sum]
#print(subsetsum([3,9,12],12,3))
def main():
    t=1
    #t=inpu()
    for _ in range(t):
        n=inpu()
        arr=lis()
        arr=[0]+arr
        if sum(arr)%2!=0:
            print(0)
            continue
        else:
            ans=[]
            if subsetsum(arr,sum(arr)//2,len(arr))==True:
                print(1)
                pows = [-1] * 11
                for i in range(1,n+1):
                    for j in range(10, -1, -1):
                        if arr[i] % (1 << j) == 0:
                            pows[j] = i
                            break
                for i in range(11):
                    if pows[i] != -1:
                        print(pows[i])
                        break
            else:
                print(0)
if __name__ == '__main__':
    main()

#######################################################################################################################
#   Author:     BlackFyre
#   Language:   PyPy 3.7
#######################################################################################################################

from sys import stdin, stdout, setrecursionlimit
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log, log2
from random import seed, randint
from datetime import datetime
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
from collections import defaultdict as dd
mod = pow(10, 9) + 7
mod2 = 998244353
# setrecursionlimit(3000)

def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var) + "\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x % y else 0
def ceil(a, b): return (a + b - 1) // b
def def_value(): return 0
def def_inf(): return inf
def atoi(s): return ord(s)-ord('a')
def inc(s, n=1): return chr((ord(s)-ord('a')+n)%26+ord('a'))

class XY:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def rotate(a,b,c):
    ang = (b.y-a.y)*(c.x-b.x) - (b.x-a.x)*(c.y-b.y)
    if ang == 0: return 0   #0coll, +-clock, --aclock
    else: return ang/abs(ang)

n = iinp()
b = lmp()
a = b.copy()

s = sum(a)
if s%2!=0:
    print(0)
else:
    s//=2
    dp = l1d(s+1, False)
    dp[0] = True
    for i in range(n):
        for j in range(s, -1, -1):
            if j-a[i]>=0:
                dp[j] = dp[j-a[i]] or dp[j]

    if not dp[s]: print(0)
    else:
        flg = False
        for i in range(n):
            if a[i]%2==1:
                print(1)
                print(i+1)
                flg = True
                break
        if not flg:
            print(1)
            gd = 0
            for i in range(n):
                gd = gcd(a[i],gd)
            for i in range(n):
                if (a[i]/gd)%2==1:
                    print(i+1)
                    break

def isSubsetSum(set, n, sum):
    subset = ([[False for i in range(sum + 1)]for i in range(n + 1)])
    for i in range(n + 1):
        subset[i][0] = True
    for i in range(1, sum + 1):
        subset[0][i] = False
    for i in range(1, n + 1):
        for j in range(1, sum + 1):
            if j < set[i - 1]:
                subset[i][j] = subset[i - 1][j]
            if j >= set[i - 1]:
                subset[i][j] = (subset[i - 1][j] or subset[i - 1][j - set[i - 1]])
    return subset[n][sum]
n=int(input())
a=list(map(int,input().split()))
tot=sum(a)
if tot&1==1:
    print(0)
else:
    sm=tot//2
    if isSubsetSum(a,n,sm):
        print(1)
        ver=False
        for i in range(n):
            if a[i]&1==1:
                print(i+1)
                ver=True
                break
        if ver==False:
            while True:
                for i in range(n):
                    a[i]//=2
                    if a[i]&1==1:
                        print(i+1)
                        ver=True
                        break
                if ver:
                    break
    else:
        print(0)

def check(arr):
    n=sum(arr)//2
    dp=[0 for i in range(sum(arr)+4)]
    dp[0]=1                              # it check whether the given array
    for i in arr:
        for j in range(len(dp)-1,-1,-1):
            if dp[j]==1:
                dp[i+j]=1
                if i+j==n:
                    return True
    if dp[n]==1:
        return True
    return False

def answer(arr):
    if sum(arr)%2!=0:
        print(0)
    else:# array is already good so it cannot be divided into two subsequence
        import math
        n=sum(arr)//2
        dp=[0 for i in range(n+1)]
        if check(arr)==True:
            d = math.gcd(arr[0], arr[1])
            for i in range(2, len(arr)):
                d = math.gcd(d, arr[i])

            for i in range(len(arr)):
                arr[i] //= d
            j=0
            while j<len(arr):
                if arr[j]%2!=0:
                    break
                j+=1
            print(1)
            if j<len(arr):
                print(j+1)
            else:
                print(j)

        else:
            print(0)
n=int(input())
inp=input().split()
arr=[]
for i in inp:
    arr.append(int(i))
answer(arr)

import sys
input = sys.stdin.readline
x=int(input())
ar=list(map(int,input().split()))[:x]
s=sum(ar)
DP={0}
for a in ar:
    NDP=set()
    for d in DP:
        NDP.add(a+d)
    DP=DP|NDP
if(s%2==1 or (s//2 not in DP)):
    print(0)
else:
    TWO=[0]*x
    for i in range(x):
        count=0
        while ar[i]%2==0:
            count+=1
            ar[i]//=2
        TWO[i]=count
    MIN=min(TWO)
    k=TWO.index(MIN)
    print(1)
    print(k+1)

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    while True:
        for i, e in enumerate(a):
            if e % 2:
                return i + 1
        a = [e // 2 for e in a]
    return 1

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

import sys
import math
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s.rstrip()))
def invr():
    return(map(int,input().split()))

def solution(L):

	for i in range(n):
		l=L[i]
		if l%2==1:
			print(1)
			print(i+1)
			return 0
	solution([l//2 for l in L])

n=inp()
L=inlt()
S=sum(L)
def test():
	if S%2!=0:
		print(0)
	else:

		P=set([0])
		found=False
		for l in L:
			if found:
				break
			A=[]
			for p in P:
				if p+l==S//2:
					found=True
					break
				if p+l <= S//2:
					A.append(p+l)
			for a in A:
				P.add(a)

		if found:
			solution(L)
		else:
			print(0)

test()

import sys
n = int(input())
a = [int(x) for x in input().split()]
z = sum(a)
if z % 2 == 0:
    s = 1
    for x in a:
        s |= s << x
    if s & (1 << (z // 2)):
        b = [x & -x for x in a]
        i = b.index(min(b))
        print(f"1\n{i + 1}")
        sys.exit()
print(0)

from math import gcd
from sys import stdin
input = stdin.buffer.readline

def check(arr):
    target = sum(arr) // 2
    dp = [[False for _ in range(target+1)] for __ in range(n+1)]

    for i in range(n+1):
        dp[i][0] = True

    for i in range(1, n+1):
        for j in range(1, target+1):
            if j - a[i-1] >= 0:
                dp[i][j] = dp[i-1][j - a[i-1]] or dp[i-1][j]
            else:
                dp[i][j] = dp[i-1][j]

    return dp[-1][-1]

def func():
    if sum(a) % 2 != 0 or not check(a):
        print(0)
    else:
        for i in range(n):
            if a[i] % 2 != 0:
                print(1, i+1, sep='\n')
                return
        gc = 0

        for i in range(n):
            gc = gcd(gc, a[i])

        for i in range(n):
            a[i] = a[i] // gc

        for i in range(n):
            if a[i] % 2 != 0:
                print(1, i+1, sep='\n')
                return

n = int(input())
a = list(map(int, input().split()))
func()

import sys
input = sys.stdin.readline
for _ in range(1):
    def canPartition(nums):
        a=sum(nums)
        n=len(nums)
        d={}
        def helper(curr,s):
            if curr==n:
                if s==a//2:
                    return True
                return False
            if (curr,s) in d:
                return d[(curr,s)]
            ans=helper(curr+1,s+nums[curr]) or helper(curr+1,s)
            d[(curr,s)]=ans
            return ans
        if a%2:
            return False
        return helper(0,0)
    n=int(input())
    arr=[int(x) for x in input().split()]
    s=sum(arr)
    if s%2:
        print(0)
        continue
    if canPartition(arr)==False:
        print(0)
        continue
    else:
        odd=-1
        temp=[]
        for i in range(n):
            if arr[i]%2:
                odd=i
            if arr[i]%2==0 and (arr[i]//2)%2:
                temp.append(i)
        if odd>=0:
            print(1)
            print(odd+1)
            continue
        if temp:
            print(1)
            print(temp[0]+1)
        else:
            d={}
            for i in range(n):
                if arr[i] in d:
                    d[arr[i]].append(i)
                else:
                    d[arr[i]]=[i]
            #print(d)
            for i in sorted(d.keys()):
                if canPartition(arr[:d[i][0]]+arr[d[i][0]+1:])==False:
                    print(1)
                    print(d[i][0]+1)
                    #print(1)
                    #print(d[i][0])
                    exit()

import sys
input = sys.stdin.readline

n = int(input())
a = list(map(int, input().split()))

s = sum(a)
d = {0}
for i in a:
    b = set()
    for c in d:
        b.add(i + c)
    d |= b

if(s % 2 == 1 or not (s // 2 in d)):
    print(0)
    exit()

print(1)
for i in range(33):
    for j in range(n):
        if(a[j] & (1 << i)):
            print(j + 1)
            exit()

def possible(nums,target):
    reach = {0}
    for num in nums:
        reach |= {i+num for i in reach if i+num <= target}
    if target in reach:
        return True
    return False
n = int(input())
arr = list(map(int,input().split()))
s = sum(arr)

if s%2==1 or not possible(arr,s//2):
    print(0)
else:
    print(1)
    mi = 100
    res = -1
    for i in range(n):
        A = arr[i] & (-arr[i])
        cnt = 0
        while A :
            cnt += 1
            A >>= 1
        if cnt < mi:
            mi = cnt
            res = i+1
    print(res)

import math, sys
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop

MOD = int(1e9) + 7

def main():
	n = int(input())
	arr = list(map(int, input().split()))

	total = sum(arr)
	if total % 2 != 0:
		print(0)
		return

	dp = [[0 for i in range(n + 1)] for j in range(total // 2 + 1)]

	for i in range(n):
		dp[0][i] = 1

	for i in range(1, total // 2 + 1):
		for j in range(1, n + 1):
			dp[i][j] = dp[i][j - 1]
			if i >= arr[j - 1]:
				dp[i][j] = dp[i][j] | dp[i - arr[j - 1]][j - 1]

	if dp[total // 2][n]:
		i = 0
		while True:
			if arr[i] % 2 == 1:
				print(1)
				print(i + 1)
				return

			arr[i] //= 2
			i += 1
			if i == n: i = 0
	else:
		print(0)

t = 1
# t = int(input())
for _ in range(t):
	main()

from sys import stdin, stdout

get_string = lambda: stdin.readline().strip(' ')
get_intmap = lambda: map( int, get_string().split(' ') )

def testcase():
    n = int(input())
    l = list(get_intmap())
    suml = sum(l)
    if suml % 2 == 1:# odd sum array cant be bipartitioned
        print(0); return
    #try to partition the even sum array by
    #doing a knapsack on half the sum as weight of sack
    dp = 1
    for i in l:
        dp |= (dp << i)
    if dp & (1 << (suml//2)):#knapsack success/ partition possible
        print(1)
        #find odd number or number with smallest possible Least significant bit
        min_lsb_pos = 32
        min_ind = -1
        for ind, i in enumerate(l):
            lsb_pos = 0
            while i & (1 << lsb_pos) == 0:
                lsb_pos += 1
            if min_lsb_pos > lsb_pos:
                min_lsb_pos = lsb_pos
                min_ind     = ind
        print(min_ind + 1)
    else:
        print(0)

testcase();quit()
for t in range(int(input())):
    testcase()

import math
def calc(arr):
	gc=arr[0]
	for i in range(1,len(arr)):
		gc=math.gcd(gc,arr[i])
	return gc
def check(arr):
    n=sum(arr)//2
    dp=[0 for i in range(sum(arr)+4)]
    dp[0]=1                              # it check whether the given array
    for i in arr:
        for j in range(len(dp)-1,-1,-1):
            if dp[j]==1:
                dp[i+j]=1
                if i+j==n:
                    return True
    if dp[n]==1:
        return True
    return False
n=int(input())
arr=list(map(int,input().split()))
gc=calc(arr)
if sum(arr)%2==0:
	if (check(arr) == False):
		print(0)
	else:
		flag=0
		for i in range(n):
			if arr[i]%2==1:
				print(1)
				print(i+1)
				flag=1
				break
		if flag==0:
			for i in range(n):
				if (arr[i]//gc)%2==1:
					print(1)
					print(i+1)
					break
else:
	print(0)

import time

def main():
    n = i_input()
    a = li_input()

    p = [0] * n
    s = 0
    for i, aa in enumerate(a):
        s += aa
        c = 0
        while not aa % 2:
            aa //= 2
            c += 1
        p[i] = c

    if s % 2:
        print(0)
        return

    a.sort()

    limit = s // 2
    l = [0]
    for aa in a:
        b = []
        p1 = p2 = 0
        while p1 < len(l):
            while p2 < len(l) and l[p1] + aa >= l[p2] and l[p2] <= limit:
                b.append(l[p2])
                p2 += 1

            if l[p1] + aa != b[-1] and l[p1] + aa <= limit:
                b.append(l[p1] + aa)
            p1 += 1
        l = b

    # print(l)

    if l[-1] != limit:
        print(0)
        return

    minp = (100, -1)
    for i in range(n):
        minp = min(minp, (p[i], i + 1))

    print(1)
    print(minp[1])

############

def i_input():
    return int(input())

def l_input():
    return input().split()

def li_input():
    return list(map(int, l_input()))

# endregion

if __name__ == "__main__":
    TT = time.time()
    main()
    # print("\n", time.time() - TT)

import sys
input = sys.stdin.readline
def canPartition(a,i,target):
    dp = [[False for i in range(target+1)]for j in range(len(a))]
    for i in range(n):
        dp[i][0] = True
    for i in range(1,n):
        for j in range(1,target+1):
            dp[i][j] = dp[i-1][j]
            if a[i-1]<=j:
                dp[i][j] = dp[i][j] or dp[i-1][j-a[i-1]]
    return dp[-1][target]
n = int(input())
a = list(map(int,input().split()))
s = sum(a)
if s%2==1:
    print(0)
else:
    final = float("inf")
    memo = {}
    d = {i:v for v,i in enumerate(a)}
    if not canPartition(a,0,s//2):
        print(0)
        exit()
    for i in range(n):
        if a[i]%2==1:
            print(1)
            print(i+1)
            break
    else:
        flag = False
        while True:
            for i in range(n):
                a[i]//=2
            for i in range(n):
                if a[i]%2==1:
                    print(1)
                    print(i+1)
                    flag = True
                    break
            if flag:
                break

# from typing import List, Set, Dict, Tuple, Text, Optional
from collections import deque
from types import GeneratorType
import os
import sys
import math
import heapq
from atexit import register
from io import BytesIO
import __pypy__  # type: ignore

#########
# INPUT #
#########

class Input(object):
  def __init__(self):
    if 'CPH' not in os.environ:
      sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
      sys.stdout = BytesIO()
      register(lambda: os.write(1, sys.stdout.getvalue()))

  def rawInput(self):
    # type: () -> str
    return sys.stdin.readline().rstrip('\r\n')

  def readInt(self):
    return int(self.rawInput())

##########
# OUTPUT #
##########

class Output(object):
  def __init__(self):
    self.out = __pypy__.builders.StringBuilder()

  def write(self, text):
    # type: (str) -> None
    self.out.append(str(text))

  def writeLine(self, text):
    # type: (str) -> None
    self.write(str(text) + '\n')

  def finalize(self):
    if sys.version_info[0] < 3:
      os.write(1, self.out.build())
    else:
      os.write(1, self.out.build().encode())

###########
# LIBRARY #
###########

def bootstrap(f, stack=[]):
  # Deep Recursion helper.
  # From: https://github.com/cheran-senthil/PyRival/blob/c1972da95d102d95b9fea7c5c8e0474d61a54378/docs/bootstrap.rst
  # Usage:

  # @bootstrap
  # def recur(n):
  #   if n == 0:
  #     yield 1
  #   yield (yield recur(n-1)) * n
  def wrappedfunc(*args, **kwargs):
    if stack:
      return f(*args, **kwargs)
    else:
      to = f(*args, **kwargs)
      while True:
        if type(to) is GeneratorType:
          stack.append(to)
          to = next(to)
        else:
          stack.pop()
          if not stack:
            break
          to = stack[-1].send(to)
      return to

  return wrappedfunc

def KnapsackNoReplacementFind(items, target_sum):
  # type: (List[int], int) -> List[int]
  '''
  >>> KnapsackNoReplacementFind([1, 2, 3, 4], 5) in [[1, 2], [0, 3]]
  True
  >>> KnapsackNoReplacementFind([1, 2, 4, 8, 16], 19)
  [0, 1, 4]
  >>> KnapsackNoReplacementFind([2, 3, 4], 10) is None
  True
  '''
  mult = target_sum+1
  dp_table = [-2] * (mult * (len(items)+1))

  dp_table[0] = -1
  for i in range(len(items)):
    base = i*mult
    nex = (i+1)*mult
    for j in range(target_sum+1):
      dp_table[nex+j] = dp_table[base+j]
    for j in range(target_sum+1):
      if j+items[i] > target_sum:
        continue
      next_coord = nex + j + items[i]
      if dp_table[base+j] >= -1 and dp_table[next_coord] == -2:
        dp_table[next_coord] = i

  if dp_table[len(items) * mult + target_sum] == -2:
    return None

  used = []
  cursum = target_sum
  pos = len(items)
  while True:
    used_item = dp_table[pos*mult + cursum]

    if used_item == -1:
      break

    used.append(used_item)
    cursum -= items[used_item]
    pos = used_item

  used.reverse()

  return used

#########
# LOGIC #
#########

def main(inp, out):
  # type: (Input, Output) -> any
  n = inp.readInt()
  nums = map(int, inp.rawInput().split())
  sum_all = sum(nums)
  if (sum_all % 2 == 1 or KnapsackNoReplacementFind(nums, sum_all//2) is None):
    out.writeLine(0)
  else:
    out.writeLine(1)

    while True:
      odds = filter(lambda x: nums[x] % 2, range(n))
      if len(odds):
        out.writeLine(odds[0]+1)
        break

      nums = map(lambda x: x / 2, nums)

###############
# BOILERPLATE #
###############

output_obj = Output()
main(Input(), output_obj)
output_obj.finalize()

import sys
import math
from collections import defaultdict,Counter,deque

# input=sys.stdin.readline
# def print(x):
#     sys.stdout.write(str(x)+"\n")

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b"\n") + (not b)
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode("ascii"))
		self.read = lambda: self.buffer.read().decode("ascii")
		self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')

# mod=pow(10,9)+7
# t=int(input())
# for i in range(t):
# 	n,q=map(int,input().split())
n=int(input())
a=list(map(int,input().split()))
s=0
for j in a:
	s+=j
if s&1:
	print(0)
	sys.exit()
s//=2
dp=[[0]*(s+1) for j in range(2)]
dp[0][0]=dp[1][0]=1
for j in range(1,n+1):
	for k in range(1,s+1):
		dp[j%2][k]=dp[1^(j%2)][k]
		if a[j-1]<=k:
			dp[j%2][k]|=dp[1^(j%2)][k-a[j-1]]

	if dp[j%2][s]==1:
		break
else:
	print(0)
	sys.exit()

print(1)
g=0
for j in range(n):
	g=math.gcd(g,a[j])

for j in range(n):
	a[j]//=g
	if a[j]&1:
		print(j+1)
		break

def exists(n,L):
    s=sum(L)

    dp=[(1+s//2)*[0] for i in range(n)]

    for x in range(s//2 +1):
        if x!=L[0]:
            dp[0][x]=False
        else:
            dp[0][x]=True
    for i in range(n-1):
        for x in range(s//2+1):
           if x>=L[i+1]:
               dp[i+1][x]=dp[i][x-L[i+1]] or dp[i][x]
           else:
               dp[i+1][x]=dp[i][x]
    l=False
    for i in range(n):
        l=l or dp[i][s//2]
    return l

def mini(n,L):
    s=sum(L)
    if s%2==1:
        return (0)
    if not exists(n,L):
        return(0)
    while True:
        for i in range(n):
            if L[i]%2==1:
                return(1,i+1)
            else:
                L[i]=L[i]//2

n=int(input())

L=[int(x) for x in input().split()]

x=mini(n,L)
if x==0:
    print(0)
else:
    print(x[0])
    print(x[1])

n = int(input())
arr = list(map(int, input().split()))

if sum(arr) & 1:
    print(0)
else:
    even, odd = 0, 0
    for i in arr:
        if i & 1:
            odd += 1
        else:
            even += 1
    target = sum(arr) // 2
    n = len(arr)
    dp = [[False for i in range(target + 1)] for j in range(n + 1)]
    for i in range(n + 1):
        dp[i][0] = True
    for i in range(1, n + 1):
        for j in range(1, target + 1):
            if arr[i - 1] > j:
                dp[i][j] = dp[i - 1][j]
            else:
                dp[i][j] = dp[i - 1][j] or dp[i - 1][j - arr[i - 1]]
    if dp[n][target]:
        if odd:
            for i in range(len(arr)):
                if arr[i] & 1:
                    print(1)
                    print(i + 1)
                    exit()
        else:
            min_index = 10 ** 9
            ans = -1
            for i in range(len(arr)):
                for j in range(32):
                    if arr[i] & (1 << j):
                        if j < min_index:
                            min_index = min(min_index, j)
                            ans = i + 1
                            break
            print(1)
            print(ans)
    else:
        print(0)

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    arr = list(map(int, input().split()))
    S = sum(arr)
    if S % 2:
        print(0)
        return

    dp = [[False, 0, []] for _ in range(S+1)]
    dp[arr[-1]] = [True, 1, [n-1]]
    dp[0][0] = True

    for i in range(n-2, -1, -1):
        for s in range(S+1, 0, -1):
            if s - arr[i] >= 0 and dp[s-arr[i]][0]:
                if 1 + dp[s-arr[i]][1] > dp[s][1]:
                    dp[s] = [True, 1 + dp[s-arr[i]][1], list(dp[s-arr[i]][2]) + [i]]
    if not dp[S//2][0]:
        print(0)
    else:
        ans = 0
        ansS = -1
        for s in range(1, S+1):
            if s % 2:
                if ans < dp[s][1]:
                    ansS = s
                    ans = dp[s][1]
            elif not dp[s // 2][0]:
                if ans < dp[s][1]:
                    ansS = s
                    ans = dp[s][1]

        print(n - ans)
        res = []
        bag = set(dp[ansS][2])
        for i in range(n):
            if i not in bag:
                res.append(i+1)
        print(*res)
    return

solve()

import sys
import sys

# Returns the minimum value of the
# difference of the two sets.
def findMin(S,n):

    # Find the sum of all elements
    total = sum(S)

    # Create a boolean table to store solutions to subproblems
    T = [[False] * (total + 1) for _ in range(len(S) + 1)]

    # Fill the lookup table in a bottom-up manner
    for i in range(len(S) + 1):

        # elements with zero-sum are always true
        T[i][0] = True

        j = 1
        while i > 0 and j <= total:

            # exclude the i'th element
            T[i][j] = T[i - 1][j]

            # include the i'th element
            if S[i - 1] <= j:
                T[i][j] |= T[i - 1][j - S[i - 1]]

            j = j + 1

    # Find the maximum value of `j` between 0 and `sum/2` for which the
    # last row is true
    j = total // 2
    while j >= 0 and not T[len(S)][j]:
        j = j - 1

    return total - 2*j

n=int(input())
a = list(map(int,input().split()))
cou=1
c=a[0]
for i in range(1,n):
    if(a[i]==c):
        cou+=1
if(sum(a)%2 !=0):
    print(0)
elif(cou==n):
    if(cou%2 ==0):
        print(1)
        print(1)
    else:
        print(0)
else:
    if(findMin(a,n)>0):
        print(0)
    else:
        min=10000
        ans=-1

        for i in range(n):
            num=a[i]
            count=0
            while(num%2 ==0):
                num=num//2
                count+=1
            if(count < min):
                min=count
                ans=i
        print(1)
        print(ans+1)

import sys
import math
from collections import defaultdict,Counter,deque

# input=sys.stdin.readline
# def print(x):
#     sys.stdout.write(str(x)+"\n")

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b"\n") + (not b)
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode("ascii"))
		self.read = lambda: self.buffer.read().decode("ascii")
		self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')

# mod=pow(10,9)+7
# t=int(input())
# for i in range(t):
# 	n,q=map(int,input().split())
n=int(input())
a=list(map(int,input().split()))
s=0
for j in a:
	s+=j
if s&1:
	print(0)
	sys.exit()
s//=2
dp=[0]*(s+1)
dp[0]=1
for j in range(n):
	for k in range(s,0,-1):
		if a[j]<=k:
			dp[k]|=dp[k-a[j]]

	if dp[s]==1:
		break
else:
	print(0)
	sys.exit()

print(1)
g=0
for j in range(n):
	g=math.gcd(g,a[j])

for j in range(n):
	a[j]//=g
	if a[j]&1:
		print(j+1)
		break

from functools import lru_cache

def gcd(a,b):
	if b==0:
		return(a)
	return(gcd(b,a%b))

@lru_cache(None)
def subsetSum(curSum,totalSum,idx,array):

	if idx>=len(array):
		return(False)

	if totalSum==2*curSum:
		return(True)

	if 2*curSum>totalSum:
		return(False)
	withVal=subsetSum(curSum+array[idx],totalSum,idx+1,array)
	if withVal:
		return(True)
	withOutVal=subsetSum(curSum,totalSum,idx+1,array)

	return(withOutVal)

n=int(input())
array=tuple(map(int,input().split()))
totalSum=sum(array)

if totalSum%2!=0 or  not subsetSum(0,totalSum,0,array):
	print(0)

else:
	for idx,val in enumerate(array):
		if val%2!=0:
			print(1)
			print(idx+1)
			break
	else:
		ansIdx=0
		ansCount=float('inf')
		for idx,val in enumerate(array):
			count=0
			while val%2==0:
				count+=1
				val=val/2
			if count<ansCount:
				ansCount=count
				ansIdx=idx
		print(1)
		print(ansIdx+1)

# from sys import stdin,stdout
# input=stdin.readline
import math
import sys
# t=int(input())
from collections import Counter,defaultdict
import bisect
def func(n,set):
    s = sum(set)
    if s%2:
        return False
    s = s//2
    subset =([[False for i in range(s + 1)]
            for i in range(n + 1)])

    for i in range(n + 1):
        subset[i][0] = True

    for i in range(1, s + 1):
         subset[0][i]= False

    for i in range(1, n + 1):
        for j in range(1, s + 1):
            if j<set[i-1]:
                subset[i][j] = subset[i-1][j]
            if j>= set[i-1]:
                subset[i][j] = (subset[i-1][j] or
                                subset[i - 1][j-set[i-1]])

    return subset[n][s]
def check(a,flag = 0):
    for i in a:
        if i%2:
            if not flag:
                return False
            else:
                return a.index(i)
    return True
n = int(input())
a = list(map(int,input().split(' ')))
aTemp = [i for i in a]
if not func(n,a):
    print(0)
else:
    while (check(aTemp)):
        aTemp = [i//2 for i in aTemp]
    print(1)
    print(check(aTemp,1)+1)

import os,sys,math
from io import BytesIO, IOBase
from collections import defaultdict,deque,OrderedDict
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(input()))
def In():return(map(int,input().split()))
def ln():return list(map(int,input().split()))
def Sn():return input().strip()
BUFSIZE = 8192
#complete the main function with number of test cases to complete greater than x
def find_gt(a, x):
    i = bi.bisect_left(a, x)
    if i != len(a):
        return i
    else:
        return len(a)
def CountTrailingZeros(n):

    bit = bin(n)[2:]
    bit = bit[::-1]
    zero = 0;
    for i in range(len(bit)):
        if (bit[i] == '0'):
            zero += 1
        else:
            break

    return zero
def solve():
    Max=2000*100
    dp=[False]*(Max+1)
    n=I()
    dp[0]=True
    l=list(In())
    total=0
    for x in l:
        total+=x
        for j in range(len(dp)-x-1,-1,-1):
            if not dp[j]:continue
            dp[j+x]=True

    if (not dp[total//2]) or (total%2!=0):
        print(0)
        return
    trail=31
    for x in l:
        trail=min(trail,CountTrailingZeros(x))
    ans=-2
    for i in range(n):
        if l[i]%(1<<trail+1)!=0:
            ans=i
    print(1)
    print(ans+1)

    pass

def main():
    T=1
    for i in range(T):
        solve()

M = 998244353
P = 1000000007

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == '__main__':
    main()

n=input()
a=map(int,raw_input().split())
sm=sum(a)
if sm%2==1:
    print 0
else:
    dp=[0 for i in range(sm/2+1)]
    dp[0]=1
    op=sm/2
    for i in range(n):
        store=[]
        for j in range(op+1):
            if dp[j]==1:
                if j+a[i]<=op:
                    if dp[j+a[i]]==0:
                        store.append(j+a[i])
        for j in store:
            dp[j]=1
    if dp[-1]==0:
        print 0
    else:
        mx=1000
        ind=-1
        g=1
        for i in a:
            k=i
            cnt=0
            while k%2==0:
                cnt+=1
                k/=2
            if cnt<mx:
                mx=cnt
                ind=g
            g+=1
        print 1
        print ind

import math

n = int(input())
a = list(map(int, input().split()))

d = math.gcd(a[0], a[1])

for i in range(2, len(a)):
    d = math.gcd(d, a[i])

for i in range(len(a)):
    a[i] //= d

s = sum(a)
if s % 2 == 1:
    print(0)
else:
    target = s // 2
    dp = [False] * (target + 1)
    dp[0] = True
    for v in a:
        for i in range(target, v - 1, -1):
            dp[i] = dp[i] or dp[i - v]
    if dp[target]:
        j = 0
        while a[j] % 2 == 0:
            j += 1
        print(1)
        print(j + 1)
    else:
        print(0)

n = int(input())
arr = list(map(int,input().split()))

dp = [[0 for _ in range(200001)] for __ in range(n + 1)]
dp[0][0] = 1
pref = [0 for i in range(n)]
pref[0] = arr[0]
for i in range(1,n):
    pref[i] = pref[i - 1] + arr[i]
for i in range(1,n + 1):
    for j in range(1,200001):
        if j > pref[i - 1]:
            break
        if j - arr[i - 1] >= 0:
            dp[i][j] = dp[i - 1][j - arr[i - 1]]|dp[i - 1][j]

s = sum(arr)
if s % 2 or not dp[n][s//2]:
    print(0)
else:
    for index,i in enumerate(arr):
        if i % 2:
            print(1)
            print(index + 1)
            exit()
    while True:
        for i in range(n):
            arr[i] = arr[i]//2
            if arr[i]%2:
                print(1)
                print(i + 1)
                exit()

import sys,math,bisect

inf = float('inf')
mod = (10**9)+7

"=========================="
def lcm(a,b):
    return int((a/math.gcd(a,b))*b)
def gcd(a,b):
    return int(math.gcd(a,b))
def tobinary(n):
    return bin(n)[2:]
def binarySearch(a,x):
    i = bisect.bisect_left(a,x)
    if i!=len(a) and a[i]==x:
        return i
    else:
        return -1
def lowerBound(a, x):
    i = bisect.bisect_left(a, x)
    if i:
        return (i-1)
    else:
        return -1
def upperBound(a,x):
    i = bisect.bisect_right(a,x)
    if i!= len(a)+1 and a[i-1]==x:
        return (i-1)
    else:
        return -1
def primesInRange(n):
    ans = []
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    for p in range(2, n+1):
        if prime[p]:
            ans.append(p)
    return ans
def primeFactors(n):
    factors = []
    while n % 2 == 0:
        factors.append(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            factors.append(i)
            n = n // i
    if n > 2:
        factors.append(n)
    return factors
"============================"
"""
n = int(input())
n,k = map(int,input().split())
arr = list(map(int,input().split()))
"""
from collections import deque,defaultdict,Counter
import heapq

def isSubsetSum(set, n, sum):
    subset =([[False for i in range(sum + 1)]
            for i in range(n + 1)])
    for i in range(n + 1):
        subset[i][0] = True
    for i in range(1, sum + 1):
         subset[0][i]= False
    for i in range(1, n + 1):
        for j in range(1, sum + 1):
            if j<set[i-1]:
                subset[i][j] = subset[i-1][j]
            if j>= set[i-1]:
                subset[i][j] = (subset[i-1][j] or
                                subset[i - 1][j-set[i-1]])
    return subset[n][sum]

for _ in range(1):
    n = int(input())
    arr = list(map(int,input().split()))
    x= sum(arr)//2
    if sum(arr)%2==1 or not isSubsetSum(arr,n,x):
        print(0)
    else:
        flag=True
        for i in range(n):
            if arr[i]%2==1:
                print(1)
                print(i+1)
                flag=False
                break
        while flag:
            for i in range(n):
                arr[i]=arr[i]//2
                if arr[i]%2==1:
                    print(1)
                    print(i+1)
                    flag=False
                    break

#Don't stalk me, don't stop me, from making submissions at high speed. If you don't trust me,
import sys
#then trust me, don't waste your time not trusting me. I don't plagiarise, don't fantasize,
import os
#just let my hard work synthesize my rating. Don't be sad, just try again, everyone fails
from io import BytesIO, IOBase
BUFSIZE = 8192
#every now and then. Just keep coding, just keep working and you'll keep progressing at speed-
# -forcing.
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
#code by _Frust(CF)/Frust(AtCoder)
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from os import path
if(path.exists('input.txt')):
    sys.stdin = open("input.txt","r")
    sys.stdout = open("output.txt","w")
    input = lambda: sys.stdin.readline().rstrip("\r\n")
import math
import heapq as hq

def checker(dp, nums):
    for i in range(n):
        for j in range(r, -1, -1):
            if dp[j]==1 and j+l1[i]<=r:
                dp[j+l1[i]]=1

    if dp[r]==1:
        return True
    else:
        return False

n=int(input())
l1=[int(i) for i in input().split()]

s=sum(l1)
if s&1:
    print(0)
else:
    r=s//2
    dp=[0 for i in range(r + 1)]
    dp[0]=1
    # print(r)

    if not checker(dp, l1):
        print(0)
    else:
        found=0
        for i in range(n):
            if l1[i]&1:
                found=1
                print(1)
                print(i+1)
                break
        if found==0:
            d1={}
            for i in l1:
                d1[i]=d1.get(i, 0)+1
            rnum=-1
            for i in range(r, -1, -1):
                if dp[i]==0 and 2*(r-i) in d1:
                    rnum=2*(r-i)
                    break
            # print(dp)

            for i in range(n):
                if l1[i]==rnum:
                    print(1)
                    print(i+1)
                    break

n = int(input())
a = [int(i) for i in input().split()]
sm = sum(a)
#print(sorted(a))
#print(sm)
if sm % 2==1:
    print(0)
else:
    target = sm // 2
    dp =[[0 for j in range(target + 1)] for i in range(n+1)]
    dp[0][0] = 1
    x =[]
    c ={0:[]}
    boo = True
    for i in range(1,n+1):
        for j in range(target):
            if dp[i-1][j]:
                dp[i][j] = 1
                if(j+a[i-1] <= target):
                    dp[i][j+a[i-1]] = 1
                if(j+a[i-1] == target):
                    k, l = i , j+a[i-1]
                    temp = []
                    while(l > 0 and k > 0):
                        if(dp[k][l]):
                            temp += [k-1]
                            l -= a[k-1]
                            k -= 1

                        else:
                            k -= 1
                    x += [temp]
                    break
            if(x):
                break

    #x = dp[-1][-1][-1]
    if(len(x)==0):
        print(0)
        exit()
    temp = []
    #print(x)
    for i in range(n):
        if i not in x[0]:
            temp += [i]
    x += [temp]
    exp = 0
    while(boo):
        for i in range(2):
            for j in range(len(x[i])):
                if a[x[i][j]]%2:
                    print(1)
                    print(x[i][j]+1)
                    boo = False
                    break
                a[x[i][j]] /= 2
            if not boo:
                break
        exp += 1

def partition(arr,n):
    s=sum(arr)//2
    if sum(arr)%2 !=0:
        return False
    else:
        dp=[[False for j in range(s+1)] for i in range(n+1)]
        for i in range(n+1):
            for j in range(s+1):
                if i==0:
                    dp[i][j]=False
                if j==0:
                    dp[i][j]=True
                elif j>=arr[i-1]:
                    dp[i][j]=dp[i-1][j-arr[i-1]] or dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j]
        return dp[n][s]
def solve(arr,n):
    count=0
    for i in range(n):
        if arr[i]%2:
            count+=1
            print(count)
            print(i+1)
            return

    # print(count)
    f=0
    while  f!=1:

        for k in range(n):
            arr[k]=arr[k]//2

            if arr[k]%2:
                print(1)
                print(k+1)
                f=1
                return

n=int(input())
arr=list(map(int,input().split()))
res=(partition(arr,n))
count=0
if res==False:
    print(0)
else:
    (solve(arr,n))

# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b"\n") + (not b)
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode("ascii"))
		self.read = lambda: self.buffer.read().decode("ascii")
		self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# ------------------- fast io --------------------
from math import ceil

def prod(a, mod=10**9+7):
	ans = 1
	for each in a:
		ans = (ans * each) % mod
	return ans

def gcd(x, y):
	while y:
		x, y = y, x % y
	return x

def lcm(a, b): return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else "0" * (length - len(y)) + y

for _ in range(int(input()) if not True else 1):
	n = int(input())
	#n, k = map(int, input().split())
	#a, b = map(int, input().split())
	#c, d = map(int, input().split())
	a = list(map(int, input().split()))
	#b = list(map(int, input().split()))
	#s = input()
	def f(n, a):
		total = sum(a)
		if total % 2:
			print(0)
			quit()

		dp = [[0]*(2*10**5 + 1) for ___ in range(101)]
		for i in range(n+1):
			dp[i][0] = 1

		for i in range(1,n+1):
			for j in range(1, total+1):
				dp[i][j] = dp[i-1][j]
				if a[i-1] <= j:
					dp[i][j] = max(dp[i][j], dp[i-1][j-a[i-1]])

		x = 0
		for k in range(total//2, -1, -1):
			if dp[n][k]:
				x = total - 2*k
				break
		if x:
			print(0)
			quit()
		for i in range(n):
			if a[i] % 2 or not dp[n][(total - a[i]) // 2]:
				print(1)
				print(i+1)
				quit()
	f(n, a)

'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline

def findPartiion(arr, n):
    Sum = 0
    for i in range(n):
        Sum += arr[i]
    if (Sum % 2 != 0):
        return 0
    part = [0] * ((Sum // 2) + 1)
    for i in range((Sum // 2) + 1):
        part[i] = 0
    for i in range(n):
        for j in range(Sum // 2, arr[i] - 1, -1):
            if (part[j - arr[i]] == 1 or j == arr[i]):
                part[j] = 1

    return part[Sum // 2]

t = 1
for _ in range(t):
    n=int(input())
    a=[int(x) for x in input().split()]
    if sum(a)%2:
        print(0)
        continue
    if not findPartiion(a,n):
        print(0)
        continue
    l=0
    r=n-1
    while l<=r:
        vals = a[::]
        i=l
        del vals[i]
        if not findPartiion(vals, n - 1):
            print(1)
            print(i + 1)
            break
        vals = a[::]
        i=r
        del vals[i]
        if not findPartiion(vals, n - 1):
            print(1)
            print(i + 1)
            break
        l+=1
        r-=1
    else:
        assert 1==2

import os
import sys
from io import BytesIO, IOBase

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda dtype: dtype(input().strip())
inp_d = lambda dtype: [dtype(x) for x in input().split()]
inp_2d = lambda dtype, n: [inp(dtype) for _ in range(n)]
inp_2ds = lambda dtype, n: [inp_d(dtype) for _ in range(n)]
inp_enu = lambda dtype: [(i, x) for i, x in enumerate(inp_d(dtype))]
inp_enus = lambda dtype, n: [[i, inp_d(dtype)] for i in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b
lsone = lambda x: x & (-x)

n, a = inp(int), inp_d(int)
mem, su = [False] * (10 ** 5 + 1), sum(a)
mem[0] = True

for i in range(n):
    for j in range(10 ** 5 - a[i], -1, -1):
        mem[a[i] + j] |= mem[j]
    mem[a[i]] = True

if su & 1 or not mem[su >> 1]:
    print(0)
else:
    print(1, a.index(min(a, key=lambda x: lsone(x))) + 1, sep='\n')

import math
import sys
import collections
import bisect
import time
import random
from itertools import permutations
def get_ints():return map(int, sys.stdin.readline().strip().split())
def get_list():return list(map(int, sys.stdin.readline().strip().split()))
def get_string():return sys.stdin.readline().strip()

def findPartition(arr, n):
	Sum = 0
	for i in range(n):
		Sum += arr[i]
	if (Sum % 2 != 0):
		return 0
	part = [0] * ((Sum // 2) + 1)
	for i in range((Sum // 2) + 1):
		part[i] = 0
	for i in range(n):
		for j in range(Sum // 2, arr[i] - 1, -1):
			if (part[j - arr[i]] == 1 or j == arr[i]):
				part[j] = 1
	return part[Sum // 2]
for t in range(1):
	n=int(input())
	arr=get_list()
	if findPartition(arr, n) == False:
		print(0)
		continue
	p=0
	for i in range(n):
		if arr[i]%2==1:
			print(1)
			print(i+1)
			p+=1
			break
	if p>0:
		continue
	for i in range(n):
		temp=arr[:i]+arr[i+1:]
		if findPartition(temp, n-1) == False:
			print(1)
			print(i+1)
			break

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    arr = list(map(int, input().split()))
    S = sum(arr)
    if S % 2:
        print(0)
        return

    dp = [[False, 0, []] for _ in range(S+1)]
    dp[arr[-1]] = [True, 1, [n-1]]
    dp[0][0] = True

    for i in range(n-2, -1, -1):
        for s in range(S+1, 0, -1):
            if s - arr[i] >= 0 and dp[s-arr[i]][0]:
                if 1 + dp[s-arr[i]][1] > dp[s][1]:
                    dp[s] = [True, 1 + dp[s-arr[i]][1], list(dp[s-arr[i]][2]) + [i]]
    if not dp[S//2][0]:
        print(0)
    else:
        ans = 0
        ansS = -1
        for s in range(1, S+1):
            if s % 2:
                if ans < dp[s][1]:
                    ansS = s
                    ans = dp[s][1]
            elif not dp[s // 2][0]:
                if ans < dp[s][1]:
                    ansS = s
                    ans = dp[s][1]

        print(n - ans)
        res = []
        bag = set(dp[ansS][2])
        for i in range(n):
            if i not in bag:
                res.append(i+1)
        print(*res)
    return

solve()

def possible(nums,target):
    reach = {0}
    for num in nums:
        reach |= {i+num for i in reach if i+num <= target}
    if target in reach:
        return True
    return False
n = int(input())
arr = list(map(int,input().split()))
s = sum(arr)

if s%2==1 or not possible(arr,s//2):
    print(0)
else:
    print(1)
    mi = 100
    res = -1
    for i in range(n):
        A = arr[i] & (-arr[i])
        cnt = 0
        while A :
            cnt += 1
            A >>= 1
        if cnt < mi:
            mi = cnt
            res = i+1
    print(res)

n=int(input())
    # n,k=map(int,input().split())
l=list(map(int,input().split()))
f=0
if sum(l)%2!=0:
    print(0)
    f=1
    # continue
if f==0:
 s=sum(l)//2
 dp=[[False for _ in range(s+1)] for _ in range(n+1)]
 for i in range(n+1):
        dp[i][0]=True
 for i in range(1,n+1):
        for j in range(1,s+1):
            if l[i-1]<=j:
                dp[i][j]=dp[i-1][j] | dp[i-1][j-l[i-1]]
            else:
                dp[i][j]=dp[i-1][j]
 f=0
 if dp[n][s]==True:
       for i in range(12):
        for i in range(n):
            if l[i]%2==1:
                print(1)
                print(i+1)
                f=1
                break
            l[i]//=2
        if f==1:
            break

        # if f==0:
        #     for i in range(n):
        #      if l[i]%4==1:
        #         print(1)
        #         print(i+1)
        #         f=1
        #         break

 else:
        print("0")

def findsubarr(s,n,e):
    if(n==1):
        return {0,e}
    else:
        p=list(findsubarr(s,n-1,a[n-2]))
        q=set()
        for x in range(len(p)):
            sum1=p[x]+0
            sum2=p[x]+e
            if(sum1<=s):
                q.add(sum1)
            if(sum2<=s):
                q.add(sum2)
        return q

n=int(input())
a=list(map(int,input().split()))
q=min(a)
s=sum(a)
p=1

if(s%2==0):
    if(s/2 in findsubarr(int(s/2),n,a[n-1]))==False:
        print(0)
        exit()

while(True):
    t=pow(2,p)
    if(s%t!=0):
        print(0)
        exit()
    else:
        for x in range(n):
            if(a[x]%t!=0):
                print(1)
                print(x+1)
                exit()
        p=p+1

import math
def calc(arr):
	gc=arr[0]
	for i in range(1,len(arr)):
		gc=math.gcd(gc,arr[i])
	return gc
def check(arr):
    n=sum(arr)//2
    dp=[0 for i in range(sum(arr)+4)]
    dp[0]=1                              # it check whether the given array
    for i in arr:
        for j in range(len(dp)-1,-1,-1):
            if dp[j]==1:
                dp[i+j]=1
                if i+j==n:
                    return True
    if dp[n]==1:
        return True
    return False
n=int(input())
arr=list(map(int,input().split()))
gc=calc(arr)
if sum(arr)%2==0:
	if (check(arr) == False):
		print(0)
	else:
		flag=0
		for i in range(n):
			if arr[i]%2==1:
				print(1)
				print(i+1)
				flag=1
				break
		if flag==0:
			for i in range(n):
				if (arr[i]//gc)%2==1:
					print(1)
					print(i+1)
					break
else:
	print(0)

n = int(input())
a = list(map(int, input().split()))
s = sum(a)

if s & 1:
    print(0)
    exit()

h = s//2
k = [False]*(s+1)
k[0] = True
for i in a:
    for j in range(s, -1, -1):
        if k[j]:
            k[j+i] = True

if k[h]:
    res = None
    m = float("inf")
    for i in range(n):
        if a[i] & 1:
            res = i+1
            break
        else:
            temp = 0
            while a[i] % 2 == 0:
                a[i] //= 2
                temp += 1
            if temp < m:
                m = temp
                res = i+1
    print(1)
    print(res)

else:
    print(0)

from sys import stdin
input = stdin.readline

def subset_sum(a, n, k):
    k += 1
    dp = [[True]*k for i in range(n)]
    for y in range(n):
        for x in range(1, k):
            if y == 0:
                dp[y][x] = x == a[y]
            elif x - a[y] < 0:
                dp[y][x] = dp[y-1][x]
            elif dp[y-1][x] == True:
                dp[y][x] = True
            else:
                dp[y][x] = dp[y-1][x-a[y]]
    return dp[-1][-1]

def solve(n, a):
    s = sum(a)
    if s % 2 > 0:
        print(0)
        return
    if not(subset_sum(a, n, s // 2)):
        print(0)
        return
    for i in range(n):
        if a[i] % 2 > 0:
            print(1)
            print(i+1)
            return
    m = float("inf")
    for i in range(n):
        j = 0
        while a[i] >> j & 1 == 0:
            j += 1
        if j < m:
            m = j
            ans = i+1
    print(1)
    print(ans)

n = int(input())
a = [int(x) for x in input().split()]
solve(n, a)

import sys
n = int(input())
a = [int(x) for x in input().split()]
z = sum(a)
if z % 2 == 0:
    s = 1
    for x in a:
        s |= s << x
    if s & (1 << (z // 2)):
        b = [x & -x for x in a]
        i = b.index(min(b))
        print(f"1\n{i + 1}")
        sys.exit()
print(0)

import sys
sys.setrecursionlimit(int(1e4))
def alreadygood(ind, sm):
    dp = [[False for i in range(300001)] for j in range(n + 1)]
    for i in range(300001):
        if i == s - i:
            dp[n - 1][i] = True
    for ind in range(n - 2, -1, -1):
        for sm in range(s - 1, -1, -1):
            dp[ind][sm] = dp[ind + 1][sm] | dp[ind + 1][sm + lis[ind]]
    return dp[0][0]

import sys, math ; input = lambda :sys.stdin.readline().rstrip()
I=lambda:[*map(int,input().split())]
n, = I()
lis = I()
dp = dict()
s = sum(lis)
if sum(lis) & 1:
    print(0)
    exit()
else:
    a = alreadygood(0, 0)
    if not a:
        print(0)
        exit()
    odd = False
    for i, j in enumerate(lis):
        if j & 1:
            print(1)
            print(i + 1)
            odd = True
            exit()
    if odd == False:
        if not a:
            print(0)
        else:
            mn = 1 << 69 ; ind = None
            for i in range(n):
                val = math.log2(lis[i]&-lis[i])+1
                if val < mn:
                    mn = val ; ind = i
            print(1)
            print(ind + 1)

import sys, threading
import math
from os import path
from collections import defaultdict, Counter, deque
from bisect import *
from string import ascii_lowercase
from functools import cmp_to_key
import heapq

def readInts():
    x = list(map(int, (sys.stdin.readline().rstrip().split())))
    return x[0] if len(x) == 1 else x

def readList(type=int):
    x = sys.stdin.readline()
    x = list(map(type, x.rstrip('\n\r').split()))
    return x

def readStr():
    x = sys.stdin.readline().rstrip('\r\n')
    return x

write = sys.stdout.write
read = sys.stdin.readline

MAXN = 1123456
MOD = 10**9 + 7

class mydict:
    def __init__(self, func):
        self.random = randint(0, 1 << 32)
        self.default = func
        self.dict = {}

    def __getitem__(self, key):
        mykey = self.random ^ key
        if mykey not in self.dict:
            self.dict[mykey] = self.default()
        return self.dict[mykey]

    def get(self, key, default):
        mykey = self.random ^ key
        if mykey not in self.dict:
            return default
        return self.dict[mykey]

    def __setitem__(self, key, item):
        mykey = self.random ^ key
        self.dict[mykey] = item

    def getkeys(self):
        return [self.random ^ i for i in self.dict]

    def __str__(self):
        return f'{[(self.random ^ i, self.dict[i]) for i in self.dict]}'

def lcm(a, b):
    return (a*b)//(math.gcd(a,b))

def mod(n):
    return n%MOD

def fls():
    sys.stdout.flush()

dp = []
def helper(ar, ind, cur):

    global dp
    # print(ind, sm-cur)
    if cur == 0:
        dp[cur] = True
        return True

    if ind >= len(ar):
        return False

    if cur < 0:
        return False

    if not dp[cur] is None:
        return dp[cur]

    b1 = b2 = False
    b1 = helper(ar, ind+1, cur)
    b2 = helper(ar, ind+1, cur-ar[ind])
    dp[cur] = b1 or b2
    return dp[cur]

def solve(t):
    # print(f'Case #{t}: ', end = '')
    n = readInts()
    ar = readList()
    sm = sum(ar)
    if sm&1:
        print(0)
        return

    global dp
    dp = [None for _ in range(sm+1)]
    helper(ar, 0, sm//2)
    if not dp[sm//2]:
        print(0)
        return

    for i in range(n):
        if ar[i]&1:
            print(1)
            print(i+1)
            return

    for i in range(n):
        nar = ar[:i] + ar[i+1:]
        dp = [None for _ in range(sm+1)]
        if not helper(nar, 0, sum(nar)//2):
            print(1)
            print(i+1)
            return

    print(n-1)

def main():
    t = 1
    if path.exists("F:/Comp Programming/input.txt"):
        sys.stdin = open("F:/Comp Programming/input.txt", 'r')
        sys.stdout = open("F:/Comp Programming/output1.txt", 'w')
    # sys.setrecursionlimit(10**5)
    # t = readInts()
    for i in range(t):
        solve(i+1)

if __name__ == '__main__':
    main()

n = int(input())
a = list(map(int, input().split()))
s = sum(a)

if s & 1:
    print(0)
    exit()

h = s//2
k = [False]*(s+1)
k[0] = True
for i in a:
    for j in range(s, -1, -1):
        if k[j]:
            k[j+i] = True

if k[h]:
    res = None
    m = float("inf")
    for i in range(n):
        if a[i] & 1:
            res = i+1
            break
        else:
            temp = 0
            while a[i] % 2 == 0:
                a[i] //= 2
                temp += 1
            if temp < m:
                m = temp
                res = i
    print(1)
    print(res)

else:
    print(0)

"""**************************************************************\
                   BISMILLAHIR RAHMANIR RAHIM
****************************************************************
               AUTHOR NAME: MD. TAHURUZZOHA TUHIN
\**************************************************************"""

#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
import math
from io import BytesIO, IOBase
from heapq import heappush,heappop,heapify
from collections import defaultdict, Counter, deque

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

# Start FASTIO
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

def prod(a, mod=10 ** 9 + 7):
    ans = 1
    for each in a:
        ans = (ans * each) % mod
    return ans

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def lcm(a, b): return a * b // gcd(a, b)

def binary(x, length=16):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y

def check_freq(x):
    freq = {}
    for c in set(x):
       freq[c] = x.count(c)
    return freq

def ii(): return int(input())
def si(): return input()
def mi(): return map(int, input().strip().split(" "))
def li(): return list(mi())
MAXX = 100000000

'''**************Solution is Here***********'''
def equalPartition(self,N, arr):
        # code here
        s=sum(arr)
        #s has to be even for halves to exist
        if s%2==1:
            return 0
        mat=[]
        p=s//2

        #initialization of DP table
        for i in range(N+1):
            row=[]
            for j in range(p+1):
                if j==0:
                    row.append(1)
                elif i==0:
                    row.append(0)
                else:
                    row.append(2)
            mat.append(row)
       # print(mat)

        # DP table
        for i in range(1,N+1):
            for j in range(1,p+1):
                if arr[i-1]>j:
                    mat[i][j]=mat[i-1][j]

                else:
                    mat[i][j]=max(mat[i-1][j],mat[i-1][j-arr[i-1]])
        return mat[-1][-1]

def solve(arr,n):
    sm = sum(arr)
    if sm%2==1:
        return False
    return equalPartition(sm//2, n, arr)

def main():
    T = 1
    for _ in range(T):
        n = ii()
        a = li()
        if (solve(a, n)) == True:
            ans = -1
            for i in range(n):
                b = [0]*n
                k = 0
                for j in range(n):
                    if i==j:
                        continue
                    b[k] = a[j]
                    k += 1
                if (solve(b,k) == False):
                    ans = i
                    break
                if (solve(b,k) == True):
                    ans = i+1
                    break
            print(1)
            print(ans+1)

        else:
            print(0)

# End FASTIO
if __name__ == "__main__":
    main()

import sys
import math
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s.rstrip()))
def invr():
    return(map(int,input().split()))
n=inp()
def solution(L):
	S=sum(L)
	if S==0:
		print(n-1)
		print(' '.join([str(i) for i in range(1, n)]))
		return 0
	if S%2!=0:
		print(0)
		return 0
	else:
		for i in range(len(L)):
			l=L[i]
			if l%2==1:
				print(1)
				print(i+1)
				return 0
	solution([l//2 for l in L])

L=inlt()
solution(L)

# Legends Always Come Up with Solution
# Author: Manvir Singh

import os
import sys
from io import BytesIO, IOBase

def findPartiion(a,n):
    s = 0
    for i in range(n):
        s += a[i]
    if s % 2:
        return 0
    part = [0] * (s // 2 + 1)
    for i in range(s // 2 + 1):
        part[i] = 0
    for i in range(n):
        for j in range(s // 2, a[i] - 1, -1):
            if (part[j - a[i]] == 1 or j == a[i]):
                part[j] = 1
    return part[s // 2]

def main():
    n=int(input())
    a=list(map(int,input().split()))
    if not findPartiion(a,len(a)):
        print(0)
    else:
        o = 0
        for i in a:
            if i % 2:
                o += 1
        if o % 2:
            print(0)
        else:
            print(1)
            for i in range(n):
                if a[i] % 2:
                    print(i + 1)
                    return
            for i in range(n):
                f=1
                for j in range(n):
                    if i!=j:
                        for k in range(n):
                            if j!=k:
                                if a[i]==2*(a[j]-a[k]):
                                    f=0
                if f:
                    print(i+1)
                    return

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

import sys
import math
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s.rstrip()))
def invr():
    return(map(int,input().split()))

def solution(L):

	for i in range(n):
		l=L[i]
		if l%2==1:
			print(1)
			print(i+1)
			return 0
	solution([l//2 for l in L])

n=inp()
L=inlt()
S=sum(L)
def test():
	if S%2!=0:
		print(0)
	else:

		P=set([0])
		found=False
		for l in L:
			A=[]
			for p in P:
				if p+l==S//2:
					print(0)
					return
				if p+l <= S//2:
					A.append(p+l)
			for a in A:
				P.add(a)

		solution(L)

test()

from math import gcd
from sys import stdin
input = stdin.buffer.readline

def check(arr):
    target = sum(arr) // 2
    dp = [[False for _ in range(target+1)] for __ in range(n+1)]

    for i in range(n+1):
        dp[i][0] = True

    for i in range(1, n+1):
        for j in range(1, target+1):
            if j - a[i-1] >= 0:
                dp[i][j] = dp[i][j - a[i-1]] or dp[i-1][j]
            else:
                dp[i][j] = dp[i-1][j]

    return dp[-1][-1]

def func():
    if sum(a) % 2 != 0 or not check(a):
        print(0)
    else:
        for i in range(n):
            if a[i] % 2 != 0:
                print(1, i+1, sep='\n')
                return
        gc = 0

        for i in range(n):
            gc = gcd(gc, a[i])

        for i in range(n):
            a[i] = a[i] // gc

        for i in range(n):
            if a[i] % 2 != 0:
                print(1, i+1, sep='\n')
                return

n = int(input())
a = list(map(int, input().split()))
func()

n=int(input())
a=list(map(int,input().split()))
sums=sum(a)
if sums%2==1:
    print(0)
else:
    flag=True
    while flag:
        for i in range(n):
            if a[i]%2==1:
                print(1)
                print(i+1)
                flag=False
                break
            else:
                a[i] = a[i] // 2
        if flag:
            sums =sums//2
            if sums%2==1:
                print(0)
                break

n=int(input())
m=[int(i) for i in input().split()]
s=sum(m)
for i in range(len(m)):
    m[i]=[m[i],i]

if s%2!=0:
    print(0)
a=0
b=0
m.sort(key=lambda x: x[0], reverse=True)
print(m)
c=1
ans=[]
while True:
    a=0
    b=0
    for i in range(len(m)):
        if a<=b and a+m[i][0]<=s//2:
            a+=m[i][0]
        else:
            b+=m[i][0]
    t=None
    for i in range(len(m)):
        if m[i][0] % 2 != 0:
            t=m[i][1]
    if t is not None:
        ans=[t]
        break
    else:
        for i in range(len(m)):
            m[i][0]//=2
print(c,*ans,sep='\n')

n=int(input())
m=[int(i) for i in input().split()]
s=sum(m)
for i in range(len(m)):
    m[i]=[m[i],i]

if s%2!=0:
    print(0)
    exit()
a=0
b=0
m.sort(key=lambda x: x[0], reverse=True)
c=1
ans=[]
while True:
    a=0
    b=0
    for i in range(len(m)):
        if len(m)%2!=0 and i==len(m)-1:
            break
        if a<=b and a+m[i][0]<=s//2:
            a+=m[i][0]
        else:
            b+=m[i][0]
    if b!=a:
        break
    t=None
    mm=m[0][0]
    for i in range(len(m)):
        if m[i][0] < mm:
            j=i
            t=m[i][1]
            mm=m[i][0]
    m.pop(j)
    ans.append(t+1)
print(len(ans))
print(*ans)

from os import path
import sys,time
mod = int(1e9 + 7)
# import re
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque
from itertools import combinations ,accumulate
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *
from functools import reduce
from operator import mul
star = lambda x: print(' '.join(map(str, x)))
grid = lambda  r :[lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
INF = float('inf')
if (path.exists('input.txt')):
    sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
import sys
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil
def st(): return list(stdin.readline().strip())
def inp():
    return int(stdin.readline())
def inlt():
    return list(map(int, stdin.readline().split()))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return map(int, stdin.readline().split())
def pr(n): return stdout.write(str(n)+"\n")
from copy import deepcopy
def subset_sum(a,n,target):
    dp = [[False for _ in range(target+1)]for _ in range(n+1)]
    for i in range(n+1):
        for j in range(target+1):
            if i==0:
                dp[i][j] = False
            if j==0:
                dp[i][j] = True
    for i in range(n+1):
        for j in range(target+1):
            if a[i-1]<=j:
                dp[i][j] = dp[i-1][j] or dp[i-1][j-a[i-1]]
            else:
                dp[i][j] = dp[i-1][j]
    return dp[n][target]
def solve():
    n = inp()
    a = inlt()
    if sum(a)%2:
        print(0)
    else:
        odd = False
        ind = 0
        if subset_sum(a,n,sum(a)//2):
            for i in range(n):
                if a[i]%2:
                    ind = i
                    odd = True
                    break
            if odd:
                print(1)
                print(ind+1)
            else:
                for i in range(1,11):
                    for j in range(n):
                        if a[i]%2:
                            print(1)
                            print(i+1)
                        else:
                            a[i]//=2
        else:
            print(0)

t = 1
#t = inp()
for _ in range(t):
    solve()

import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

n = int(input())
lst = list(map(int,input().split()))

sumN = sum(lst)

if sumN%2:
    print(0)
else:
    ans = 0
    dude = 0
    for ele in lst:
        dude ^= ele
    if dude!=0:
        print(0)
    else:
        for idx,ele in enumerate(lst):
            if ele%2:
                ans = idx + 1
                break

        if ans:
            print(1)
            print(ans)
        elif sumN//2%2:
            print(0)
        else:
            for idx,ele in enumerate(lst):
                if ((sumN-ele)//2)%2:
                    ans = idx + 1
                    break
            print(1)
            print(ans)

#"{} {} {}".format(maxele,minele,minele)

# yield " ".join([str(x) for x in ans])
# 2 4 4 2

# 2*10

#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n = I()
a = LI()
m = max(a)
dp = [[False] * (n * m + 1) for _ in range(n + 1)]
dp[0][0] = True
s = 0
ans = set()
for i in range(n):
    ai = a[i]
    for j in range(n * m + 1):
        dp[i+1][j] = dp[i][j]
    if (s + ai) % 2 == 0 and dp[i+1][(s + ai) // 2]:
        ans.add(i+1)
        continue
    s += ai
    for j in range(n * m + 1 - ai):
        if dp[i][j] and not dp[i+1][j + ai]:
            dp[i+1][j + ai] = True
ans = list(ans)
print(len(ans))
print(*ans)

#Fast I/O
import sys,os
import math
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')

# inputs template
from io import BytesIO, IOBase

def main():
    n=int(input())
    arr=list(MI())
    s=sum(arr)
    if s%2:
        print(0)
        return
    t=s//2
    mat=[[0 for i in range(t+1)] for j in range(n+1)]
    mat[0][0]=1
    for i in range(1,n+1):
        mat[i][0]=1
        for j in range(1,t+1):
            if arr[i-1]<=j:
                mat[i][j]=mat[i-1][j]|mat[i-1][j-arr[i-1]]
            else:
                mat[i][j]=mat[i-1][j]
    if mat[n][t]:
        found=False
        for i in range(1,32):
            if found:
                break
            for j in range(n):
                if arr[j]&(1<<i):
                    print(1)
                    print(j+1)
                    found=True
                    break
    else:
        print(0)

# Sample Inputs/Output
# 6 2
# 1 3 2 3 3 2
# 1 6
# 2 5

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

#for array of integers
def MI():return (map(int,input().split()))
# endregion
#for fast output, always take string
def outP(var): sys.stdout.write(str(var)+'\n')
# end of any user-defined functions

MOD=10**9+7

# main functions for execution of the program.

if __name__ == '__main__':
    #This doesn't works here but works wonders when submitted on CodeChef or CodeForces
    main()

n = int(input())
a = [int(_) for _ in input().split()]
c = a.copy()
for i in range(n):
    a[i] = a[i] % 2 + 2

sum = 0
for x in a:
    sum += x

if sum % 2 != 0:
    print(0)
    exit(0)

dp = [[-1 for _ in range((5 * n) + 1)] for _ in range(n + 1)]
def call(i, cursum):
    if dp[i][cursum] != -1:
        return dp[i][cursum]

    if cursum * 2 == sum:
        return True

    if i >= n:
        return False

    bad = False
    bad = bad | call(i + 1, cursum)
    bad = bad | call(i + 1, cursum + a[i])
    dp[i][cursum] = bad
    return dp[i][cursum]

if not call(0, 0):
    print(0)
    exit(0)

for i in range(n):
    if a[i] % 2 != 0:
        print(1)
        print(i + 1)
        exit(0)

id = -1
while id == -1:
    for i in range(n):
        if c[i] % 2 == 1:
            id = i
            break

        c[i] = c[i] // 2

print(1)
print(id + 1)

#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n = I()
a = LI()
m = max(a)
a = [[a[i], i] for i in range(n)]
a.sort(reverse=True)
dp = [[False] * (n * m + 1) for _ in range(n + 1)]
dp[0][0] = True
s = 0
ans = set()
for i in range(n):
    ai = a[i][0]
    idx = a[i][1]
    for j in range(n * m + 1):
        dp[i+1][j] = dp[i][j]
    if (s + ai) % 2 == 0 and dp[i+1][(s + ai) // 2]:
        ans.add(idx+1)
        continue
    s += ai
    for j in range(n * m + 1 - ai):
        if dp[i][j] and not dp[i+1][j + ai]:
            dp[i+1][j + ai] = True
ans = list(ans)
print(len(ans))
print(*ans)

def helper2(a,tar):
    pool = [0] * 200005
    pool[0] = 1
    for i in range(len(a)):
        for j in range(tar):
            if pool[j] == 1:
                pool[j+a[i]] = 1

        if pool[tar] == 1:
            return True

    return False

def helper(a):

    if sum(a) % 2 == 1:
        return -1

    if helper2(a,sum(a)//2):
        while True:
            for i in range(len(a)):
                if a[i] % 2 == 1:
                    return i
                a[i] = a[i] // 2
    else:
        return -1

#t = int(input())
#for i in range(t):
n = int(input())
a = list(map(int,input().split(" ")))
res = helper(a)
if res == -1:
    print(0)
else:
    print(1)
    print(res+1)

def con(n):
    t=bin(int(n))
    return t[::-1]

n=int(input())
l=list(map(con,input().split()))
c=float('inf')
for i in range(n):
    c=min(len(l[i]),c)

f=0
for i in range(c):
    for j in range(n):
        if l[j][i]=='1':
            print(1)
            print(j+1)
            f=1
            break
    if f==1:
        break

def inp():
    return [int(a) for a in input().split()]
def gcd(x, y):
    if y:
        return gcd(y, x % y)
    else:
        return x
def bad(array):
    st = set()
    st.add(0)
    for i in array:
        st1 = set()
        for j in st:
            st1.add(i + j)
        st = st.union(st1)
    if sum(array) // 2 in st:
        return True
    return False
ind = []
n = int(input())
a = inp()
prev = a[0]
for i in range(1, n):
    g = gcd(prev, a[i])
    prev = a[i]
for i in range(n):
    a[i] //= g
if sum(a) % 2 == 1:
    print(0)
else:
    if bad(a):
        for i in range(n):
            if a[i] % 2:
                print(1)
                print(i + 1)
                break
    else:
        print(0)

# Legends Always Come Up with Solution
# Author: Manvir Singh

import os
import sys
from io import BytesIO, IOBase
from math import gcd
def partion(a):
    su=sum(a)
    if su%2:
        return 0
    dp=[1]+[0]*su
    for i in a:
        for j in range(su,i-1,-1):
            dp[j]+=dp[j-i]
    return dp[su//2]
def gcd_Array(a):
    g=0
    for i in a:
        g=gcd(g,i)
    return g
def main():
    n=int(input())
    a=list(map(int,input().split()))
    if partion(a):
        g=gcd_Array(a)
        for i in range(n):
            a[i]=a[i]//g
        o,ind=0,0
        for i,v in enumerate(a):
            if v&1:
                o+=1
                ind=i+1
        if o&1:
            print(0)
        else:
            print(1)
            print(ind+1)
    else:
        print(0)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

import os
import sys
from io import BytesIO, IOBase
import math
from heapq import heappop, heappush, heapify, heapreplace
from collections import defaultdict, deque
from bisect import bisect_left, bisect_right
#from functools import lru_cache
import re
mod = 1000000007
mod1 = 998244353

def read():
    sys.stdin  = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')

# ------------------------------------------- Algos --------------------------------------------------------
def primeFactors(n):
    arr = []
    while n % 2 == 0:
        arr.append(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            arr.append(i)
            n = n // i
    if n > 2:
        arr.append(n)
    return arr
def primeFactorsSet(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s
def sieve(n):
    res=[0 for i in range(n+1)]
    #prime=set([])
    prime=[]
    for i in range(2,n+1):
        if not res[i]:
            #prime.add(i)
            prime.append(i)
            for j in range(1,n//i+1):
                res[i*j]=1
    return prime
def isPrime(n) : # Check Prime Number or not
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True
def countPrimesLessThanN(n):
    seen, ans = [0] * n, 0
    for num in range(2, n):
        if seen[num]: continue
        ans += 1
        seen[num*num:n:num] = [1] * ((n - 1) // num - num + 1)
    return ans
def gcd(x, y):
    return math.gcd(x, y)
def lcm(a,b):
    return (a // gcd(a,b))* b
def isBitSet(n,k):
    # returns the count of numbers up to N having K-th bit set.
    res = (n >> (k + 1)) << k
    if ((n >> k) & 1):
        res += n & ((1 << k) - 1)
    return res
def modular_exponentiation(x, y, p):    #returns (x^y)%p
    res = 1
    x = x % p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) :
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res
def nCr(n, r, p):    # returns nCr % p
    num = den = 1
    for i in range(r):
        num = (num * (n - i)) % p
        den = (den * (i + 1)) % p
    return (num * pow(den,
            p - 2, p)) % p
def smallestDivisor(n):
    if (n % 2 == 0):
        return 2
    i = 3
    while(i * i <= n):
        if (n % i == 0):
            return i
        i += 2
    return n

class DisjointSetUnion:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n

    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a

    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a == b:
            return False
        if self.size[a] < self.size[b]:
            a, b = b, a
        self.num_sets -= 1
        self.parent[b] = a
        self.size[a] += self.size[b]
        return True

    def set_size(self, a):
        return self.size[self.find(a)]

    def __len__(self):
        return self.num_sets

# -------------------------------------------------- code -------------------------------------------------
def subsetSum(elements, target):
    dp = [False]*(target+1)
    dp[0] = True
    for ele in elements:
        for j in range(target, ele - 1, -1):
            if dp[j - ele]:
                dp[j] = True
    return dp[target]

def main():
    n = int(input())
    arr = list(map(int, input().split()))

    if not subsetSum(arr, sum(arr)//2):
        print(0)
        return

    g = 0
    odd = -1
    for i in range(n):
        g = gcd(g, arr[i])
        if arr[i]%2 == 1:
            odd = i+1
            break

    if odd != -1:
        print(1)
        print(odd)
        return

    ans = -1
    for i in range(n):
        if arr[i]//g % 2 == 1:
            ans = i+1
            break

    print(1)
    print(ans)

# ---------------------------------------------- region fastio ---------------------------------------------
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------------------------------------- end region ---------------------------------------------

if __name__ == "__main__":
    #read()
    main()

def solve(arr):
    s = sum(arr)
    if s & 1:
        print(0)
        return
    half = s // 2
    dp = [False] * (half + 1)
    dp[0] = True
    for a in arr:
        if a > half:
            print(0)
            return
        for j in range(half, a - 1, -1):
            dp[j] = dp[j] or dp[j - a]
    if not dp[-1]:
        print(0)
        return

    found = [None] * 13
    for a in arr:
        for i in range(13):
            if not found[i] and (a >> i) & 1:
                found[i] = a
    for i in range(13):
        if found[i]:
            print(1)
            print(found[i])
            return

# t = int(input())
# for _ in range(t):
    # n, k = [int(x) for x in input().split()]
n = int(input())
arr = [int(x) for x in input().split()]
solve(arr)

# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

import os
import sys
from io import BytesIO, IOBase
import math
from heapq import heappop, heappush, heapify, heapreplace
from collections import defaultdict, deque
from bisect import bisect_left, bisect_right
#from functools import lru_cache
import re
mod = 1000000007
mod1 = 998244353

def read():
    sys.stdin  = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')

# ------------------------------------------- Algos --------------------------------------------------------
def primeFactors(n):
    arr = []
    while n % 2 == 0:
        arr.append(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            arr.append(i)
            n = n // i
    if n > 2:
        arr.append(n)
    return arr
def primeFactorsSet(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s
def sieve(n):
    res=[0 for i in range(n+1)]
    #prime=set([])
    prime=[]
    for i in range(2,n+1):
        if not res[i]:
            #prime.add(i)
            prime.append(i)
            for j in range(1,n//i+1):
                res[i*j]=1
    return prime
def isPrime(n) : # Check Prime Number or not
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True
def countPrimesLessThanN(n):
    seen, ans = [0] * n, 0
    for num in range(2, n):
        if seen[num]: continue
        ans += 1
        seen[num*num:n:num] = [1] * ((n - 1) // num - num + 1)
    return ans
def gcd(x, y):
    return math.gcd(x, y)
def lcm(a,b):
    return (a // gcd(a,b))* b
def isBitSet(n,k):
    # returns the count of numbers up to N having K-th bit set.
    res = (n >> (k + 1)) << k
    if ((n >> k) & 1):
        res += n & ((1 << k) - 1)
    return res
def modular_exponentiation(x, y, p):    #returns (x^y)%p
    res = 1
    x = x % p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) :
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res
def nCr(n, r, p):    # returns nCr % p
    num = den = 1
    for i in range(r):
        num = (num * (n - i)) % p
        den = (den * (i + 1)) % p
    return (num * pow(den,
            p - 2, p)) % p
def smallestDivisor(n):
    if (n % 2 == 0):
        return 2
    i = 3
    while(i * i <= n):
        if (n % i == 0):
            return i
        i += 2
    return n

class DisjointSetUnion:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n

    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a

    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a == b:
            return False
        if self.size[a] < self.size[b]:
            a, b = b, a
        self.num_sets -= 1
        self.parent[b] = a
        self.size[a] += self.size[b]
        return True

    def set_size(self, a):
        return self.size[self.find(a)]

    def __len__(self):
        return self.num_sets

# -------------------------------------------------- code -------------------------------------------------
def subsetSum(elements, target):
    dp = [False]*(target+1)
    dp[0] = True
    for ele in elements:
        for j in range(target, ele - 1, -1):
            if dp[j - ele]:
                dp[j] = True
    return dp[target]

def main():
    n = int(input())
    arr = list(map(int, input().split()))
    s = sum(arr)
    if s%2 == 1:
        print(0)
        return

    if subsetSum(arr, s//2):
        g = 0
        odd = -1
        for i in range(n):
            if arr[i]%2 == 1:
                odd = i+1
                break
            else:
                g = gcd(g, arr[i])
        if odd != -1:
            print(1)
            print(odd)
        else:
            z = -1
            for i in range(n):
                arr[i] = arr[i]//g
                if arr[i]//4 != 0:
                    z = i+1
                    break
            if z != -1:
                print(1)
                print(z)
                return

            de = deque(arr)
            a = -1
            for i in range(n):
                x = de.popleft()

                if not subsetSum(de, (s-x)//2):
                    a = i+1
                    break

                else:
                    de.append(x)
            print(1)
            print(a)

    else:
        print(0)

# ---------------------------------------------- region fastio ---------------------------------------------
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------------------------------------- end region ---------------------------------------------

if __name__ == "__main__":
    #read()
    main()

import sys
sys.setrecursionlimit(int(1e4))
def alreadygood(ind, sm):
    dp = [[False for i in range(200001)] for j in range(n + 1)]
    for i in range(200001):
        if i == s - i:
            dp[n - 1][i] = True
    for ind in range(n - 2, -1, -1):
        for sm in range(s - 1, -1, -1):
            dp[ind][sm] = dp[ind + 1][sm] | dp[ind + 1][sm + lis[ind]]
    return dp[0][0]

import sys, math ; input = lambda :sys.stdin.readline().rstrip()
I=lambda:[*map(int,input().split())]
n, = I()
lis = I()
dp = dict()
s = sum(lis)
if sum(lis) & 1:
    print(0)
    exit()
else:
    odd = False
    for i, j in enumerate(lis):
        if j & 1:
            print(1)
            print(i + 1)
            odd = True
            exit()
    if odd == False:
        if not alreadygood(0, 0):
            print(0)
        else:
            mn = 1 << 69 ; ind = None
            for i in range(n):
                val = math.log2(lis[i]&-lis[i])+1
                if val < mn:
                    mn = val ; ind = i
            print(1)
            print(ind + 1)

import os
import sys
from io import BytesIO, IOBase

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda dtype: dtype(input().strip())
inp_d = lambda dtype: [dtype(x) for x in input().split()]
inp_2d = lambda dtype, n: [inp(dtype) for _ in range(n)]
inp_2ds = lambda dtype, n: [inp_d(dtype) for _ in range(n)]
inp_enu = lambda dtype: [(i, x) for i, x in enumerate(inp_d(dtype))]
inp_enus = lambda dtype, n: [[i, inp_d(dtype)] for i in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b
lsone = lambda x: x & (-x)

n, a = inp(int), inp_d(int)
mem, su = [False] * (10 ** 5 + 1), sum(a)

for i in range(n):
    for j in range(10 ** 5 - a[i] + 1):
        mem[a[i] + j] = True

if su & 1 or not mem[su >> 1]:
    print(0)
else:
    print(1, a.index(min(a, key=lambda x: lsone(x))) + 1, sep='\n')

import sys
sys.setrecursionlimit(int(1e4))
def alreadygood(ind, sm):
    dp = [[False for i in range(20001)] for j in range(n + 1)]
    for i in range(20001):
        if i == s - i:
            dp[n - 1][i] = True
    for ind in range(n - 2, -1, -1):
        for sm in range(s - 1, -1, -1):
            dp[ind][sm] = dp[ind + 1][sm] | dp[ind + 1][sm + lis[ind]]
    return dp[0][0]

import sys, math ; input = lambda :sys.stdin.readline().rstrip()
I=lambda:[*map(int,input().split())]
n, = I()
lis = I()
dp = dict()
s = sum(lis)
if sum(lis) & 1:
    print(0)
    exit()
else:
    odd = False
    for i, j in enumerate(lis):
        if j & 1:
            print(1)
            print(i + 1)
            odd = True
            exit()
    if odd == False:
        if not alreadygood(0, 0):
            print(0)
        else:
            print(1)
            print(lis.index(min(lis)) + 1)

# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase

def knapsack(n,wt,w,dp):

    for i in range(n+1):
        dp[i][0]=1

    for r in range(1,n+1):
        for c in range(1,w+1):
            if wt[r-1]<=w:
                dp[r][c]=dp[r-1][c] or dp[r-1][c-wt[r-1]]
            else:
                dp[r][c]=0

    return dp[n][w]

def main():
    n=int(input())
    a=list(map(int,input().split()))
    s=sum(a)

    if s%2==0:

        dp=[[0 for _ in range(s//2+1)]for _ in range(n+1)]

        if knapsack(n,a,s//2,dp):

            # for item in dp:
            #     print(*item)

            for i,item in enumerate(a):
                if item%2:
                    print(1)
                    print(i+1)
                    break
                elif dp[n][((s-item)//2)]==0:
                    print(1)
                    print(i+1)
                    break
        else:
            print(0)
    else:
        print(0)

# 6
# 2 4 6 8 10 10

#----------------------------------------------------------------------------------------
def nouse0():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse1():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse2():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

def nouse3():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse4():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse5():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# endregion

if __name__ == '__main__':
    main()

 ######      ###      #######    #######    ##      #     #####        ###     #####
 #     #    #   #          #        #       # #     #    #     #      #   #     ###
 #     #   #     #        #         #       #  #    #   #       #    #     #    ###
 ######   #########      #          #       #   #   #   #           #########    #
 ######   #########     #           #       #    #  #   #           #########    #
 #     #  #       #    #            #       #     # #   #    ####   #       #    #
 #     #  #       #   #             #       #      ##   #    #  #   #       #
 ######   #       #  #######     #######    #       #    #####  #   #       #    #

# mandatory imports
import os
import sys
from io import BytesIO, IOBase
from math import log2, ceil, sqrt, gcd, log

# optional imports
# from itertools import permutations
# from functools import cmp_to_key  # for adding custom comparator
# from fractions import Fraction
from collections import *
from bisect import *
# from __future__ import print_function # for PyPy2
from heapq import *
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

g   = lambda : input().strip()
gl  = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")

n, = gil()
a = gil()
if sum(a)&1:
    print(0)
    exit()
idx = 0
p = int(log2(a[0]))

for i in range(1, n):
    pi = int(log2(a[i]))
    if pi < p:
        idx = i
        p = pi

print(1)
print(idx+1)

import os
import sys
from io import BytesIO, IOBase

_print = print
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')

def inp():
    return sys.stdin.readline().rstrip()

def mpint():
    return map(int, inp().split(' '))

def itg():
    return int(inp())

# ############################## import
def sum_partition(iterable):
    iterable = tuple(iterable)
    s = sum(iterable)
    half = s >> 1
    dp = [0] * (half + 1)
    for i in range(len(iterable)):
        for h in range(half, iterable[i] - 1, -1):
            dp[h] = max(dp[h], dp[h - iterable[i]] + iterable[i])
    return dp[half] == s - dp[half]

# ############################## main
def main():
    n = itg()
    arr = tuple(mpint())
    if not sum_partition(arr):
        print(0)
        return

    print(1)
    d = {}
    for i, a in enumerate(arr):
        d[a] = i + 1

    while True:
        for k in tuple(d):
            if k & 1:
                print(d[k])
                return
            else:
                d[k >> 1] = d[k]
                del d[k]

DEBUG = 0
URL = 'https://codeforces.com/contest/1516/problem/C'

if __name__ == '__main__':
    # 0: normal, 1: runner, 2: debug, 3: interactive
    if DEBUG == 1:
        import requests
        from ACgenerator.Y_Test_Case_Runner import TestCaseRunner

        runner = TestCaseRunner(main, URL)
        inp = runner.input_stream
        print = runner.output_stream
        runner.checking()
    else:
        if DEBUG != 2:
            sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
        if DEBUG:
            def print(*args, **kwargs):
                _print(*args, **kwargs)
                sys.stdout.flush()
        main()
# Please check!

def helper2(a,tar):
    pool = [0] * 200005
    pool[0] = 1
    for i in range(len(a)):
        for j in range(tar):
            if pool[j] == 1:
                pool[j+a[i]] = 1
    #print(pool[tar])
    return pool[tar] == 1

def helper(a):

    if sum(a) % 2 == 1:
        return -1

    if helper2(a,sum(a)//2):
        while True:
            for i in range(len(a)):
                if a[i] % 2 == 1:
                    return i
                a[i] = a[i] // 2
    else:
        return -1

#t = int(input())
#for i in range(t):
n = int(input())
a = list(map(int,input().split(" ")))
#print(len(a))
res = helper(a)
if res == -1:
    print(0)
    print()
else:
    print(1)
    print(res+1)

import sys
input = sys.stdin.readline
def canPartition(a,i,target,num):
    global final
    if target==0:
        final = min(final,num)
        return True
    if i>=len(a) or target<0:
        return False
    if (i,target) in memo:
        return memo[i,target]
    memo[i,target] =  canPartition(a,i+1,target,num) or canPartition(a,i+1,target-a[i],min(num,a[i]))
    return memo[i,target]
n = int(input())
a = list(map(int,input().split()))
s = sum(a)
if s%2==1:
    print(0)
else:
    final = float("inf")
    memo = {}
    d = {i:v for v,i in enumerate(a)}
    for i in range(n):
        if a[i]%2==1:
            print(1)
            print(i+1)
            break
    else:
        flag = False
        while True:
            for i in range(n):
                a[i]//=2
            for i in range(n):
                if a[i]%2==1:
                    print(1)
                    print(i+1)
                    flag = True
                    break
            if flag:
                break

from os import path
import sys,time
mod = int(1e9 + 7)
# import re
from math import ceil, floor,gcd,log,log2 ,factorial,sqrt
from collections import defaultdict ,Counter , OrderedDict , deque
from itertools import combinations ,accumulate
# from string import ascii_lowercase ,ascii_uppercase
from bisect import *
from functools import reduce
from operator import mul
star = lambda x: print(' '.join(map(str, x)))
grid = lambda  r :[lint() for i in range(r)]
stpr = lambda x : sys.stdout.write(f'{x}' + '\n')
INF = float('inf')
if (path.exists('input.txt')):
    sys.stdin=open('input.txt','r');sys.stdout=open('output.txt','w');
import sys
from sys import stdin, stdout
from collections import *
from math import gcd, floor, ceil
def st(): return list(stdin.readline().strip())
def inp():
    return int(stdin.readline())
def inlt():
    return list(map(int, stdin.readline().split()))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def invr():
    return map(int, stdin.readline().split())
def pr(n): return stdout.write(str(n)+"\n")
from copy import deepcopy
def subset_sum(a,n,target):
    dp = [[False for _ in range(target+1)]for _ in range(n+1)]
    for i in range(n+1):
        for j in range(target+1):
            if i==0:
                dp[i][j] = False
            if j==0:
                dp[i][j] = True
    for i in range(n+1):
        for j in range(target+1):
            if a[i-1]<=j:
                dp[i][j] = dp[i-1][j] or dp[i-1][j-a[i-1]]
            else:
                dp[i][j] = dp[i-1][j]
    return dp[n][target]
def solve():
    n = inp()
    a = inlt()
    if sum(a)%2:
        print(0)
    else:
        odd = False
        ind = 0
        if subset_sum(a,n,sum(a)//2):
            for i in range(n):
                if a[i]%2:
                    ind = i
                    odd = True
                    break
            if odd:
                print(1)
                print(ind+1)
            else:
                for i in range(1,11):
                    for j in range(n):
                        if a[i]%2:
                            print(1)
                            print(i+1)
                            break
                        else:
                            a[i]//=2
        else:
            print(0)

t = 1
#t = inp()
for _ in range(t):
    solve()

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(10**5)
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def main():
    pass

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# import sys
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")

def solution():
	n=int(input())
	arr=list(map(int,input().split()))
	sm=sum(arr)

	if sm%2!=0:
		print(0)
		return
	else:
		target=sm//2
		dp=[[False for i in range(target+1)] for j in range(n+1)]

		for i in range(n+1):
			dp[i][0]=True

		for i in range(1,n+1):
			for j in range(1, target+1):
				if arr[i-1]<=j:
					dp[i][j]=dp[i-1][j-arr[i-1]] or dp[i-1][j]
				else:
					dp[i][j]=dp[i-1][j]

		if not dp[-1][-1]:
			print(0)
			return
		for i in range(n):
			if arr[i]%2!=0:
				print(1)
				print(i+1)
				return

		for i in range(n):
			temp=sm-arr[i]
			temp=temp//2
			if temp%2!=0:
				print(1)
				print(i+1)

	return

# t=int(input())
# while t:
# 	t-=1
solution()

n=int(input())
pow=[2,4,8,16,32,64,128,256,512,1024]
s=[int(i) for i in input().split()]
fl=True
for i in range(len(s)):
    if s[i]!=2000:
        fl=False
    s[i]=[s[i],i]
if fl:
    print(1,1,sep='\n')
    exit()
n=len(s)
k=0
for i in range(len(s)):
    k+=s[i][0]
if k%2!=0:
    print(0)
    exit()
ans=[]
state = True
while state:
    n = len(s)
    k=0
    for i in range(len(s)):
        k += s[i][0]
    p=[[False for i in range(n+2)] for i in range((k//2)+2)]
    for i in range(1,n+2):
        if i<=k//2+1:
            p[i][0]=True
        p[0][i]=True
    for i in range(1,k//2+1):
        for j in range(1,n+1):
            if (i-s[j-1][0])>=0:
                p[i][j]=p[i][j-1] or p[i-s[j-1][0]][j-1]
            else:
                p[i][j]=p[i][j-1]
    state = p[-1][-1]
    if len(s)>0:
        m=s[0][0]
        t=0
    else:
        break
    j=0
    mj=11
    for i in range(len(s)):
        if s[i][0]%2!=0:
            t=s[i][1]
            tmp=i
            break
        for j in range(len(pow)):
            if s[i][0]%pow[j]!=0:
                if mj>j:
                    mj=j
                    t=s[i][1]
                    tmp=i
    s.pop(tmp)
    ans.append(t+1)
print(len(ans))
print(*ans)

#!/usr/bin/env python3

import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

n = I()
a = LI()
s = sum(a)
m = max(a)
if s % 2:
    print(0)
else:
    dp = [[False] * (n * m + 1) for _ in range(n + 1)]
    dp[0][0] = True
    for i in range(n):
        ai = a[i]
        for j in range(n * m + 1):
            dp[i+1][j] = dp[i][j]
        for j in range(n * m + 1 - ai):
            if dp[i][j] and not dp[i+1][j + ai]:
                dp[i+1][j + ai] = True
    if dp[n][s//2]:
        print(1)
        print(a.index(min(a)) + 1)
    else:
        print(0)

n = int(input())
a = list(map(int, input().split()))
s = sum(a)
if s % 2 == 1:
    print(0)
    exit()
dp = [[False] * (s // 2+10) for _ in range(n + 1)]
dp[0][0] = True
for i in range(n):
    for j in range(s // 2+10):
        if j < a[i]:
            dp[i + 1][j] = dp[i][j]
        else:
            dp[i + 1][j] |= dp[i][j - a[i]]
if not dp[n][s//2]:
    print(0)
else:
    l = []
    for i in a:
        cnt = 0
        while i % 2 == 0:
            i //= 2
            cnt += 1
        l.append(cnt)
    print(1)
    print(l.index(min(l))+1)

def find(a):
    t = sum(a)
    if t%2 == 1:
        return -1
    else:
        tar = t//2
        s = set()
        s.add(0)
        count = 0
        for i in a[:-1]:
           count += i
           t = count%tar
           if t in s and i!=0:
               return 0
           s.add(t)
        return -1
def process(a):

    num = float('inf')
    ind = 0
    for i in range(len(a)):
        count = 0
        while a[i]&1 == 0:
            a[i] = a[i] >> 1
            count+=1
        if (count < num):
            num = count
            ind = i+1
    print(1)
    print(ind)

ilg = int(input())
a = list(map(int, input().split()))
r = find(a)
if (r==-1 or len(a) <=1):
    print(0)
else:
    process(a)

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    a = list(map(int,input().split()))
    vis = [False]*(2000*100)+[False]
    vis[0]=True
    for i in range(n):
        for j in range(len(vis)-a[i]-1,-1,-1):
            if not vis[j]:continue
            vis[a[i]+j]=True
    sm = sum(a)
    if (not vis[sm//2] or sm%2!=0):
        print(0)
        return
    idx= -1

    log  =32
    div= float('inf')
    for pw in range(log,-1,-1):
        for i in range(n):
            if a[i]//(2**pw)>0:
                div = min(div,a[i]//(2**pw))

    for i in range(n):
        a[i]/=div
        if a[i]%2!=0:
            idx =i
            break
    print(1)
    print(idx+1)
    return

t= 1#int(input())
for _ in range(t):
    solve()

x=int(input())
ar=list(map(int,input().split()))[:x]
s=sum(ar)
b=[]
for j in range(x):
    if(ar[j]%2==1):
        b.append(j)
if(s%2):
    print(0)
else:
    if(s%3==0):
        for k in b:
            if ar[k]%6:
                print(1)
                print(k+1)
                break
    else:
        print(1)
        print(b[0]+1)

#!/usr/bin/env python3.9
from pprint import pprint
n = int(input())
a = list(map(int, input().split(' ')))
# print(a)
sa = sum(a)
if sa % 2 != 0:
    # array already good
    # print('sum is odd')
    print(0)
else:
    target = sa // 2
    # print(target)
    # pack knapsack
    # i items, j target capacity
    d = [[0 for _ in range(target+1)] for _ in range(n)]
    d[0][0] = 1
    for i in range(1, n):
        wi = a[i-1]
        for j in range(1, target+1):
            using_wi = d[i-1][j-wi] if j-wi >= 0 else 0
            d[i][j] = d[i-1][j] or using_wi
    # [print(*row) for row in d]
    if d[-1][-1] == False:
        # array is good
        print(0)
    else:
        # drop odd number
        drop_idx = -1
        for i in range(n):
            if a[i] % 2 == 1:
                drop_idx = i
                break
        if drop_idx == -1:
            # full array of even numbers
            for i in range(n):
                if a[i] % 4 == 2:
                    drop_idx = i
                    break
        if drop_idx == -1:
            drop_idx = a.index(max(a))

        print(1)
        print(drop_idx + 1)
        # print(a[drop_idx])

#!/usr/bin/env python
#from __future__ import division, print_function
import math
import os
import sys
#from fractions import *
from sys import *
from decimal import *
from io import BytesIO, IOBase
from itertools import accumulate,combinations,permutations,combinations_with_replacement,product
from collections import *
#import timeit,time
#sys.setrecursionlimit(10**5)
M = 10 ** 9 + 7
import heapq

# print(math.factorial(5))
if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
# sys.setrecursionlimit(10**6)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()
if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

def inp(): return sys.stdin.readline().rstrip("\r\n")  # for fast input

def out(var): sys.stdout.write(str(var))  # for fast output, always take string

def lis(): return list(map(int, inp().split()))

def stringlis(): return list(map(str, inp().split()))

def sep(): return map(int, inp().split())

def strsep(): return map(str, inp().split())

def fsep(): return map(float, inp().split())

def inpu(): return int(inp())

# -----------------------------------------------------------------

def regularbracket(t):
    p = 0
    for i in t:
        if i == "(":
            p += 1
        else:
            p -= 1
        if p < 0:
            return False
    else:
        if p > 0:
            return False
        else:
            return True
# -------------------------------------------------
def binarySearchcount(arr, n, key):
    left = 0
    right = n - 1
    count = 0
    while (left <= right):
        mid = int((right + left) / 2)
        # Check if middle element is
        # less than or equal to key
        if (arr[mid] <= key):
            count = mid + 1
            left = mid + 1
        # If key is smaller, ignore right half
        else:
            right = mid - 1
    return count

#--------------------------------------------------binery search
def binarySearch(arr, n, key):
    left = 0
    right = n - 1
    while (left <= right):
        mid = ((right + left) // 2)
        if arr[mid]==key:
            return mid
        if (arr[mid] <= key):
            left = mid + 1
        # If key is smaller, ignore right half
        else:
            right = mid - 1
    return -1
#-------------------------------------------------ternary search
def ternarysearch(arr,n,key):
    l,r=0,n-1
    while(l<=r):
        mid = (-l+r)//3 + l
        mid2 = mid + (-l+r)//3
        if arr[mid]==key:
            return mid
        if arr[mid2]==key:
            return mid2
        if arr[mid]>key:
            r=mid-1
        elif arr[mid2]<key:
            l=mid2+1
        else:
            l=mid+1
            r=mid2-1
    return -1
# ------------------------------reverse string(pallindrome)
def reverse1(string):
    pp = ""
    for i in string[::-1]:
        pp += i
    if pp == string:
        return True
    return False

# --------------------------------reverse list(paindrome)
def reverse2(list1):
    l = []
    for i in list1[::-1]:
        l.append(i)
    if l == list1:
        return True
    return False

def mex(list1):
    # list1 = sorted(list1)
    p = max(list1) + 1
    for i in range(len(list1)):
        if list1[i] != i:
            p = i
            break
    return p

def sumofdigits(n):
    n = str(n)
    s1 = 0
    for i in n:
        s1 += int(i)
    return s1

def perfect_square(n):
    s = math.sqrt(n)
    if s == int(s):
        return True
    return False

# -----------------------------roman
def roman_number(x):
    if x > 15999:
        return
    value = [5000, 4000, 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
    symbol = ["F", "MF", "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
    roman = ""
    i = 0
    while x > 0:
        div = x // value[i]
        x = x % value[i]
        while div:
            roman += symbol[i]
            div -= 1
        i += 1
    return roman

def soretd(s):
    for i in range(1, len(s)):
        if s[i - 1] > s[i]:
            return False
    return True

# print(soretd("1"))
# ---------------------------
def countRhombi(h, w):
    ct = 0
    for i in range(2, h + 1, 2):
        for j in range(2, w + 1, 2):
            ct += (h - i + 1) * (w - j + 1)
    return ct

def countrhombi2(h, w):
    return ((h * h) // 4) * ((w * w) // 4)

# ---------------------------------
def binpow(a, b):
    if b == 0:
        return 1
    else:
        res = binpow(a, b // 2)
    if b % 2 != 0:
        return res * res * a
    else:
        return res * res

# -------------------------------------------------------
def binpowmodulus(a, b, M):
    if b==1:
        return a%M
    if b==0:
        return 1
    if b%2==0:
        ans=binpowmodulus(a,b//2,M)
        return (ans*ans)%(M)
    else:
        ans=binpowmodulus(a,(b-1)//2,M)
        return ((ans*a)%M * ans)%M
# -------------------------------------------------------------
def coprime_to_n(n):
    result = n
    i = 2
    while (i * i <= n):
        if (n % i == 0):
            while (n % i == 0):
                n //= i
            result -= result // i
        i += 1
    if (n > 1):
        result -= result // n
    return result

def luckynumwithequalnumberoffourandseven(x,n,a):
    if x >= n and str(x).count("4") == str(x).count("7"):
        a.append(x)
    else:
        if x < 1e12:
            luckynumwithequalnumberoffourandseven(x * 10 + 4,n,a)
            luckynumwithequalnumberoffourandseven(x * 10 + 7,n,a)
    return a
#----------------------
def luckynum(x,l,r,a):
    if x>=l and x<=r:
        a.append(x)
    if x>r:
        a.append(x)
        return a
    if x < 1e10:
            luckynum(x * 10 + 4, l,r,a)
            luckynum(x * 10 + 7, l,r,a)
    return a

def luckynuber(x, n, a):
    p = set(str(x))
    if len(p) <= 2:
        a.append(x)
    if x < n:
        luckynuber(x + 1, n, a)
    return a

# ------------------------------------------------------interactive problems

def interact(type, x):
    if type == "r":
        inp = input()
        return inp.strip()
    else:
        print(x, flush=True)

# ------------------------------------------------------------------zero at end of factorial of a number
def findTrailingZeros(n):
    # Initialize result
    count = 0

    # Keep dividing n by
    # 5 & update Count
    while (n >= 5):
        n //= 5
        count += n

    return count

# -----------------------------------------------merge sort
# Python program for implementation of MergeSort
def mergeSort(arr):
    if len(arr) > 1:

        # Finding the mid of the array
        mid = len(arr) // 2

        # Dividing the array elements
        L = arr[:mid]

        # into 2 halves
        R = arr[mid:]

        # Sorting the first half
        mergeSort(L)

        # Sorting the second half
        mergeSort(R)

        i = j = k = 0

        # Copy data to temp arrays L[] and R[]
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1

        # Checking if any element was left
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1

        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# -----------------------------------------------lucky number with two lucky any digits
res = set()
def solven(p, l, a, b, n):  # given number
    if p > n or l > 10:
        return
    if p > 0:
        res.add(p)
    solven(p * 10 + a, l + 1, a, b, n)
    solven(p * 10 + b, l + 1, a, b, n)

# problem
"""
n = int(input())
for a in range(0, 10):
    for b in range(0, a):
        solve(0, 0)
print(len(res))
"""

# In the array A at every step we have two
# choices for each element either we can
# ignore the element or we can include the
# element in our subset
def subsetsUtil(A, subset, index, d):
    print(*subset)
    s = sum(subset)
    d.append(s)
    for i in range(index, len(A)):
        # include the A[i] in subset.
        subset.append(A[i])

        # move onto the next element.
        subsetsUtil(A, subset, i + 1, d)

        # exclude the A[i] from subset and
        # triggers backtracking.
        subset.pop(-1)
    return d

def subsetSums(arr, l, r, d, sum=0):
    if l > r:
        d.append(sum)
        return
    subsetSums(arr, l + 1, r, d, sum + arr[l])

    # Subset excluding arr[l]
    subsetSums(arr, l + 1, r, d, sum)
    return d

def print_factors(x):
    factors = []
    for i in range(1, x + 1):
        if x % i == 0:
            factors.append(i)
    return (factors)

# -----------------------------------------------
def calc(X, d, ans, D):
    # print(X,d)
    if len(X) == 0:
        return

    i = X.index(max(X))
    ans[D[max(X)]] = d

    Y = X[:i]
    Z = X[i + 1:]

    calc(Y, d + 1, ans, D)
    calc(Z, d + 1, ans, D)

# ---------------------------------------

def factorization(n, l):
    c = n
    if prime(n) == True:
        l.append(n)
        return l
    for i in range(2, c):
        if n == 1:
            break
        while n % i == 0:
            l.append(i)
            n = n // i
    return l

# endregion------------------------------
def good(b):
    l = []
    i = 0
    while (len(b) != 0):
        if b[i] < b[len(b) - 1 - i]:
            l.append(b[i])
            b.remove(b[i])
        else:
            l.append(b[len(b) - 1 - i])
            b.remove(b[len(b) - 1 - i])
    if l == sorted(l):
        # print(l)
        return True
    return False

# arr=[]
# print(good(arr))
def generate(st, s):
    if len(s) == 0:
        return

    # If current string is not already present.
    if s not in st:
        st.add(s)

        # Traverse current string, one by one
        # remove every character and recur.
        for i in range(len(s)):
            t = list(s).copy()
            t.remove(s[i])
            t = ''.join(t)
            generate(st, t)
    return
#=--------------------------------------------longest increasing subsequence

def largestincreasingsubsequence(A):
    l = [1]*len(A)
    sub=[]
    for i in range(1,len(l)):
        for k in range(i):
            if A[k]<A[i]:
                sub.append(l[k])
        l[i]=1+max(sub,default=0)
    return max(l,default=0)

#----------------------------------Function to calculate Bitwise OR of sums of all subsequences
def findOR(nums, N):
    # Stores the prefix
    # sum of nums[]
    prefix_sum = 0
    # Stores the bitwise OR of
    # sum of each subsequence
    result = 0
    # Iterate through array nums[]
    for i in range(N):
        # Bits set in nums[i] are
        # also set in result
        result |= nums[i]
        # Calculate prefix_sum
        prefix_sum += nums[i]
        # Bits set in prefix_sum
        # are also set in result
        result |= prefix_sum
    # Return the result
    return result

def OR(a, n):
    ans = a[0]
    for i in range(1, n):
        ans |= a[i]
        #l.append(ans)
    return ans

def toString(List):
    return ''.join(List)
# Function to print permutations of string
# This function takes three parameters:
# 1. String
# 2. Starting index of the string
# 3. Ending index of the string.
def permute(a, l, r,p):
    if l == r:
        p.append(toString(a))
    else:
        for i in range(l, r + 1):
            a[l], a[i] = a[i], a[l]
            permute(a, l + 1, r,p)
            a[l], a[i] = a[i], a[l]  # backtrack
# Function to find square root of
# given number upto given precision
def squareRoot(number, precision):
    start = 0
    end, ans = number, 1
    # For computing integral part
    # of square root of number
    while (start <= end):
        mid = int((start + end) / 2)
        if (mid * mid == number):
            ans = mid
            break

        # incrementing start if integral
        # part lies on right side of the mid
        if (mid * mid < number):
            start = mid + 1
        # decrementing end if integral part
        # lies on the left side of the mid
        else:
            end = mid - 1
    # For computing the fractional part
    # of square root upto given precision
    increment = 0.1
    for i in range(0, precision):
        while (ans * ans <= number):
            ans += increment
        # loop terminates when ans * ans > number
        ans = ans - increment
        increment = increment / 10
    return ans

def countRectangles(l, w):
    squareSide = math.gcd(l, w)
    return int((l * w) / (squareSide * squareSide))

# Function that count the
# total numbersProgram between L
# and R which have all the
# digit same
def count_same_digit(L, R):
    tmp = 0
    ans = 0
    n = int(math.log10(R) + 1)
    for i in range(0, n):
        # tmp has all digits as 1
        tmp = tmp * 10 + 1
        for j in range(1, 10):

            if (L <= (tmp * j) and (tmp * j) <= R):
                #print(tmp*j)
                # Increment the required count
                ans += 1
    return ans
#----------------------------------print k closest number of a number in an array
def findCrossOver(arr, low, high, x):
    # Base cases
    if (arr[high] <= x):  # x is greater than all
        return high
    if (arr[low] > x):  # x is smaller than all
        return low
    # Find the middle point
    mid = (low + high) // 2
    if (arr[mid] <= x and arr[mid + 1] > x):
        return mid
    if (arr[mid] < x):
        return findCrossOver(arr, mid + 1, high, x)
    return findCrossOver(arr, low, mid - 1, x)
def Kclosest(arr, x, k, n,ans):
    # Find the crossover point
    l = findCrossOver(arr, 0, n - 1, x)
    r = l + 1
    count = 0
    if (arr[l] == x):
        l -= 1
    #print(l)
    while (l >= 0 and r < n and count < k):
        if (x - arr[l] < arr[r] - x):
            ans.append(arr[l])
            l -= 1
        else:
            ans.append(arr[r])
            r += 1
        count += 1
    while (count < k and l >= 0):
        ans.append(arr[l])
        l -= 1
        count += 1
    while (count < k and r < n):
        ans.append(arr[r])
        r += 1
        count += 1
    return ans
#---------------------------------------------------------------

def calcSum(arr, n, k):
    # Initialize sum = 0
    l=[]
    sum=0
    # Consider first subarray of size k
    # Store the sum of elements
    for i in range(k):
        sum += arr[i]

    # Print the current sum
    l.append(sum)

    # Consider every subarray of size k
    # Remove first element and add current
    # element to the window
    for i in range(k, n):
        # Add the element which enters
        # into the window and substract
        # the element which pops out from
        # the window of the size K
        sum = (sum - arr[i - k]) + arr[i]

        # Print the sum of subarray
        l.append(sum)

    return l

"""
def dfs(root,nodeVal,nodeConnection,visited):
    leftVal = nodeVal[root][0]
    rightVal = nodeVal[root][1]
    solution = []
    if nodeConnection[root]:
        visited.add(root)
        for i in nodeConnection[root]:
            if i not in visited:
                solution.append(dfs(i,nodeVal,nodeConnection,visited))
        # print("solution",solution)
        leftMax = 0
        rightMax = 0
        for i in solution:
            l, r = i
            leftMax += max(abs(leftVal - l[0]) + l[1], abs(leftVal - r[0]) + r[1])
            rightMax += max(abs(rightVal - l[0]) + l[1], abs(rightVal - r[0]) + r[1])
        # print(root,"return->",(leftVal,leftMax),(rightVal,rightMax))
        return ((leftVal, leftMax), (rightVal, rightMax))
    else:
        # ((left,maxVal),(right,maxVal))
        return ((leftVal, 0), (rightVal, 0))
"""
"""
def luckynumber(x,n,a):
    if x >0:
        a.append(x)
    if x>10**9:
        return a
    else:
        if x < 1e12:
            luckynumber(x * 10 + 4,n,a)
            luckynumber(x * 10 + 7,n,a)
def lcm(a,b):
    return (a*b)//math.gcd(a,b)

def query1(l, r):
    if l >= r:
        return -1
    print('?', l + 1, r + 1)
    sys.stdout.flush()
    return int(input()) - 1
def answer(p):
    print('!', p + 1)
    sys.stdout.flush()
    exit()

#---------------------count number of primes
"""
import math
MAX = 10**5
prefix = [0] * (MAX + 1)
def buildPrefix():
    prime = [1] * (MAX + 1)
    p = 2
    while (p * p <= MAX):
        if (prime[p] == 1):
            i = p * 2
            while (i <= MAX):
                prime[i] = 0
                i += p
        p += 1
    for p in range(2, MAX + 1):
        prefix[p] = prefix[p - 1]
        if (prime[p] == 1):
            prefix[p] += 1
def query(L, R):
    return prefix[R] - prefix[L - 1]
#buildPrefix()

def maxSubArraySum(a, size):
    max_so_far = a[0]
    curr_max = a[0]
    for i in range(1, size):
        curr_max = max(a[i], curr_max + a[i])
        max_so_far = max(max_so_far, curr_max)
    return max_so_far

def solve(n,k):
    if n==1 and k==1:
        return 0
    mid=(2**(n-1))//2
    if k<=mid:
        return solve(n-1,k)
    else:
        return solve(n-1,k-(mid))==0

#------------------print subset of strings
def solvr(s,p):
    if len(s)==0:
        print(p,end=" ")
        return
    op1=p
    op2=p+s[0]
    s=s[1:]
    solvr(s,op1)
    solvr(s,op2)
    return
#-------------------------------------balanced paranthesis
def paranthesis(n,m,ans,l):
    if n==0 and m==0:
        print(ans)
        return
    if n!=0:
        op1=ans+"("
        paranthesis(n-1,m,op1,l)
    if m>n:
        op2=ans+")"
        paranthesis(n,m-1,op2,l)
"""
class node:
    def __init__(self,data):
        self.data=data
        self.next=None
class linkedlis:
    def __init__(self):
        self.head=None
    def printlis(self):
        temp=self.head
        while(temp):
            print(temp.data,end=" ")
            temp=temp.next
    def pushfirst(self,new_data):
        new_node=node(new_data)
        new_node.next=self.head
        self.head=new_node
    def pushmid(self,previous_node,new_data):
        new_node=node(new_data)
        if previous_node==None:
            print("call pushfirst function if it is the the start otherwise raise an error.")
        new_node.next=previous_node.next
        previous_node.next=new_node
    def pushlast(self,new_data):
        new_node=node(new_data)
        if self.head==None:
            self.head=new_node
            return
        last=self.head
        while(last.next!=None):
            last=last.next
        last.next=new_node
    def delete_node(self,key):
        pass
if __name__ == '__main__':
    l=linkedlis()
    l.head= node(1)
    p = node(2)
    pp = node(4)
    l.head.next = p
    p.next = pp
    #print(l.head)
    l.pushmid(p, 3)
    l.pushlast(5)
    l.pushfirst(0)
    #l.printlis()
    #print(l.head.data)
"""
"""
def main():
        n=1000
        l=[12]*1000
        sum=12*100
        dp=[[False]*(sum+1) for i in range(n+1)]
        for i in range(n+1):
            dp[i][0]=True
        for i in range(1,n+1):
            for j in range(1,sum+1):
                if j<l[i-1]:
                    dp[i][j]=dp[i-1][j]
                else:
                    dp[i][j]=dp[i-1][j] or dp[i-1][j-l[i-1]]
        print(dp[n][sum])
if __name__ == '__main__':
    main()
"""
"""
def largestSubset(a, n):
    dp = [0 for i in range(n)]
    dp[n - 1] = 1
    for i in range(n - 2, -1, -1):
        mxm = 0
        for j in range(i + 1, n):
            if a[j] % a[i] == 0 or a[i] % a[j] == 0:
                mxm = max(mxm, dp[j])
        dp[i] = 1 + mxm
    # Return maximum value from dp[]
    return max(dp)
a = [4,6,12]
n = len(a)
print(largestSubset(a, n))
"""
"""
def rse(arr,n):
    stack=[]
    ans=[]
    for i in range(n-1,-1,-1):
        if len(stack)==0:
            ans.append(n)
        else:
            while(len(stack)!=0):
                if stack[-1][0]>=arr[i]:
                    stack.pop()
                else:
                    break
            if len(stack)==0:
                ans.append(n)
            else:
                ans.append(stack[-1][1])
        stack.append([arr[i],i])
    ans.reverse()
    return ans
def lse(arr,n):
    stack=[]
    ans=[]
    for i in range(n):
        if len(stack)==0:
            ans.append(-1)
        else:
            while(len(stack)!=0):
                if stack[-1][0]>=arr[i]:
                    stack.pop()
                else:
                    break
            if len(stack)==0:
                ans.append(-1)
            else:
                ans.append(stack[-1][1])
        stack.append([arr[i],i])
    return ans
"""
"""
def lcs(s,r):
    rr=len(r)
    ss=len(s)
    l=[[0]*(rr+1) for i in range(ss+1)]
    for i in range(ss+1):
        for j in range(rr+1):
            if i==0 and j==0:
                l[i][j]=0
            elif s[i-1]==r[j-1]:
                l[i][j]=l[i-1][j-1]+1
            else:
                l[i][j] =max(l[i-1][j],l[i][j-1])
    return l[ss][rr]
"""
def subsetsum(arr,sum,len):
    dp=[[False]*(sum+1) for i in range(len+1)]
    for i in range(len+1):
        dp[i][0]=True
    for i in range(1,len+1):
        for j in range(1,sum+1):
            if j==0:
                dp[i][j]=True
            elif arr[i-1]>j:
                dp[i][j]=dp[i-1][j]
            else:
                dp[i][j]=dp[i-1][j] or dp[i-1][j-arr[i-1]]
    #print(dp)
    return dp[len][sum]
#print(subsetsum([3,9,12],12,3))
def main():
    t=1
    #t=inpu()
    for _ in range(t):
        n=inpu()
        arr=lis()
        arr=arr
        if sum(arr)%2!=0:
            print(0)
            continue
        else:
            if subsetsum(arr,sum(arr)//2,len(arr))==True:
                print(1)
                pows = [-1] * 11
                for i in range(n):
                    if arr[i]%2!=0:
                        print(i+1)
                        break
                else:
                    print(0)
            else:
                print(0)
if __name__ == '__main__':
    main()

def inp():
    return [int(a) for a in input().split()]
def gcd(x, y):
    if y:
        return gcd(y, x % y)
    else:
        return x
def bad(array):
    st = set()
    st.add(0)
    for i in array:
        st1 = set()
        for j in st:
            st1.add(i + j)
        st = st.union(st1)
    if sum(array) // 2 in st:
        return True
    return False
ind = []
n = int(input())
a = inp()
if sum(a) % 2 == 1:
    print(0)
else:
    prev = a[0]
    for i in range(1, n):
        g = gcd(prev, a[i])
        prev = a[i]
    for i in range(n):
        a[i] //= g
    if bad(a):
        for i in range(n):
            if a[i] % 2:
                print(1)
                print(i + 1)
                break
    else:
        print(0)

#!/bin/python3

import math
import os
import random
import re
import sys

#
# Complete the 'timeConversion' function below.
#
# The function is expected to return a STRING.
# The function accepts STRING s as parameter.
#
if __name__ == '__main__':
    n=int(input())
    a = list(map(int,(input().split(' '))))
    temp = [[0]*(2000*n+1)]*2
    temp[1][0] = 1
    temp1 = 0
    for i in range(0,n):
        temp1+=a[i]
        for j in range(0,2000*n+1):
            if j>=a[i]:
                temp[(i%2)][j]|=temp[(i%2)^1][j-a[i]]
            temp[(i%2)][j]|=temp[(i%2)^1][j]
    pos = 0
    if ((temp1%2==1) or (temp1%2==0 and temp[(n%2)^1][int(temp1/2)]==0)):
        print(0)
    else:
        print(1)
        temp=0
        ind = 0
        for i in range(0,n):
            temp1=0
            while(a[i]%2):
                a[i]/=2
                temp1+=1
            if temp1>temp:
                temp=temp1
                ind=i
        print(ind+1)

from bisect import bisect,bisect_left

from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *

#------------------------------------------------------------------------
import os
import sys

from io import BytesIO, IOBase
# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------

from types import GeneratorType

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to

    return wrappedfunc

mod=10**9+7
farr=[1]
ifa=[]

def fact(x,mod=0):
    if mod:
        while x>=len(farr):
            farr.append(farr[-1]*len(farr)%mod)
    else:
        while x>=len(farr):
            farr.append(farr[-1]*len(farr))
    return farr[x]

def ifact(x,mod):
    global ifa
    fact(x,mod)
    ifa.append(pow(farr[-1],mod-2,mod))
    for i in range(x,0,-1):
        ifa.append(ifa[-1]*i%mod)
    ifa.reverse()

def per(i,j,mod=0):
    if i<j: return 0
    if not mod:
        return fact(i)//fact(i-j)
    return farr[i]*ifa[i-j]%mod

def com(i,j,mod=0):
    if i<j: return 0
    if not mod:
        return per(i,j)//fact(j)
    return per(i,j,mod)*ifa[j]%mod

def catalan(n):
    return com(2*n,n)//(n+1)

def isprime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False
    return True

def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
    if a==0:return b//c*(n+1)
    if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
    m=(a*n+b)//c
    return n*m-floorsum(c,c-b-1,a,m-1)

def inverse(a,m):
    a%=m
    if a<=1: return a
    return ((1-inverse(m,a)*m)//a)%m

def lowbit(n):
    return n&-n

class BIT:
    def __init__(self,arr):
        self.arr=arr
        self.n=len(arr)-1

    def update(self,x,v):
        while x<=self.n:
            self.arr[x]+=v
            x+=x&-x

    def query(self,x):
        ans=0
        while x:
            ans+=self.arr[x]
            x&=x-1
        return ans

class ST:
    def __init__(self,arr):#n!=0
        n=len(arr)
        mx=n.bit_length()#取不到
        self.st=[[0]*mx for i in range(n)]
        for i in range(n):
            self.st[i][0]=arr[i]
        for j in range(1,mx):
            for i in range(n-(1<<j)+1):
                self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
    def query(self,l,r):
        if l>r:return -inf
        s=(r+1-l).bit_length()-1
        return max(self.st[l][s],self.st[r-(1<<s)+1][s])

class DSU:#容量+路径压缩
    def __init__(self,n):
        self.c=[-1]*n

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def find(self,x):
        if self.c[x]<0:
            return x
        self.c[x]=self.find(self.c[x])
        return self.c[x]

    def union(self,u,v):
        u,v=self.find(u),self.find(v)
        if u==v:
            return False
        if self.c[u]>self.c[v]:
            u,v=v,u
        self.c[u]+=self.c[v]
        self.c[v]=u
        return True

    def size(self,x): return -self.c[self.find(x)]

class UFS:#秩+路径
    def __init__(self,n):
        self.parent=[i for i in range(n)]
        self.ranks=[0]*n

    def find(self,x):
        if x!=self.parent[x]:
            self.parent[x]=self.find(self.parent[x])
        return self.parent[x]

    def union(self,u,v):
        pu,pv=self.find(u),self.find(v)
        if pu==pv:
            return False
        if self.ranks[pu]>=self.ranks[pv]:
            self.parent[pv]=pu
            if self.ranks[pv]==self.ranks[pu]:
                self.ranks[pu]+=1
        else:
            self.parent[pu]=pv

def Prime(n):
    c=0
    prime=[]
    flag=[0]*(n+1)
    for i in range(2,n+1):
        if not flag[i]:
            prime.append(i)
            c+=1
        for j in range(c):
            if i*prime[j]>n: break
            flag[i*prime[j]]=prime[j]
            if i%prime[j]==0: break
    return flag

def dij(s,graph):
    d={}
    d[s]=0
    heap=[(0,s)]
    seen=set()
    while heap:
        dis,u=heappop(heap)
        if u in seen:
            continue
        seen.add(u)
        for v,w in graph[u]:
            if v not in d or d[v]>d[u]+w:
                d[v]=d[u]+w
                heappush(heap,(d[v],v))
    return d

def bell(s,g):#bellman-Ford
    dis=AI(n,inf)
    dis[s]=0
    for i in range(n-1):
        for u,v,w in edge:
            if dis[v]>dis[u]+w:
                dis[v]=dis[u]+w
    change=A(n)
    for i in range(n):
        for u,v,w in edge:
            if dis[v]>dis[u]+w:
                dis[v]=dis[u]+w
                change[v]=1
    return dis

def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
    res=[]
    for k in nums:
        i=bisect.bisect_left(res,k)
        if i==len(res):
            res.append(k)
        else:
            res[i]=k
    return len(res)

def RP(nums):#逆序对
    n = len(nums)
    s=set(nums)
    d={}
    for i,k in enumerate(sorted(s),1):
        d[k]=i
    bi=BIT([0]*(len(s)+1))
    ans=0
    for i in range(n-1,-1,-1):
        ans+=bi.query(d[nums[i]]-1)
        bi.update(d[nums[i]],1)
    return ans

class DLN:
    def __init__(self,val):
        self.val=val
        self.pre=None
        self.next=None

def nb(i,j,n,m):
    for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
        if 0<=ni<n and 0<=nj<m:
            yield ni,nj

def topo(n):
    q=deque()
    res=[]
    for i in range(1,n+1):
        if ind[i]==0:
            q.append(i)
            res.append(i)
    while q:
        u=q.popleft()
        for v in g[u]:
            ind[v]-=1
            if ind[v]==0:
                q.append(v)
                res.append(v)
    return res

@bootstrap
def gdfs(r,p):
    for ch in g[r]:
        if ch!=p:
            yield gdfs(ch,r)
    yield None

t=1
for i in range(t):
    n=N()
    a=RLL()
    s=sum(a)
    if s&1:
        print(0)
        exit()
    dp=1
    for i in range(n):
        dp|=dp<<a[i]
    if not dp>>(s//2):
        print(0)
        exit()
    print(1)
    g=G(12)
    for i,x in enumerate(a,1):
        c=0
        while not x&1:
            x//=2
            c+=1
        g[c].append(i)
    for i in range(12):
        if g[i]:
            print(g[i][0])
            exit()
    #print(ans)

'''
sys.setrecursionlimit(200000)
import threading
threading.stack_size(10**8)
t=threading.Thr
ead(target=main)
t.start()
t.join()
'''

def canPartition(nums):
    target, n = sum(nums), len(nums)
    if target & 1:
        return False
    target >>= 1
    dp = [True] + [False]*target
    for x in nums:
        dp = [dp[s] or (s >= x and dp[s-x]) for s in range(target+1)]
        if dp[target]:
            return True
    return False

n = int(input())
arr = [int(x) for x in input().split()]
res = []

while canPartition(arr):
    tmp = []
    tarr = arr
    print(tarr)
    for i in range(n):
        t = arr[:i] + arr[i+1:]
        if not canPartition(t):
            tmp.append(i)

    arr = arr[:min(tmp)] + arr[min(tmp)+1:]
    res.append(min(tmp))

if len(res) > 0:
    print(len(res))
    print(" ".join(str(x+1) for x in res))
else:
    print('0')

import sys
import math
from collections import defaultdict,Counter,deque

# input=sys.stdin.readline
# def print(x):
#     sys.stdout.write(str(x)+"\n")

import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b"\n") + (not b)
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode("ascii"))
		self.read = lambda: self.buffer.read().decode("ascii")
		self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')

# mod=pow(10,9)+7
# t=int(input())
# for i in range(t):
# 	n,q=map(int,input().split())
n=int(input())
a=list(map(int,input().split()))
s=0
for j in a:
	s+=j
if s&1:
	print(0)
	sys.exit()
s//=2
dp=[0]*(s+1)
dp[0]=1
for j in range(n):
	for k in range(1,s+1):
		if a[j]<=k:
			dp[k]|=dp[k-a[j]]

	if dp[s]==1:
		break
else:
	print(0)
	sys.exit()

print(1)
g=0
for j in range(n):
	g=math.gcd(g,a[j])

for j in range(n):
	a[j]//=g
	if a[j]&1:
		print(j+1)
		break

# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase

def knapsack(n,wt,w,dp):

    for i in range(n+1):
        dp[i][0]=1

    for r in range(1,n+1):
        for c in range(1,w+1):
            if wt[r-1]<=w:
                dp[r][c]=dp[r-1][c] or dp[r-1][c-wt[r-1]]
            else:
                dp[r][c]=0

    return dp[n][w]

def main():
    n=int(input())
    a=list(map(int,input().split()))
    s=sum(a)

    if s%2==0:

        dp=[[0 for _ in range(s//2+1)]for _ in range(n+1)]

        if knapsack(n,a,s//2,dp):

            # for item in dp:
            #     print(*item)

            for i,item in enumerate(a):
                if item%2:
                    print(1)
                    print(i+1)
                    break
                elif dp[n][((s-item)//2)]==0 or ((s-item)//2)%2:
                    print(1)
                    print(i+1)
                    break
            else:
                print(s)
        else:
            print(0)
    else:
        print(0)

# 6
# 2 4 6 8 10 10

#----------------------------------------------------------------------------------------
def nouse0():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse1():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse2():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

def nouse3():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse4():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse5():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# endregion

if __name__ == '__main__':
    main()

#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase
from functools import reduce

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def gcd(x, y):
    """greatest common divisor of x and y"""
    while y:
        x, y = y, x % y
    return x

def extended_gcd(a, b):
    """returns gcd(a, b), s, r s.t. a * s + b * r == gcd(a, b)"""
    s, old_s = 0, 1
    r, old_r = b, a
    while r:
        q = old_r // r
        old_r, r = r, old_r - q * r
        old_s, s = s, old_s - q * s
    return old_r, old_s, (old_r - old_s * a) // b if b else 0

gcdm = lambda *args: reduce(gcd, args, 0)

lcm = lambda a, b: a * b // gcd(a, b)

lcmm = lambda *args: reduce(lcm, args, 1)

def main():
    n = int(input())
    a = [int(ai) for ai in input().split()]
    g = gcdm(*a)
    a = [ai // g for ai in a]

    odd_idx = 0
    for i in range(n):
        if a[i] % 2:
            odd_idx = i
            break

    s = sum(a)
    if s % 2:
        print(0)
        return

    needed = s // 2

    dp = [0] * (needed + 1)
    dp[0] = 1
    for i in range(n):
        for j in range(needed + 1):
            dp[j] = dp[j] or (dp[j - a[i]] if j - a[i] > - 1 else 0)

    if dp[-1]:
        print(1)
        print(odd_idx + 1)
    else:
        print(0)

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == "__main__":
    main()

# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = "x" in file.mode or "r" not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b"\n") + (not b)
			ptr = self.buffer.tell()
			self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode("ascii"))
		self.read = lambda: self.buffer.read().decode("ascii")
		self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# ------------------- fast io --------------------
from math import ceil

def prod(a, mod=10**9+7):
	ans = 1
	for each in a:
		ans = (ans * each) % mod
	return ans

def gcd(x, y):
	while y:
		x, y = y, x % y
	return x

def lcm(a, b): return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else "0" * (length - len(y)) + y

for _ in range(int(input()) if not True else 1):
	n = int(input())
	#n, k = map(int, input().split())
	#a, b = map(int, input().split())
	#c, d = map(int, input().split())
	a = list(map(int, input().split()))
	#b = list(map(int, input().split()))
	#s = input()
	def f(n, a):
		total = sum(a)
		if total % 2:
			print(0)
			quit()
		mod4 = (total // 2) % 4
		dp = [-1]*(total // 2 + 1)
		dp[0] = 0
		for i in range(n):
			for j in range(0, total//2 + 1):
				if dp[j] != i+1 and dp[j] != -1 and a[i] + j <= total//2:
					dp[a[i] + j] = i+1
		if dp[total//2] == -1:
			print(0)
			quit()
		for i in range(n):
			if a[i] % 2:
				print(1)
				print(i+1)
				quit()

		if mod4 == 1 or mod4 == 3:
			print(0)
			quit()

		# all elements divisible by 2
		for i in range(n):
			if a[i] % 4 == 2:
				print(1)
				print(i+1)
				quit()
		a = [a[i]//4 for i in range(n)]
		f(n, a)
	f(n, a)

from sys import stdin,stdout
stdin.readline
def mp(): return list(map(int, stdin.readline().strip().split()))
def it():return int(stdin.readline().strip())
from collections import defaultdict as dd,Counter as C,deque
from math import ceil,gcd,sqrt,factorial,log2,floor

n = it()
l=mp()

su=sum(l)

if su&1:
	print(0)
else:
	t=[[False for i in range(su//2+1)] for _ in range(n+1)]

	for i in range(n+1):
		for j in range(su//2+1):
			if j==0:
				t[i][j]=True

	for i in range(1,n+1):
		for j in range(1,su//2+1):

			if j >= l[i-1]:
				t[i][j]=(t[i-1][j-l[i-1]] or t[i-1][j])

			else:
				t[i][j]=t[i-1][j]
	# print((t[n][su//2]))
	if (t[n][su//2]):
		ind = -1
		for i in range(n):
			if l[i]&1:
				ind = i
				break
		if ind != -1:
			print(1)
			print(ind+1)
		else:
			while 1:
				flag =0
				flag=0
				ind = -1
				for i in range(n):
					if l[i]&1:
						ind = i
						flag =1
						break
					else:
						l[i]//=2
				if flag:
					break
			print(1)
			print(ind+1)

 ######      ###      #######    #######    ##      #     #####        ###     #####
 #     #    #   #          #        #       # #     #    #     #      #   #     ###
 #     #   #     #        #         #       #  #    #   #       #    #     #    ###
 ######   #########      #          #       #   #   #   #           #########    #
 ######   #########     #           #       #    #  #   #           #########    #
 #     #  #       #    #            #       #     # #   #    ####   #       #    #
 #     #  #       #   #             #       #      ##   #    #  #   #       #
 ######   #       #  #######     #######    #       #    #####  #   #       #    #

# mandatory imports
import os
import sys
from io import BytesIO, IOBase
from math import log2, ceil, sqrt, gcd, log

# optional imports
# from itertools import permutations
# from functools import cmp_to_key  # for adding custom comparator
# from fractions import Fraction
from collections import *
from bisect import *
# from __future__ import print_function # for PyPy2
from heapq import *
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

g   = lambda : input().strip()
gl  = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")

n, = gil()
a = gil()
sm = sum(a)

def iszero(a, n):
    dp = [n]*((sm//2) + 1)
    dp[0] = -1
    for i in range(len(dp)):
        for j in range(dp[i]+1, n):
            if i + a[j] < len(dp) and dp[i+a[j]] > j:
                dp[i+a[j]] = j

    # print(*dp)
    return dp[-1] == n

if sm&1 or iszero(a, n):
    print(0)
    exit()
idx = 0
p = int(log2(a[0]))

for i in range(1, n):
    pi = int(log2(a[i]))
    if pi < p:
        idx = i
        p = pi

print(1)
print(idx+1)

n=int(input())
m=[int(i) for i in input().split()]
s=sum(m)
for i in range(len(m)):
    m[i]=[m[i],i]

if s%2!=0:
    print(0)
    exit()
a=0
b=0
m.sort(key=lambda x: x[0], reverse=True)
c=1
ans=[]
while True:
    a=0
    b=0
    for i in range(len(m)):
        if a<=b and a+m[i][0]<=s//2:
            a+=m[i][0]
        else:
            b+=m[i][0]
    if b!=a:
        break
    t=None
    mm=m[0][0]
    for i in range(len(m)):
        if m[i][0] < mm:
            j=i
            t=m[i][1]
            mm=m[i][0]
    m.pop(j)
    ans.append(t)
print(len(ans),*ans,sep='\n')

# Legends Always Come Up with Solution
# Author: Manvir Singh

import os
import sys
from io import BytesIO, IOBase

def findPartiion(a,n):
    s = sum(a)
    if s % 2:
        return 0
    part = [0] * (s // 2 + 1)
    part[0]=1
    for i in range(n):
        for j in range(s // 2, a[i] - 1, -1):
            part[j]|=part[j-a[i]]
    return part[s//2]

def main():
    n=int(input())
    a=list(map(int,input().split()))
    if sum(a)%2:
        print(0)
    elif not findPartiion(a,len(a)):
        print(0)
    else:
        o = 0
        for i in a:
            if i % 2:
                o += 1
        if o % 2:
            print(0)
        else:
            print(1)
            for i in range(n):
                if a[i] % 2:
                    print(i + 1)
                    return
            for i in range(n):
                f=1
                for j in range(n):
                    if i!=j:
                        for k in range(n):
                            if j!=k:
                                if a[i]==2*(a[j]-a[k]):
                                    f=0
                if f:
                    print(i+1)
                    return

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()

import sys
input = sys.stdin.readline
for _ in range(1):
    def canPartition(nums):
        a=sum(nums)
        n=len(nums)
        d={}
        def helper(curr,s):
            if curr==n:
                if s==a//2:
                    return True
                return False
            if (curr,s) in d:
                return d[(curr,s)]
            ans=helper(curr+1,s+nums[curr]) or helper(curr+1,s)
            d[(curr,s)]=ans
            return ans
        if a%2:
            return False
        return helper(0,0)
    n=int(input())
    arr=[int(x) for x in input().split()]
    s=sum(arr)
    if s%2:
        print(0)
        continue
    if canPartition(arr)==False:
        print(0)
        continue
    else:
        odd=-1
        temp=[]
        for i in range(n):
            if arr[i]%2:
                odd=i
            if arr[i]%2==0 and (arr[i]//2)%2:
                temp.append(i)
        if odd>=0:
            print(1)
            print(odd+1)
            continue
        if temp:
            print(1)
            print(temp[0]+1)
        else:
            d={}
            for i in range(n):
                if arr[i] in d:
                    d[arr[i]].append(i+1)
                else:
                    d[arr[i]]=[i+1]
            for i in sorted(d.keys()):
                if len(d[i])%2==0:
                    print(1)
                    print(d[i][0])
                    exit()

def lol(s,a,n,d):
    if (s,n) in d:
        return d[(s,n)]

    if s==0:
        d[(s,n)]=True
        return True
    if n==0 and s!=0:
        d[(s,n)]=False
        return False
    if a[n-1]>s:
        return lol(s,a,n-1,d)
    z=lol(s,a,n-1,d)
    y=lol(s-a[n-1],a,n-1,d)
    d[(s,n)]=z or y
    return z or y
n=int(input())
a=list(map(int,input().split()))
s=0
f=0
d={}
for i in a:
    s+=i
if s%2==1:
    print(0)
else:
    if lol(s//2,a,n,d):
        f=1
    else:
        print(0)
if f==1:
    ans=1
    for i in range(len(a)):
        if a[i]%2==1:
            print(ans)
            print(i+1)
            f=0
            break
    if f==1:
        d={}
        for i in range(len(a)):
            ele=a.pop(i)
            if not lol(s//2,a,n-1,d):
                print(ans)
                print(i+1)
                break
            else:
                a.insert(i,ele)

def inp():
    return [int(a) for a in input().split()]
def gcd(x, y):
    if y:
        return gcd(y, x % y)
    else:
        return x
ind = []
n = int(input())
a = inp()
if sum(a) % 2 == 1:
    print(0)
else:
    prev = a[0]
    for i in range(1, n):
        g = gcd(prev, a[i])
        prev = a[i]
    for i in range(n):
        a[i] /= g
    while sum(a) % 2 == 0:
        for i in range(n):
            if a[i] % 2:
                ind.append(i + 1)
                del a[i]
                n -= 1
                break
    print(len(ind))
    print(*ind)

import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

n = int(input())
lst = list(map(int,input().split()))

sumN = sum(lst)

if sumN%2:
    print(0)
else:
    ans = 0
    for idx,ele in enumerate(lst):
        if ele%2:
            ans = idx + 1
            break

    if ans:
        print(1)
        print(ans)
    elif sumN//2%2:
        print(0)
    else:
        for idx,ele in enumerate(lst):
            if ((sumN-ele)//2)%2:
                ans = idx + 1
                break
        print(1)
        print(ans)

#"{} {} {}".format(maxele,minele,minele)

# yield " ".join([str(x) for x in ans])
# 2 4 4 2

# 2*10

import math
def fun(a,n):
    d=[{} for i in range(n)]
    d[0][0]=True
    d[0][a[0]]=True

    d[-1][sum(a)//2]=False

    for i in range(n-1):
        for j in d[i]:
            d[i+1][j+a[i+1]]=True
            d[i+1][j]=True
    #print(d)
    return d[-1][sum(a)//2]

n=int(input())
a=[int(x) for x in input().split()]

if sum(a)%2==1:
    print(0)

else:
    if fun(a,n):
        print(1)
        mn=int(math.log(a[0],2))
        ans=0
        for i in range(n):
            if int(math.log(a[i],2))<mn:
                mn=int(math.log(a[i],2))
                ans=i

        print(ans)

    else:
        print(0)

def fp(arr, n) :
    Sum = 0
    for i in range(n) :
        Sum += arr[i]
    if (Sum % 2 != 0) :
        return 0
    part = [0] * ((Sum // 2) + 1)
    for i in range((Sum // 2) + 1) :
        part[i] = 0
    for i in range(n) :
        for j in range(Sum // 2, arr[i] - 1, -1) :
            if (part[j - arr[i]] == 1 or j == arr[i]) :
                part[j] = 1
    return part[Sum // 2]

n = int(input())
arr = list(map(int,input().split()))
b = arr.copy()
if fp(arr,n)==True:
    for i in range(n):
        b[i] = 0
        if fp(b,n)==True:
            b[i] = arr[i]
        else:
            print(1)
            print(i+1)
else:
    print(0)

import sys
input = sys.stdin.readline
I = lambda : list(map(int,input().split()))
S = lambda : list(map(str,input()))

n, = I()
a   = I()
sum1 = sum(a)
if sum1%2==0:
	sum1 = sum1//2
	prev = [[False,10**10] for i in range(sum1+1)]
	ans  = [[] for i in range(sum1+1)]
	prev[0] = [True,0]
	for i in range(n):
		dp = [[prev[j][k] for k in range(len(prev[j]))] for j in range(sum1+1)]
		ans1 = [[ans[j][k] for k in range(len(ans[j]))] for j in range(sum1+1)]
		for j in range(sum1+1):
			if (j-a[i])>=0:
				if prev[j-a[i]][0]:
					dp[j][0] = True
					if (prev[j-a[i]][1]+1)<dp[j][1]:
						ans1[j] = ans[j-a[i]]+[i+1]
					dp[j][1] = min(dp[j][1],prev[j-a[i]][1]+1)
		prev = [[dp[j][k] for k in range(len(dp[j]))] for j in range(sum1+1)]
		ans = [[ans1[j][k] for k in range(len(ans[j]))] for j in range(sum1+1)]
	if prev[sum1][0]:
		min1 = prev[sum1][1]
		idx = sum1
		for i in range(sum1+1):
			if prev[i][0] and ((2*sum1-i)%2!=0 or prev[((2*sum1)-i)//2][0]==False):
				if min1>prev[i][1]:
					idx = i
				min1 = min(min1,prev[i][1])
		print(len(ans[idx]))
		print(*ans[idx])
	else:
		print(0)
else:
	print(0)

import sys
input = sys.stdin.readline
import heapq
hpush = heapq.heappush
hpop = heapq.heappop
n = int(input())
a = list(map(int, input().split()))
sm = sum(a)
if sm % 2:
  print(0)
  exit(0)
dp = [0] * (sm // 2 + 1)
dp[0] = 1
odd = 0
for i in range(n):
  x = a[i]
  if x % 2: odd = i + 1
  for i in range(sm, -1, -1):
    if i + x <= sm // 2:
      dp[i + x] |= dp[i]
if dp[sm // 2] == 0:
  print(0)
  exit(0)
if odd:
  print(1)
  print(odd)
  exit(0)

h = [(-a[i], i) for i in range(n)]
heapq.heapify(h)
res = set()
while len(h):
  x, i = hpop(h)
  x = -x
  res.add(i + 1)
  sm -= x
  if dp[sm // 2] == 0: break
  dp = [0] * (sm // 2 + 1)
  dp[0] = 1
  for i in range(n):
    x = a[i]
    if i + 1 in res: continue
    for i in range(sm, -1, -1):
      if i + x <= sm // 2:
        dp[i + x] |= dp[i]
  if dp[sm // 2] == 0: break
  #print(sm, res, dp, h)
print(len(res))
res = sorted(res)
for r in res: print(r)

 ######      ###      #######    #######    ##      #     #####        ###     #####
 #     #    #   #          #        #       # #     #    #     #      #   #     ###
 #     #   #     #        #         #       #  #    #   #       #    #     #    ###
 ######   #########      #          #       #   #   #   #           #########    #
 ######   #########     #           #       #    #  #   #           #########    #
 #     #  #       #    #            #       #     # #   #    ####   #       #    #
 #     #  #       #   #             #       #      ##   #    #  #   #       #
 ######   #       #  #######     #######    #       #    #####  #   #       #    #

# mandatory imports
import os
import sys
from io import BytesIO, IOBase
from math import log2, ceil, sqrt, gcd, log

# optional imports
# from itertools import permutations
# from functools import cmp_to_key  # for adding custom comparator
# from fractions import Fraction
from collections import *
from bisect import *
# from __future__ import print_function # for PyPy2
from heapq import *
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

g   = lambda : input().strip()
gl  = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
rr = lambda x : reversed(range(x))
mod = int(1e9)+7
inf = float("inf")

n, = gil()
a = gil()
sm = sum(a)

def iszero(a, n):
    dp = [n]*((sm//2) + 1)
    dp[0] = 0
    for i in range(len(dp)):
        for j in range(dp[i], n):
            if i + a[j] < len(dp) and dp[i+a[j]] > j+1:
                dp[i+a[j]] = j+1

    # print(*dp)
    return dp[-1] == n

if sm&1 or iszero(a, n):
    print(0)
    exit()
idx = 0
p = int(log2(a[0]))

for i in range(1, n):
    pi = int(log2(a[i]))
    if pi < p:
        idx = i
        p = pi

print(1)
print(idx+1)

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    sa = sum(a)
    if sa % 2:
        return 0

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa // 2 not in t:
        return None
    return a.index(min(a)) + 1

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

from bisect import bisect,bisect_left

from collections import *
from math import gcd,ceil,sqrt,floor,inf
from heapq import *
from itertools import *
from operator import add,mul,sub,xor,truediv,floordiv
from functools import *

#------------------------------------------------------------------------
import os
import sys

from io import BytesIO, IOBase
# region fastio

BUFSIZE = 8192

input = lambda: sys.stdin.readline().rstrip("\r\n")

#------------------------------------------------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def A(n):return [0]*n
def AI(n,x): return [x]*n
def A2(n,m): return [[0]*m for i in range(n)]
def G(n): return [[] for i in range(n)]
def GP(it): return [[ch,len(list(g))] for ch,g in groupby(it)]
#------------------------------------------------------------------------

from types import GeneratorType

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to

    return wrappedfunc

mod=10**9+7
farr=[1]
ifa=[]

def fact(x,mod=0):
    if mod:
        while x>=len(farr):
            farr.append(farr[-1]*len(farr)%mod)
    else:
        while x>=len(farr):
            farr.append(farr[-1]*len(farr))
    return farr[x]

def ifact(x,mod):
    global ifa
    fact(x,mod)
    ifa.append(pow(farr[-1],mod-2,mod))
    for i in range(x,0,-1):
        ifa.append(ifa[-1]*i%mod)
    ifa.reverse()

def per(i,j,mod=0):
    if i<j: return 0
    if not mod:
        return fact(i)//fact(i-j)
    return farr[i]*ifa[i-j]%mod

def com(i,j,mod=0):
    if i<j: return 0
    if not mod:
        return per(i,j)//fact(j)
    return per(i,j,mod)*ifa[j]%mod

def catalan(n):
    return com(2*n,n)//(n+1)

def isprime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False
    return True

def floorsum(a,b,c,n):#sum((a*i+b)//c for i in range(n+1))
    if a==0:return b//c*(n+1)
    if a>=c or b>=c: return floorsum(a%c,b%c,c,n)+b//c*(n+1)+a//c*n*(n+1)//2
    m=(a*n+b)//c
    return n*m-floorsum(c,c-b-1,a,m-1)

def inverse(a,m):
    a%=m
    if a<=1: return a
    return ((1-inverse(m,a)*m)//a)%m

def lowbit(n):
    return n&-n

class BIT:
    def __init__(self,arr):
        self.arr=arr
        self.n=len(arr)-1

    def update(self,x,v):
        while x<=self.n:
            self.arr[x]+=v
            x+=x&-x

    def query(self,x):
        ans=0
        while x:
            ans+=self.arr[x]
            x&=x-1
        return ans

class ST:
    def __init__(self,arr):#n!=0
        n=len(arr)
        mx=n.bit_length()#取不到
        self.st=[[0]*mx for i in range(n)]
        for i in range(n):
            self.st[i][0]=arr[i]
        for j in range(1,mx):
            for i in range(n-(1<<j)+1):
                self.st[i][j]=max(self.st[i][j-1],self.st[i+(1<<j-1)][j-1])
    def query(self,l,r):
        if l>r:return -inf
        s=(r+1-l).bit_length()-1
        return max(self.st[l][s],self.st[r-(1<<s)+1][s])

class DSU:#容量+路径压缩
    def __init__(self,n):
        self.c=[-1]*n

    def same(self,x,y):
        return self.find(x)==self.find(y)

    def find(self,x):
        if self.c[x]<0:
            return x
        self.c[x]=self.find(self.c[x])
        return self.c[x]

    def union(self,u,v):
        u,v=self.find(u),self.find(v)
        if u==v:
            return False
        if self.c[u]>self.c[v]:
            u,v=v,u
        self.c[u]+=self.c[v]
        self.c[v]=u
        return True

    def size(self,x): return -self.c[self.find(x)]

class UFS:#秩+路径
    def __init__(self,n):
        self.parent=[i for i in range(n)]
        self.ranks=[0]*n

    def find(self,x):
        if x!=self.parent[x]:
            self.parent[x]=self.find(self.parent[x])
        return self.parent[x]

    def union(self,u,v):
        pu,pv=self.find(u),self.find(v)
        if pu==pv:
            return False
        if self.ranks[pu]>=self.ranks[pv]:
            self.parent[pv]=pu
            if self.ranks[pv]==self.ranks[pu]:
                self.ranks[pu]+=1
        else:
            self.parent[pu]=pv

def Prime(n):
    c=0
    prime=[]
    flag=[0]*(n+1)
    for i in range(2,n+1):
        if not flag[i]:
            prime.append(i)
            c+=1
        for j in range(c):
            if i*prime[j]>n: break
            flag[i*prime[j]]=prime[j]
            if i%prime[j]==0: break
    return flag

def dij(s,graph):
    d={}
    d[s]=0
    heap=[(0,s)]
    seen=set()
    while heap:
        dis,u=heappop(heap)
        if u in seen:
            continue
        seen.add(u)
        for v,w in graph[u]:
            if v not in d or d[v]>d[u]+w:
                d[v]=d[u]+w
                heappush(heap,(d[v],v))
    return d

def bell(s,g):#bellman-Ford
    dis=AI(n,inf)
    dis[s]=0
    for i in range(n-1):
        for u,v,w in edge:
            if dis[v]>dis[u]+w:
                dis[v]=dis[u]+w
    change=A(n)
    for i in range(n):
        for u,v,w in edge:
            if dis[v]>dis[u]+w:
                dis[v]=dis[u]+w
                change[v]=1
    return dis

def lcm(a,b): return a*b//gcd(a,b)
def lis(nums):
    res=[]
    for k in nums:
        i=bisect.bisect_left(res,k)
        if i==len(res):
            res.append(k)
        else:
            res[i]=k
    return len(res)

def RP(nums):#逆序对
    n = len(nums)
    s=set(nums)
    d={}
    for i,k in enumerate(sorted(s),1):
        d[k]=i
    bi=BIT([0]*(len(s)+1))
    ans=0
    for i in range(n-1,-1,-1):
        ans+=bi.query(d[nums[i]]-1)
        bi.update(d[nums[i]],1)
    return ans

class DLN:
    def __init__(self,val):
        self.val=val
        self.pre=None
        self.next=None

def nb(i,j,n,m):
    for ni,nj in [[i+1,j],[i-1,j],[i,j-1],[i,j+1]]:
        if 0<=ni<n and 0<=nj<m:
            yield ni,nj

def topo(n):
    q=deque()
    res=[]
    for i in range(1,n+1):
        if ind[i]==0:
            q.append(i)
            res.append(i)
    while q:
        u=q.popleft()
        for v in g[u]:
            ind[v]-=1
            if ind[v]==0:
                q.append(v)
                res.append(v)
    return res

@bootstrap
def gdfs(r,p):
    for ch in g[r]:
        if ch!=p:
            yield gdfs(ch,r)
    yield None

t=1
for i in range(t):
    n=N()
    a=RLL()
    s=sum(a)
    if s&1:
        print(0)
        exit()
    dp=1
    for i in range(n):
        dp|=dp<<a[i]
    if not dp>>(s//2)&1:
        print("JISHU")
        print(0)
        exit()
    print(1)
    g=G(12)
    for i,x in enumerate(a,1):
        c=0
        while not x&1:
            x//=2
            c+=1
        g[c].append(i)
    for i in range(12):
        if g[i]:
            print(g[i][0])
            exit()
    #print(ans)

import sys
import io, os
#input = sys.stdin.buffer.readline
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline

def main():
    n = int(input())
    A = list(map(int, input().split()))

    M = sum(A)
    dp = [False]*(M+1)
    dp[0] = True
    for a in A:
        for j in reversed(range(M+1)):
            if not dp[j]:
                continue
            dp[j+a] = True

    flag = False
    for i in range(M+1):
        if M-i == i:
            flag = True
            break
    if not flag:
        print(0)
        exit()
    B = []
    for i, a in enumerate(A):
        B.append((a, i))
    for a, i in B:
        if a%2 == 1:
            print(1)
            print(i+1)
            break
    else:
        B.sort(key=lambda x: x[0])
        print(1)
        print(B[0][1]+1)

if __name__ == '__main__':
    main()

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    def possible(idx):
        new_sa = sa - a[idx]
        new_half = new_sa // 2

        t = set()
        for i in range(n):
            if i == idx:
                continue
            for v in list(t):
                t.add(v + e)
            t.add(e)

            if new_half in t:
                return False
        return True

    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    for i in range(n):
        if possible(i):
            return i + 1
    return None

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

import os
import sys
from io import BytesIO, IOBase

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, 8192))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inp = lambda dtype: dtype(input().strip())
inp_d = lambda dtype: [dtype(x) for x in input().split()]
inp_2d = lambda dtype, n: [inp(dtype) for _ in range(n)]
inp_2ds = lambda dtype, n: [inp_d(dtype) for _ in range(n)]
inp_enu = lambda dtype: [(i, x) for i, x in enumerate(inp_d(dtype))]
inp_enus = lambda dtype, n: [[i, inp_d(dtype)] for i in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b

n, a = inp(int), inp_d(int)
sums, su = {0, a[0]}, sum(a)

for i in range(1, n):
    sums.update([a[i] + j for j in sums if a[i] + j <= su >> 1])

if su & 1 or su >> 1 not in sums:
    print(0)
else:
    for i in range(n):
        if a[i] & 1:
            exit(print(1, i + 1, sep='\n'))
    else:
        print(1, a.index(min(a)) + 1, sep='\n')

def find(a):
    t = sum(a)
    if t%2 == 1:
        return -1
    else:
        tar = t//2
        s = set()
        s.add(0)
        count = 0
        for i in a[:-1]:
           count += i
           t = count%tar
           if t in s and i!=0:
               return 0
           s.add(t)
        return -1
def process(a):

    num = float('inf')
    ind = 0
    for i in range(len(a)):
        count = 0
        while a[i]&1 == 0:
            a[i] = a[i] >> 1
            count+=1
        if (count < num):
            num = count
            ind = i+1
    print(1)
    print(ind)

ilg = int(input())
a = list(map(int, input().split()))
r = find(a)
if (r==-1 or len(a) <=1):
    print(0)
else:
    process(a)

n = int(input())
a = [int(_) for _ in input().split()]
c = a.copy()
for i in range(n):
    a[i] = a[i] % 2 + 2

sum = 0
for x in a:
    sum += x

if sum % 2 != 0:
    print(0)
    exit(0)

dp = [[-1 for _ in range((5 * n) + 1)] for _ in range(n + 1)]
def call(i, cursum):
    if dp[i][cursum] != -1:
        return dp[i][cursum]

    if cursum * 2 == sum:
        return True

    if i >= n:
        return False

    bad = False
    bad = bad | call(i + 1, cursum)
    bad = bad | call(i + 1, cursum + a[i])
    dp[i][cursum] = bad
    return dp[i][cursum]

if not call(0, 0):
    print(0)
    exit(0)

for i in range(n):
    if a[i] % 2 != 0:
        print(1)
        print(i + 1)
        exit(0)

id = -1
while id == -1:
    for i in range(n):
        if c[i] % 2 == 1:
            id = i
            break

        c[i] = c[i] // 2

print(1)
print(id + 1)

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    for i, e in enumerate(a):
        if e % 2:
            return i + 1
    return 1

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

import random
import collections
import string
import math
import copy
import os
import sys
from io import BytesIO, IOBase

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

def input(): return sys.stdin.readline().rstrip("\r\n")

# n = 0
# m = 0

# n = int(input())

# li = [int(i) for i in input().split()]

# s = sorted(li)
"""
from dataclasses import dataclass

@dataclass
class point:
    x: float
    y: float

@dataclass
class line:
    A: float
    B: float
    C: float

    def gety(self, x):
        return (self.A*x+self.C)/-self.B

    def getx(self, y):
        return (self.B*y+self.C)/-self.A

    def k(self):
        return -self.A/self.B

    def b(self):
        return -self.C/self.B

    def dist(self, p: point):
        return abs((self.A*p.x+self.B*p.y+self.C)/(self.A**2+self.B**2)**0.5)

def calc_line(u: point, v: point):
    return line(A=u.y-v.y, B=v.x-u.x, C=u.y*(u.x-v.x)-u.x*(u.y-v.y))

def is_parallel(u: line, v: line) -> bool:
    f1 = False
    f2 = False
    try:
        k1 = u.k()
    except:
        f1 = True
    try:
        k2 = v.k()
    except:
        f2 = True
    if f1 != f2:
        return False
    return f1 or k1 == k2

def seg_len(_from: point, _to: point):
    return ((_from.x - _to.x)**2 + (_from.y - _to.y)**2) ** 0.5

def in_range(_from: point, _to: point, _point: point) -> bool:
    if _from.x < _to.x:
        if _from.y < _to.y:
            return _from.x <= _point.x <= _to.x and _from.y <= _point.y <= _to.y
        else:
            return _from.x <= _point.x <= _to.x and _from.y >= _point.y >= _to.y
    else:
        if _from.y < _to.y:
            return _from.x >= _point.x >= _to.x and _from.y <= _point.y <= _to.y
        else:
            return _from.x >= _point.x >= _to.x and _from.y >= _point.y >= _to.y

def intersect(u: line, v: line) -> point:
    tx = (u.B*v.C-v.B*u.C)/(v.B*u.A-u.B*v.A)
    if u.B!=0.0:
        ty = -u.A*tx/u.B - u.C/u.B
    else:
        ty = -v.A*tx/v.B - v.C/v.B
    return point(x=tx, y=ty)

def in_direction(_from: point, _to: point, _point: point) -> bool:
    if _from.x < _to.x:
        if _from.y < _to.y:
            return _to.x < _point.x  and _to.y < _point.y
        else:
            return _to.x < _point.x  and _point.y <= _to.y
    else:
        if _from.y < _to.y:
            return _to.x >= _point.x  and _to.y < _point.y
        else:
            return _to.x >= _point.x  and _point.y <= _to.y

"""
# mo = int(1e9+7)
mo = 998244353

def exgcd(a, b):
    if not b:
        return 1, 0
    y, x = exgcd(b, a % b)
    y -= a//b * x
    return x, y

def getinv(a, m):
    x, y = exgcd(a, m)
    return -1 if x == 1 else x % m

def comb(n, b):
    res = 1
    b = min(b, n-b)
    for i in range(b):
        res = res*(n-i)*getinv(i+1, mo) % mo
        # res %= mo
    return res % mo

def quickpower(a, n):
    res = 1
    while n:
        if n & 1:
            res = res * a % mo
        n >>= 1
        a = a*a % mo
    return res

def dis(a, b):
    return abs(a[0]-b[0]) + abs(a[1]-b[1])

def getpref(x):
    if x > 1:
        return (x)*(x-1) >> 1
    else:
        return 0

def orafli(upp):
    primes = []
    marked = [False for i in range(upp+3)]
    prvs = [i for i in range(upp+3)]
    for i in range(2, upp):
        if not marked[i]:
            primes.append(i)
        for j in primes:
            if i*j >= upp:
                break
            marked[i*j] = True
            prvs[i*j] = j
            if i % j == 0:
                break
    return primes, prvs

def lower_ord(c: str) -> int:
    return ord(c)-97

def upper_ord(c: str) -> int:
    return ord(c) - 65

def read_list():
    return [int(i) for i in input().split()]

def read_int():
    s = input().split()
    if len(s) == 1:
        return int(s[0])
    else:
        return map(int, s)

def ask(s):
    print(f"? {s}", flush=True)

def answer(s):
    print(f"{s}", flush=True)

import functools

# primes, prvs = orafli(100010)

def solve():
    n = read_int()

    bl = [1]
    for i in range(11):
        bl.append(bl[-1]<<1)

    l = read_list()
    if sum(l)&1:
        print(0)
        return

    blm = [0 for i in range(12)]
    for i in l:
        tl = []
        for p,j in enumerate(bl):
            blm[p]+=1 if j&i else 0
    sel = -1
    for k, v in enumerate(blm):
        if v&1:
            print(0)
            return
        if v and sel == -1:
            sel = k
    vv = 1<<sel
    for p, i in enumerate(l):
        if i&vv:
            print(1)
            print(p+1)
            return
    # print(blm)

    # d = {0}
    # dd = set(l)
    # flg = True
    # for i in d:
    #     for k in l:
    #         if k==i:
    #             if flg:
    #                 flg = True
    #                 continue

    #         cd = set()
    #         for j in d:
    #             cd.add(i+j)
    #         print(f"lencd{len(cd)}, lend{len(d)}")
    #         print(cd,d)
    #         # print()
    #         if len(cd)!=len(d) or len(cd.intersection(d)):
    #             print('WA!')
    #             break
    #         d = d.union(cd)

# fi = open('C:\\cppHeaders\\CF2020.12.17\\test.data', 'r')
# def input(): return fi.readline().rstrip("\r\n")
# primes, prv = orafli(10001)
# solve()
# t = int(input())

t = 1

for ti in range(t):
    # try:
    # print(f"Case #{ti+1}: ", end='')
    solve()
    # except:
        # traceback.print_exc()

# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

import os
import sys
from io import BytesIO, IOBase
import math
from heapq import heappop, heappush, heapify, heapreplace
from collections import defaultdict, deque
from bisect import bisect_left, bisect_right
#from functools import lru_cache
import re
mod = 1000000007
mod1 = 998244353

def read():
    sys.stdin  = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')

# ------------------------------------------- Algos --------------------------------------------------------
def primeFactors(n):
    arr = []
    while n % 2 == 0:
        arr.append(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            arr.append(i)
            n = n // i
    if n > 2:
        arr.append(n)
    return arr
def primeFactorsSet(n):
    s = set()
    while n % 2 == 0:
        s.add(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            s.add(i)
            n = n // i
    if n > 2:
        s.add(n)
    return s
def sieve(n):
    res=[0 for i in range(n+1)]
    #prime=set([])
    prime=[]
    for i in range(2,n+1):
        if not res[i]:
            #prime.add(i)
            prime.append(i)
            for j in range(1,n//i+1):
                res[i*j]=1
    return prime
def isPrime(n) : # Check Prime Number or not
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True
def countPrimesLessThanN(n):
    seen, ans = [0] * n, 0
    for num in range(2, n):
        if seen[num]: continue
        ans += 1
        seen[num*num:n:num] = [1] * ((n - 1) // num - num + 1)
    return ans
def gcd(x, y):
    return math.gcd(x, y)
def lcm(a,b):
    return (a // gcd(a,b))* b
def isBitSet(n,k):
    # returns the count of numbers up to N having K-th bit set.
    res = (n >> (k + 1)) << k
    if ((n >> k) & 1):
        res += n & ((1 << k) - 1)
    return res
def modular_exponentiation(x, y, p):    #returns (x^y)%p
    res = 1
    x = x % p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) :
            res = (res * x) % p
        y = y >> 1
        x = (x * x) % p
    return res
def nCr(n, r, p):    # returns nCr % p
    num = den = 1
    for i in range(r):
        num = (num * (n - i)) % p
        den = (den * (i + 1)) % p
    return (num * pow(den,
            p - 2, p)) % p
def smallestDivisor(n):
    if (n % 2 == 0):
        return 2
    i = 3
    while(i * i <= n):
        if (n % i == 0):
            return i
        i += 2
    return n

class DisjointSetUnion:
    def __init__(self, n):
        self.parent = list(range(n))
        self.size = [1] * n
        self.num_sets = n

    def find(self, a):
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a

    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a == b:
            return False
        if self.size[a] < self.size[b]:
            a, b = b, a
        self.num_sets -= 1
        self.parent[b] = a
        self.size[a] += self.size[b]
        return True

    def set_size(self, a):
        return self.size[self.find(a)]

    def __len__(self):
        return self.num_sets

# -------------------------------------------------- code -------------------------------------------------
def subsetSum(elements, target):
    dp = [False]*(target+1)
    dp[0] = True
    for ele in elements:
        for j in range(target, ele - 1, -1):
            if dp[j - ele]:
                dp[j] = True
    return dp[target]

def main():
    n = int(input())
    arr = list(map(int, input().split()))
    s = sum(arr)
    if s%2 == 1:
        print(0)
        return

    if subsetSum(arr, s//2):
        g = 0
        odd = -1
        for i in range(n):
            if arr[i]%2 == 1:
                odd = i+1
                break
            else:
                g = gcd(g, arr[i])
        if odd != -1:
            print(1)
            print(odd)
        else:
            for i in range(n):
                arr[i] = arr[i]//g

            de = deque(arr)
            a = -1
            for i in range(n):
                x = de.popleft()

                if not subsetSum(de, (s-x)//2):
                    a = i+1
                    break

                else:
                    de.append(x)
            print(1)
            print(a)

    else:
        print(0)

# ---------------------------------------------- region fastio ---------------------------------------------
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

# -------------------------------------------------- end region ---------------------------------------------

if __name__ == "__main__":
    #read()
    main()

import sys
input = sys.stdin.readline
for _ in range(1):
    def canPartition(nums):
        a=sum(nums)
        n=len(nums)
        d={}
        def helper(curr,s):
            if curr==n:
                if s==a//2:
                    return True
                return False
            if (curr,s) in d:
                return d[(curr,s)]
            ans=helper(curr+1,s+nums[curr]) or helper(curr+1,s)
            d[(curr,s)]=ans
            return ans
        if a%2:
            return False
        return helper(0,0)
    n=int(input())
    arr=[int(x) for x in input().split()]
    s=sum(arr)
    if s%2:
        print(0)
        continue
    if canPartition(arr)==False:
        print(0)
        continue
    else:
        odd=-1
        temp=[]
        for i in range(n):
            if arr[i]%2:
                odd=i
            if arr[i]%2==0 and (arr[i]//2)%2:
                temp.append(i)
        if odd>=0:
            print(1)
            print(odd+1)
            continue
        if temp:
            print(1)
            print(temp[0]+1)
        else:
            d={}
            for i in range(n):
                if arr[i] in d:
                    d[arr[i]].append(i+1)
                else:
                    d[arr[i]]=[i+1]
            #print(d)
            for i in sorted(d.keys()):
                if canPartition(arr[:d[i][0]]+arr[d[i][0]+1:])==False:
                    print(1)
                    print(d[i][0])
                    #print(1)
                    #print(d[i][0])
                    exit()

def inp():
    return [int(a) for a in input().split()]
def gcd(x, y):
    if y:
        return gcd(y, x % y)
    else:
        return x
ind = []
n = int(input())
a = inp()
if sum(a) % 2 == 1:
    print(0)
else:
    prev = a[0]
    for i in range(1, n):
        g = gcd(prev, a[i])
        prev = a[i]
    for i in range(n):
        a[i] /= g
    while sum(a) % 2 == 0:
        for i in range(n):
            if a[i] % 2:
                ind.append(i + 1)
                del a[i]
                n -= 1
                break
    print(len(ind))
    print(*ind)

# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase

def knapsack(n,wt,w,dp):

    for i in range(n+1):
        dp[i][0]=1

    for r in range(1,n+1):
        for c in range(1,w+1):
            if wt[r-1]<=w:
                dp[r][c]=dp[r-1][c] or dp[r-1][c-wt[r-1]]
            else:
                dp[r][c]=dp[r-1][c]

    return dp[n][w]

def main():
    n=int(input())
    a=list(map(int,input().split()))
    s=sum(a)
    if s%2==0:

        dp=[[0 for _ in range(s//2+1)]for _ in range(n+1)]

        if knapsack(n,a,s//2,dp):

            for i,item in enumerate(a):
                if item%2:
                    print(1)
                    print(i+1)
                    break
                elif ((s-item)//2)%2:
                    print(1)
                    print(i+1)
                    break
            else:
                print(2)
                print(n-1,n)
        else:
            print(0)
    else:
        print(0)

# 6
# 2 4 6 8 10 10

#----------------------------------------------------------------------------------------
def nouse0():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse1():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse2():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

def nouse3():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse4():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')
def nouse5():
    # This is to save my code from plag due to use of FAST IO template in it.
    a=420
    b=420
    print(f'i am nitish{(a+b)//2}')

# endregion

if __name__ == '__main__':
    main()

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    def possible(idx):
        new_sa = sa - a[idx]
        new_half = new_sa // 2

        t = set()
        for i, e in enumerate(a):
            if i == idx:
                continue
            for v in list(t):
                t.add(v + e)
            t.add(e)

            if new_half in t:
                return False
        return True

    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    for i in range(n):
        if possible(i):
            return i + 1
    return None

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

#Don't stalk me, don't stop me, from making submissions at high speed. If you don't trust me,
import sys
#then trust me, don't waste your time not trusting me. I don't plagiarise, don't fantasize,
import os
#just let my hard work synthesize my rating. Don't be sad, just try again, everyone fails
from io import BytesIO, IOBase
BUFSIZE = 8192
#every now and then. Just keep coding, just keep working and you'll keep progressing at speed-
# -forcing.
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
#code by _Frust(CF)/Frust(AtCoder)
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from os import path
if(path.exists('input.txt')):
    sys.stdin = open("input.txt","r")
    sys.stdout = open("output.txt","w")
    input = lambda: sys.stdin.readline().rstrip("\r\n")
import math
import heapq as hq

def checker(dp, nums):
    for i in range(n):
        for j in range(r, -1, -1):
            if dp[j]==1 and j+l1[i]<=r:
                dp[j+l1[i]]=1

            if dp[r]==True:
                return True
    return False

n=int(input())
l1=[int(i) for i in input().split()]

s=sum(l1)
if s&1:
    print(0)
else:
    r=s//2
    dp=[0 for i in range(r + 1)]
    dp[0]=1

    if not checker(dp, l1):
        print(0)
    else:
        print(1)
        k=min(l1)
        for i in range(n):
            if l1[i]==k:
                print(i+1)

n = int(input())
a = list(map(int,input().split()))
odd = 0
for i in a:
    if (i%2==1):
        odd+=1
if (odd%2==1):
    print(0)
else:
    if (odd>0):
        print(1)
        for i in range(n):
            if (a[i]%2==1):
                print(i+1)
                break
    else:
        print(1)
        mini = 10**9
        x = 0
        for i in range(n):
            ans=0
            while(a[i]%2==0):
                a[i] = a[i]//2
                ans+=1
            if (mini>ans):
                x = i+1
        print(x)

import sys
import math
input = sys.stdin.readline

############ ---- Input Functions ---- ############
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s.rstrip()))
def invr():
    return(map(int,input().split()))
n=inp()
def solution(L):
	S=sum(L)
	if S==0:
		print(n-1)
		print(' '.join([str(i) for i in range(1, n)]))
		return 0
	if S%2!=0:
		print(0)
		return 0
	else:
		for i in range(len(L)):
			l=L[i]
			if l%2==1:
				print(1)
				print(i+1)
				return 0
	solution([l//2 for l in L])

L=inlt()
solution(L)

import sys,math,bisect

inf = float('inf')
mod = (10**9)+7

"=========================="
def lcm(a,b):
    return int((a/math.gcd(a,b))*b)
def gcd(a,b):
    return int(math.gcd(a,b))
def tobinary(n):
    return bin(n)[2:]
def binarySearch(a,x):
    i = bisect.bisect_left(a,x)
    if i!=len(a) and a[i]==x:
        return i
    else:
        return -1
def lowerBound(a, x):
    i = bisect.bisect_left(a, x)
    if i:
        return (i-1)
    else:
        return -1
def upperBound(a,x):
    i = bisect.bisect_right(a,x)
    if i!= len(a)+1 and a[i-1]==x:
        return (i-1)
    else:
        return -1
def primesInRange(n):
    ans = []
    prime = [True for i in range(n+1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n+1, p):
                prime[i] = False
        p += 1
    for p in range(2, n+1):
        if prime[p]:
            ans.append(p)
    return ans
def primeFactors(n):
    factors = []
    while n % 2 == 0:
        factors.append(2)
        n = n // 2
    for i in range(3,int(math.sqrt(n))+1,2):
        while n % i== 0:
            factors.append(i)
            n = n // i
    if n > 2:
        factors.append(n)
    return factors
"============================"
"""
n = int(input())
n,k = map(int,input().split())
arr = list(map(int,input().split()))
"""
from collections import deque,defaultdict,Counter
import heapq

for _ in range(1):
    n=int(input())
    arr=list(map(int,input().split()))
    flag=True
    if sum(arr)%2==1:
        print(0)
    elif sum(arr)%2==0 and n%2==1:
        print(0)
    else:
        flag=True
        for i in range(n):
            if arr[i]%2==1:
                print(1)
                print(i+1)
                flag=False
                break
        while flag:
            for i in range(n):
                arr[i]=arr[i]/2
                if arr[i]%2==1:
                    print(1)
                    print(i+1)
                    flag=False
                    break

import time

#start_time = time.time()
#def TIME_(): print(time.time()-start_time)

import os, sys
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import bisect_left, bisect_right
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string, heapq as h
BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        import os
        self.os = os
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            self.os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def getInt(): return int(input())
def getStrs(): return input().split()
def getInts(): return list(map(int,input().split()))
def getStr(): return input()
def listStr(): return list(input())
def getMat(n): return [getInts() for _ in range(n)]
def getBin(): return list(map(int,list(input())))
def isInt(s): return '0' <= s[0] <= '9'
def ceil_(a,b): return a//b + (a%b > 0)

MOD = 10**9 + 7

"""
If the sum of elements is odd, return

Subset sums of 14 with min element 2

Must not be able to have subset sums 13

Remove the number which is the smallest power of 2
"""

from copy import deepcopy

def solve():
    N = getInt()
    A = getInts()
    S = sum(A)
    if S % 2:
        print(0)
        return
    sums = set([0])
    for a in A:
        new_sums = deepcopy(sums)
        for s in sums:
            new_sums.add(a+s)
        sums = deepcopy(new_sums)
    if s//2 not in sums:
        print(0)
        return
    two_min = 65
    two_min_idx = -1
    for i,a in enumerate(A):
        num = 0
        x = a
        while x % 2 == 0:
            x //= 2
            num += 1
        if num < two_min:
            two_min = num
            two_min_idx = i
    print(1)
    print(two_min_idx+1)
    return

#for _ in range(getInt()):
#print(solve())
solve()

#TIME_()

n = int(input())
a = list(map(int, input().split()))
s = sum(a)
if s % 2 == 1:
    print(0)
    exit()
dp = [[False] * (s // 2+1) for _ in range(n + 1)]
dp[0][0] = True
for i in range(n):
    for j in range(s // 2+1):
        if j < a[i]:
            dp[i + 1][j] = dp[i][j]
        else:
            dp[i + 1][j] |= dp[i][j - a[i]]
if not dp[-1][-1]:
    print(0)
else:
    l = []
    for i in a:
        cnt = 0
        while i % 2 == 0:
            i //= 2
            cnt += 1
        l.append(cnt)
    print(1)
    print(l.index(min(l))+1)

import math
import sys
input = sys.stdin.readline
def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    s = input().strip()
    return(list(s[:len(s)]))
def invr():
    return(map(int,input().split()))

def part(l,s):
    if s%2!=0:
        return 0
    s=s//2
    dp=[0 for _ in range(s+1)]
    dp[0]=1
    for i in range(1,n):
        for j in range(s,-1,-1):
            if j-l[i-1]>=0:
                dp[j]= dp[j - l[i-1]]  or dp[j]
    return dp[s]
n=inp()
l=inlt()
s=sum(l)
if part(l,s):
    if s%2:
        print(0)
    else:
        indx=-1
        for i in range(n):
            if l[i]%2==1:
                indx=i
                break
        if indx!=-1:
            print(1)
            print(indx+1)
        else:
            vals=[]
            cnt=0
            while(part(l,s)):
                z=[each & -each for each in l]
                cnt+=1
                temp=l[z.index(min(z))]
                s-=temp
                vals.append(temp)
                l.remove(temp)
            print(cnt)
            for each in vals:
                print(each)
else:
    print(0)

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    a = list(map(int,input().split()))
    vis = [False]*(2000*100)+[False]
    vis[0]=True
    for i in range(n):
        for j in range(len(vis)-a[i]-1,-1,-1):
            if not vis[j]:continue
            vis[a[i]+j]=True
    sm = sum(a)
    if (not vis[sm//2] or sm%2!=0):
        print(0)
        return
    idx= -1

    log  =32
    div= float('inf')
    for pw in range(log,-1,-1):
        for i in range(n):
            if a[i]//(2**pw)>0:
                div = min(div,a[i]//(2**pw))

    for i in range(n):
        if a[i]%2:
            idx=i
            break
        a[i]/=(2**div)
        if a[i]%2:
            idx =i
    print(1)
    print(idx+1)
    return

t= 1#int(input())
for _ in range(t):
    solve()

"""

Author : Preet Modh

"""
import sys,os
from difflib import SequenceMatcher
from collections import Counter
from bisect import bisect_left as bl,bisect_right as br
from io import BytesIO, IOBase
from itertools import accumulate
import math

"""

**All function calls:**

LCSubstr(a,b):              for Longest Common Substring
gcd(x, y):                  greatest common divisor of x and y
prime_factors(n):           Number of prime factor of n
distinct_factors(n):        list of distinct factors of n
all_factors(n):             list of all factors of n
is_prime(n):                checks if n is prime
prime_list(n):              all primes less than number of
modinv(a, m):               modular inverse of a w.r.t. to m, works when a and m are coprime
make_nCr_mod()(n,r)         value of ncr%mod
binarySearch(arr, l, r, x): binary search
PrefixSum(arr):             prefix sum array
memodict(f):                Memoization decorator for a function taking a single argument
memoize(f):                 Memoization decorator for a function taking one or more arguments

"""

# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

def memodict(f):
    """ Memoization decorator for a function taking a single argument. """
    class memodict(dict):
        def __missing__(self, key):
            ret = self[key] = f(key)
            return ret

    return memodict().__getitem__

def memoize(f):
    """ Memoization decorator for a function taking one or more arguments. """
    class memodict(dict):
        def __getitem__(self, *key):
            return dict.__getitem__(self, key)

        def __missing__(self, key):
            ret = self[key] = f(*key)
            return ret

    return memodict().__getitem__

LCSubstr = lambda a, b:SequenceMatcher(None, a, b).find_longest_match(0, len(a), 0, len(b))
""" THIS IS FOR  for Longest Common Substring """

def gcd(x, y):
    """greatest common divisor of x and y"""
    while y:
        x, y = y, x % y
    return x

def pollard_rho(n):
    """returns a random factor of n"""
    if n & 1 == 0:
        return 2
    if n % 3 == 0:
        return 3

    s = ((n - 1) & (1 - n)).bit_length() - 1
    d = n >> s
    for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
        p = pow(a, d, n)
        if p == 1 or p == n - 1 or a % n == 0:
            continue
        for _ in range(s):
            prev = p
            p = (p * p) % n
            if p == 1:
                return gcd(prev - 1, n)
            if p == n - 1:
                break
        else:
            for i in range(2, n):
                x, y = i, (i * i + 1) % n
                f = gcd(abs(x - y), n)
                while f == 1:
                    x, y = (x * x + 1) % n, (y * y + 1) % n
                    y = (y * y + 1) % n
                    f = gcd(abs(x - y), n)
                if f != n:
                    return f
    return n

@memodict
def prime_factors(n):
    """returns a Counter of the prime factorization of n"""
    if n <= 1:
        return Counter()
    f = pollard_rho(n)
    return Counter([n]) if f == n else prime_factors(f) + prime_factors(n // f)

def distinct_factors(n):
    """returns a list of all distinct factors of n"""
    factors = [1]
    for p, exp in prime_factors(n).items():
        factors += [p**i * factor for factor in factors for i in range(1, exp + 1)]
    return factors

def all_factors(n):
    """returns a sorted list of all distinct factors of n"""
    small, large = [], []
    for i in range(1, int(n**0.5) + 1, 2 if n & 1 else 1):
        if not n % i:
            small.append(i)
            large.append(n // i)
    if small[-1] == large[-1]:
        large.pop()
    large.reverse()
    small.extend(large)
    return small

def is_prime(n):
    """returns True if n is prime else False"""
    if n < 5 or n & 1 == 0 or n % 3 == 0:
        return 2 <= n <= 3
    s = ((n - 1) & (1 - n)).bit_length() - 1
    d = n >> s
    for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
        p = pow(a, d, n)
        if p == 1 or p == n - 1 or a % n == 0:
            continue
        for _ in range(s):
            p = (p * p) % n
            if p == n - 1:
                break
        else:
            return False
    return True

def prime_sieve(n):
    """returns a sieve of primes >= 5 and < n"""
    flag = n % 6 == 2
    sieve = bytearray((n // 3 + flag >> 3) + 1)
    for i in range(1, int(n**0.5) // 3 + 1):
        if not (sieve[i >> 3] >> (i & 7)) & 1:
            k = (3 * i + 1) | 1
            for j in range(k * k // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
            for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
                sieve[j >> 3] |= 1 << (j & 7)
    return sieve

def prime_list(n):
    """returns a list of primes <= n"""
    res = []
    if n > 1:
        res.append(2)
    if n > 2:
        res.append(3)
    if n > 4:
        sieve = prime_sieve(n + 1)
        res.extend(3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not (sieve[i >> 3] >> (i & 7)) & 1)
    return res

def extended_gcd(a, b):
    """returns gcd(a, b), s, r s.t. a * s + b * r == gcd(a, b)"""
    s, old_s = 0, 1
    r, old_r = b, a
    while r:
        q = old_r // r
        old_r, r = r, old_r - q * r
        old_s, s = s, old_s - q * s
    return old_r, old_s, (old_r - old_s * a) // b if b else 0

def modinv(a, m):
    """returns the modular inverse of a w.r.t. to m, works when a and m are coprime"""
    g, x, _ = extended_gcd(a % m, m)
    return x % m if g == 1 else None

def make_nCr_mod(max_n=2 * 10**5, mod=10**9 + 7):
    max_n = min(max_n, mod - 1)

    fact, inv_fact = [0] * (max_n + 1), [0] * (max_n + 1)
    fact[0] = 1
    for i in range(max_n):
        fact[i + 1] = fact[i] * (i + 1) % mod

    inv_fact[-1] = pow(fact[-1], mod - 2, mod)
    for i in reversed(range(max_n)):
        inv_fact[i] = inv_fact[i + 1] * (i + 1) % mod

    def nCr_mod(n, r):
        res = 1
        while n or r:
            a, b = n % mod, r % mod
            if a < b:
                return 0
            res = res * fact[a] % mod * inv_fact[b] % mod * inv_fact[a - b] % mod
            n //= mod
            r //= mod
        return res

    return nCr_mod
    """
    To use:
    x=make_nCr_mod()
    print(x(n,r))
    """

def binarySearch(arr, l, r, x):

    while l <= r:
        mid = l + (r - l) // 2
        if arr[mid] == x:
            return mid

        elif arr[mid] < x:
            l = mid + 1

            r = mid - 1

    return -1

def PrefixSum(arr):
      return list(accumulate(arr))

class inputs:
    #To handle different inputs
    def single(self):
        return int(input())
    def mul(self):
        return map(int,input().split())
    def list(self):
        return  list(map(int,input().split()))

inp=inputs()
########################################################

def isSubsetSum(set, n, sum):

    # The value of subset[i][j] will be
    # true if there is a
    # subset of set[0..j-1] with sum equal to i
    subset =([[False for i in range(sum + 1)]
            for i in range(n + 1)])

    # If sum is 0, then answer is true
    for i in range(n + 1):
        subset[i][0] = True

    # If sum is not 0 and set is empty,
    # then answer is false
    for i in range(1, sum + 1):
         subset[0][i]= False

    # Fill the subset table in botton up manner
    for i in range(1, n + 1):
        for j in range(1, sum + 1):
            if j<set[i-1]:
                subset[i][j] = subset[i-1][j]
            if j>= set[i-1]:
                subset[i][j] = (subset[i-1][j] or
                                subset[i - 1][j-set[i-1]])

    # uncomment this code to print table
    # for i in range(n + 1):
    # for j in range(sum + 1):
    # print (subset[i][j], end =" ")
    # print()
    return subset[n][sum]

def main():
    n=inp.single()
    a=inp.list()
    s=sum(a)
    if sum(a)%2==1:
        print("0")
        return
    else:
        for i in range(len(a)):
            if a[i]%2!=0:
                print(1)
                print(i+1)
                return

        if (not isSubsetSum(a,len(a),s//2)):
            print(0)
            return

        while(True):
            for i in range(len(a)):
                a[i]=a[i]//2
                if(a[i]%2==1):
                    print(1)
                    print(i+1)
                    return

if __name__ == "__main__":
    main()

def exists(n,L):
    s=sum(L)

    dp=[(1+s//2)*[0] for i in range(n)]

    for x in range(s//2 +1):
        dp[0][x]=True
    for i in range(n-1):
        for x in range(s//2+1):
           if x>=L[i+1]:
               dp[i+1][x]=dp[i][x-L[i+1]] or dp[i][x]
           else:
                dp[i+1][x]=dp[i][x]
    l=False
    for i in range(n):
        l=l or dp[i][s//2]
    return l

def mini(n,L):
    s=sum(L)
    if s%2==1:
        return (0)
    if not exists(n,L):
        return(0)
    while True:
        for i in range(n):
            if L[i]%2==1:
                return(1,i+1)
            else:
                L[i]=L[i]//2

n=int(input())

L=[int(x) for x in input().split()]

x=mini(n,L)
if x==0:
    print(0)
else:
    print(x[0])
    print(x[1])

def canPartition(nums):
    target, n = sum(nums), len(nums)
    if target & 1:
        return False
    target >>= 1
    dp = [True] + [False]*target
    for x in nums:
        dp = [dp[s] or (s >= x and dp[s-x]) for s in range(target+1)]
        if dp[target]:
            return True
    return False

n = int(input())
arr = [int(x) for x in input().split()]
res = []

while canPartition(arr):
    tmp = []
    tarr = arr
    print(tarr)
    for i in range(n):
        t = arr[:i] + arr[i+1:]
        if not canPartition(t):
            tmp.append(i)

    arr = arr[:min(tmp)] + arr[min(tmp)+1:]
    res.append(min(tmp))

if len(res) > 0:
    print(len(res))
    print(" ".join(str(x+1) for x in res))
else:
    print('0')

import os,sys,math
from io import BytesIO, IOBase
from collections import defaultdict,deque,OrderedDict
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(input()))
def In():return(map(int,input().split()))
def ln():return list(map(int,input().split()))
def Sn():return input().strip()
BUFSIZE = 8192
#complete the main function with number of test cases to complete greater than x
def find_gt(a, x):
    i = bi.bisect_left(a, x)
    if i != len(a):
        return i
    else:
        return len(a)
def CountTrailingZeros(n):

    bit = bin(n)[2:]
    bit = bit[::-1]
    zero = 0;
    for i in range(len(bit)):
        if (bit[i] == '0'):
            zero += 1
        else:
            break

    return zero
def solve():
    Max=2000*100
    dp=[True]*(Max+1)
    n=I()
    l=list(In())
    total=0
    for x in l:
        total+=x
        for j in range(len(dp)-x-1,-1,-1):
            if not dp[j]:continue
            dp[j+x]=True

    if (not dp[total//2]) or (total%2!=0):
        print(0)
        return
    trail=31
    for x in l:
        trail=min(trail,CountTrailingZeros(x))
    ans=-2
    for i in range(n):
        if l[i]%(1<<trail+1)!=0:
            ans=i
    print(1)
    print(ans+1)

    pass

def main():
    T=1
    for i in range(T):
        solve()

M = 998244353
P = 1000000007

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()

if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

if __name__ == '__main__':
    main()

import sys

input = sys.stdin.readline

def solve():
    n = int(input())
    a = list(map(int,input().split()))
    vis = [False]*(2000*100)+[False]
    vis[0]=True
    for i in range(n):
        for j in range(len(vis)-a[i]-1,-1,-1):
            if not vis[j]:continue
            vis[a[i]+j]=True
    sm = sum(a)
    if (not vis[sm//2] or sm%2!=0):
        print(0)
        return
    idx= -1

    log  =32
    div= float('inf')
    for pw in range(log,-1,-1):
        for i in range(n):
            if a[i]//(2**pw)>0:
                div = min(div,a[i]//(2**pw))

    for i in range(n):
        a[i]/=(2**div)
        if a[i]%2!=0:
            idx =i
            break
    print(1)
    print(idx+1)
    return

t= 1#int(input())
for _ in range(t):
    solve()

import sys
input = sys.stdin.readline
for _ in range(1):
    def canPartition(nums):
        a=sum(nums)
        n=len(nums)
        d={}
        def helper(curr,s):
            if curr==n:
                if s==a//2:
                    return True
                return False
            if (curr,s) in d:
                return d[(curr,s)]
            ans=helper(curr+1,s+nums[curr]) or helper(curr+1,s)
            d[(curr,s)]=ans
            return ans
        if a%2:
            return False
        return helper(0,0)
    n=int(input())
    arr=[int(x) for x in input().split()]
    s=sum(arr)
    if s%2:
        print(0)
        continue
    if canPartition(arr)==False:
        print(0)
        continue
    else:
        odd=-1
        temp=[]
        for i in range(n):
            if arr[i]%2:
                odd=i
            if arr[i]%2==0 and (arr[i]//2)%2:
                temp.append(i)
        if odd>=0:
            print(1)
            print(odd)
            continue
        if temp:
            print(1)
            print(i+1)
        else:
            print(1)
            print(arr.index(min(arr))+1)

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    def possible(idx):
        new_sa = sa - a[idx]
        new_half = new_sa // 2

        t = set()
        for i, e in enumerate(a):
            if i == idx:
                continue
            for v in list(t):
                t.add(v + e)
            t.add(e)

            if new_half in t:
                return False
        return True

    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    for i in range(n):
        if possible(i):
            return i + 1
    return None

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)

def isSubsetSum(arr, n, sum):
    if sum == 0:
        return True
    if n == 0 and sum != 0:
        return False

    if arr[n - 1] > sum:
        return isSubsetSum(arr, n - 1, sum)

    return isSubsetSum(arr, n - 1, sum) or isSubsetSum(arr, n - 1, sum - arr[n - 1])

def findPartion(arr, n):
    sum = 0
    for i in range(0, n):
        sum += arr[i]
    if sum % 2 != 0:
        return False

    return isSubsetSum(arr, n, sum // 2)

arr = [6, 3, 9, 12]
n = len(arr)

# Function call
if findPartion(arr, n):
    b = [x & -x for x in arr]
    i = b.index(min(b))
    print(f"1\n{i + 1}")
else:
    print(0)

# 2022-09-04 12:35:14.236880
# https://codeforces.com/problemset/problem/1516/C
import sys
from collections import Counter

_DEBUG = True
if not _DEBUG:
    input = sys.stdin.readline
    # print = sys.stdout.write

def proc(n, a):
    sa = sum(a)

    t = set()
    for e in a:
        for v in list(t):
            t.add(v + e)
        t.add(e)

    if sa % 2 == 1 or (sa // 2) not in t:
        return None

    for i, e in enumerate(a):
        if e % 2:
            return i + 1
    return 1

n = int(input())
a = list(map(int, input().split()))
ans = proc(n, a)
if not ans:
    print(0)
else:
    print(1)
    print(ans)