Problem:
 Score : 100 points    Problem Statement We have five variables x_1, x_2, x_3, x_4, and x_5 .  The variable x_i was initially assigned a value of i .  Snuke chose one of these variables and assigned it 0 .  You are given the values of the five variables after this assignment.  Find out which variable Snuke assigned 0 .      Constraints  The values of x_1, x_2, x_3, x_4, and x_5 given as input are a possible outcome of the assignment by Snuke.         Input Input is given from Standard Input in the following format:  x_1  x_2  x_3  x_4  x_5       Output If the variable Snuke assigned 0 was x_i , print the integer i .        Sample Input 1 0 2 3 4 5      Sample Output 1 1  In this case, Snuke assigned 0 to x_1 , so we should print 1 .       Sample Input 2 1 2 0 4 5      Sample Output 2 3

Solution (Python):
from math import sin, cos, tan, asin, acos, atan, sqrt, floor, ceil, pi, log10, log, gcd
from itertools import accumulate, permutations, combinations
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
import pprint
from copy import deepcopy
from decimal import Decimal
import heapq
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
print = pprint.pprint


class Data():
        def __init__(self):
                self.power = 1
                self.rev = 1


class Combi():
        def __init__(self, N, mod):
                self.lists = [Data() for _ in range(N+1)]
                self.mod = mod
                for i in range(2, N+1):
                        self.lists[i].power = ((self.lists[i-1].power)*i) % self.mod
                self.lists[N].rev = pow(self.lists[N].power, self.mod-2, self.mod)
                for j in range(N, 0, -1):
                        self.lists[j-1].rev = ((self.lists[j].rev)*j) % self.mod

        def combi(self, K, R):
                if K < R:
                        return 0
                else:
                        return ((self.lists[K].power)*(self.lists[K-R].rev)*(self.lists[R].rev)) % self.mod


class Dijkstra():

        class Edge():
                """ 重み付き有向辺 """

                def __init__(self, _to, _cost):
                        self.to = _to
                        self.cost = _cost

        def __init__(self, V):
                """
                Args:
                        V(int): 頂点の数
                """
                self.G = [[] for i in range(V)]  
                self._E = 0  
                self._V = V  

        @property
        def E(self):
                """ 辺数 """
                return self._E

        @property
        def V(self):
                """ 頂点数 """
                return self._V

        def add(self, _from, _to, _cost):
                """ 2頂点と、辺のコストを追加する """
                self.G[_from].append(self.Edge(_to, _cost))
                self._E += 1

        def shortest_path(self, s):
                """ 始点sから頂点iまでの最短路を格納したリストを返す
                """
                import heapq
                que = []
                heapq.heapify(que)
                d = [float("inf")] * self.V
                d[s] = 0
                heapq.heappush(que, (0, s))  

                while len(que) != 0:
                        cost, v = heapq.heappop(que)
                        if d[v] < cost:
                                continue

                        for i in range(len(self.G[v])):
                                e = self.G[v][i]  
                                if d[e.to] > d[v] + e.cost:
                                        d[e.to] = d[v] + e.cost
                                        heapq.heappush(que, (d[e.to], e.to))
                return d


def warshall_floyd(d):
        
        n = len(d[0])-1
        for i in range(n+1):
                d[i][i] = 0  
        for k in range(1, n+1):
                for i in range(1, n+1):
                        for j in range(1, n+1):
                                d[i][j] = min(d[i][j], d[i][k] + d[k][j])
        return d


def kruskal(edge, N):
        res = 0
        node = []
        edge.sort()
        G = UnionFind(N)
        for cost, p, q, in edge:
                if not G.same(p, q):
                        G.union(p, q)
                        node.add((cost, p, q))
                        res += cost
        return res, node


def bellman_ford(s, graph, n):
        dist = [10**20 for i in range(n+1)]
        dist[s] = 0
        for i in range(1, n+1):
                flag = False
                for some in graph:
                        a, b, d = some[0], some[1], some[2]
                        newlen = dist[a]+d
                        if newlen < dist[b]:
                                flag = True
                                dist[b] = newlen
                if not flag:
                        break
                if i == n:
                        print("There is a negative circle!")
        return dist


class LCA_Tree():
        
        

        def bfs(self, node):
                
                self.visited[node] = True
                for p in tree[node]:
                        if self.visited[p] == False:
                                self.kprv[0][p] = node
                                self.depth[p] = self.depth[node]+1
                                self.bfs(p)

        def __init__(self, root, tree):
                self.root = root
                self.n = len(tree)-1
                self.K = (self.n-1).bit_length()
                self.visited = [False for i in range(self.n+1)]
                self.depth = [0 for i in range(self.n+1)]
                self.kprv = [[-1 for i in range(self.n+1)] for j in range(self.K+1)]
                self.bfs(self.root)
                for cnt in range(1, self.K+1):
                        for node in range(self.n+1):
                                if self.kprv[cnt-1][node] >= 0:
                                        self.kprv[cnt][node] = self.kprv[cnt -
                                                                                                        1][self.kprv[cnt-1][node]]
                                else:
                                        self.kprv[cnt][node] = -1

        def query(self, u, v):
                

                dd = self.depth[v]-self.depth[u]

                if dd < 0:
                        u, v = v, u
                        dd = -dd

                for i in range(self.K+1):
                        if dd & 1:
                                v = self.kprv[i][v]
                        dd >>= 1
                if u == v:
                        return u

                for i in range(self.K-1, -1, -1):
                        pu = self.kprv[i][u]
                        pv = self.kprv[i][v]
                        if pu != pv:
                                u = pu
                                v = pv
                return self.kprv[0][u]


class UnionFind():
        def __init__(self, n):
                self.n = n
                self.parents = [-1] * (n+1)

        def find(self, x):
                if self.parents[x] < 0:
                        return x
                else:
                        self.parents[x] = self.find(self.parents[x])
                        return self.parents[x]

        def union(self, x, y):
                x = self.find(x)
                y = self.find(y)

                if x == y:
                        return

                if self.parents[x] > self.parents[y]:
                        x, y = y, x

                self.parents[x] += self.parents[y]
                self.parents[y] = x

        def size(self, x):
                return -self.parents[self.find(x)]

        def same(self, x, y):
                return self.find(x) == self.find(y)

        def members(self, x):
                root = self.find(x)
                return [i for i in range(self.n + 1) if self.find(i) == root]

        def roots(self):
                return [i for i, x in enumerate(self.parents) if x < 0]

        def group_count(self):
                return len(self.roots())

        def all_group_members(self):
                return {r: self.members(r) for r in self.roots()}

        def __str__(self):
                return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


class UnionFindLabel(UnionFind):
        def __init__(self, labels):
                assert len(labels) == len(set(labels))

                self.n = len(labels)
                self.parents = [-1] * self.n
                self.d = {x: i for i, x in enumerate(labels)}
                self.d_inv = {i: x for i, x in enumerate(labels)}

        def find_label(self, x):
                return self.d_inv[super().find(self.d[x])]

        def union(self, x, y):
                super().union(self.d[x], self.d[y])

        def size(self, x):
                return super().size(self.d[x])

        def same(self, x, y):
                return super().same(self.d[x], self.d[y])

        def members(self, x):
                root = self.find(self.d[x])
                return [self.d_inv[i] for i in range(self.n) if self.find(i) == root]

        def roots(self):
                return [self.d_inv[i] for i, x in enumerate(self.parents) if x < 0]


class BIT:
        
        def __init__(self, n):
                self.n = n
                self.data = [0]*(n+1)

        def to_sum(self, i):
                
                s = 0
                while i > 0:
                        s += self.data[i]
                        i -= (i & -i)
                return s

        def add(self, i, x):
                
                while i <= self.n:
                        self.data[i] += x
                        i += (i & -i)

        def get(self, i, j):
                
                return self.to_sum(j)-self.to_sum(i-1)


class SegTree():
        
        def __init__(self, lists, function, basement):
                self.n = len(lists)
                self.K = (self.n-1).bit_length()
                self.f = function
                self.b = basement
                self.seg = [basement]*(2**(self.K+1)+1)
                X = 2**self.K
                for i, v in enumerate(lists):
                        self.seg[i+X] = v
                for i in range(X-1, 0, -1):
                        self.seg[i] = self.f(self.seg[i << 1], self.seg[i << 1 | 1])

        def update(self, k, value):
                X = 2**self.K
                k += X
                self.seg[k] = value
                while k:
                        k = k >> 1
                        self.seg[k] = self.f(self.seg[k << 1], self.seg[(k << 1) | 1])

        def query(self, L, R):
                num = 2**self.K
                L += num
                R += num
                vL = self.b
                vR = self.b
                while L < R:
                        if L & 1:
                                vL = self.f(vL, self.seg[L])
                                L += 1
                        if R & 1:
                                R -= 1
                                vR = self.f(self.seg[R], vR)
                        L >>= 1
                        R >>= 1
                return self.f(vL, vR)

        def find_max_index(self, L, R, X):
                
                return self.fMi(L, R, X, 1, 0, 2**self.K)

        def find_min_index(self, L, R, X):
                
                return self.fmi(L, R, X, 1, 0, 2**self.K)

        def fMi(self, a, b, x, k, l, r):
                if self.seg[k] > x or r <= a or b <= l:
                        
                        return -1
                else:
                        if k >= 2**self.K:
                                return k-2**self.K
                        else:
                                vr = self.fMi(a, b, x, (k << 1) | 1, (l + r) // 2, r)
                                if vr != -1:
                                        return vr
                                return self.fMi(a, b, x, k << 1, l, (l + r) // 2)

        def fmi(self, a, b, x, k, l, r):
                if self.seg[k] > x or r <= a or b <= l:
                        
                        return -1
                else:
                        if k >= 2**self.K:
                                return k-2**self.K
                        else:
                                vl = self.fmi(a, b, x, k << 1, l, (l+r)//2)
                                if vl != -1:
                                        return vl
                                return self.fmi(a, b, x, k << 1 | 1, (l+r)//2, r)


def count_inversion(lists):
        ans = 0
        N = len(lists)
        tree = BIT(N)
        for index, p in enumerate(lists):
                tree.add(p, 1)
                ans += index+1-tree.to_sum(p)
        return ans




def xgcd(a, b):
        x0, y0, x1, y1 = 1, 0, 0, 1
        while b != 0:
                q, a, b = a // b, b, a % b
                x0, x1 = x1, x0 - q * x1
                y0, y1 = y1, y0 - q * y1
        return a, x0, y0




def modinv(a, m):
        g, x, y = xgcd(a, m)
        if g != 1:
                return False
        else:
                return x % m


def union_lcm(lists):
        if len(lists) == 1:
                return lists[0]
        elif len(lists) > 1:
                num = lists[0]
                for i in range(1, len(lists)):
                        num = num*lists[i]//gcd(num, lists[i])
                return num



def union_gcd(lists):
        if len(lists) == 1:
                return lists[0]
        elif len(lists) > 1:
                num = lists[0]
                for i in range(1, len(lists)):
                        num = gcd(num, lists[i])
                return num




def trans(x, k):
        string = ""
        while x != 0:
                u, v = divmod(x, k)
                string = str(v)+string
                x = u
        return string


def trans(X, K):
        
        if 0 < X < -K:
                return str(X)
        if X == 0:
                return "0"
        U, V = divmod(X, K)
        if V < 0:
                U += 1
                return trans(U, K)+str(V-K)
        else:
                return trans(U, K)+str(V)


def prime_list(n):
        prime = {i for i in range(2, n)}
        for i in range(2, n):
                if i in prime:
                        for j in range(i*2, n, i):
                                if j in prime:
                                        prime.remove(j)
        return prime


def is_prime(N):
        if N == 1:
                return False
        i = 2
        while i**2 <= N:
                if N % i == 0:
                        return False
                i += 1
        return True


def super_factorization(N):
        
        spf = [i for i in range(N+1)]
        
        
        prime = {i for i in range(2, N+1)}

        for i in range(2, N+1):
                if i in prime:
                        for j in range(i*2, N+1, i):
                                if j in prime:
                                        spf[j] = i
                                        prime.remove(j)

        result = [{} for _ in range(N+1)]
        
        for i in range(2, N+1):
                div = spf[i]
                if div == 1:
                        result[i] = {i: 1}
                else:
                        y = i//div
                        result[i] = result[y].copy()
                        if div in result[i].keys():
                                result[i][div] += 1
                        else:
                                result[i][div] = 1
        return result
def main():
    
    a,b,c,d,e=list(map(int,input().split()))
    print(15-a-b-c-d-e)
if __name__=="__main__":
    main()

Solution (Python):
a = list(map(int, input().split()))
for x in range(len(a)):
  if x + 1 != a[x]:
  	print(x + 1)

Solution (Python):
import argparse
import collections
import logging.config
import sys
import csv
import numpy as np

def main():
    s=input().split(" ")
    ans=15
    for d in s:
        ans -= int(d)
    print (ans)

if __name__ == '__main__':
    main()

Solution (Python):
a=list(map(int,input().split()))
for i in range(len(a)):
  if a[i]==0:
    print(i+1)
    break

Solution (Python):

a, b, c, d, e = map(int, input().split())
 
suuji_list = ["", a, b, c, d, e]
 
print(suuji_list.index(0))

Solution (Python):
def ip(): return[int(_) for _ in input().split()]

def main():
    ip1=ip()
    for i in ip1:
        if i==0:
            print(ip1.index(i)+1)
    return



if __name__=='__main__':
    main()

Solution (Python):
a = list(map(int, input().split()))

if a[0] == 0:
  print(1)
elif a[1] == 0:
  print(2)
elif a[2] == 0:
  print(3)
elif a[3] == 0:
  print(4)
else:
  print(5)

Solution (Python):
l=list(map(int,input().split()))
print(l.index(0)+1)

Solution (Python):
x = list(map(int, input().split()))
for i in range(5):
    if not x[i] == i+1:
        print(i+1)
        exit()

Solution (Python):
x = map(int,input().split())

cnt=1

for i in x:
    
    if i==0:
        print(cnt)
    else:
        cnt+=1

Solution (Python):


l = list(map(int, input().split()))
print(l.index(0)+1)

Solution (Python):
import sys
input = sys.stdin.readline

a = list(map(int, input().split(' ')))
 
for i in range(len(a)):
  if a[i] == 0:
    print(i+1)
    break

Solution (Python):
import sys
input = sys.stdin.readline
a = list(map(int, input().rstrip().split(' ')))
 
for i in range(len(a)):
  if a[i] == 0:
    print(i+1)
    break

Solution (Python):
import sys
a = list(map(int, sys.stdin.readline().rstrip().split(' ')))
 
for i in range(len(a)):
  if a[i] == 0:
    print(i+1)
    break

Solution (Python):
a=input().split()
print(a.index('0')+1)

Solution (Python):
xi = [1, 2, 3, 4, 5]
xi2 = input()
xi2_ = xi2.split(" ")
change = list(map(int, xi2_))
changed_index = (set(xi) ^ set(change))
print(list(changed_index)[1])

Solution (Python):
n = input().replace(' ', '')
print(n.index('0') + 1)

Solution (Python):


s = input().split(' ')

for i in range(len(s)):
    if int(s[i]) == 0:
        print(i + 1)
        break

Solution (Python):
x = [int(i) for i in input().split()]
for i in range(5):
    if x[i] == 0:
        print(i+1)

Solution (Python):
a=[int(x) for x in input().split()]

for i in range(len(a)):
  if a[i]==0:
    print(i+1)
    break

Solution (Python):
x = [int(i) for i in input().split()]
print(15-sum(x))

Solution (Python):
a = list(map(int,input().split()))
print(a.index(0)+1)

Solution (Python):
n = list(map(int,input().split()))
l = n.index(0)
print(l+1)

Solution (Python):
A = list(map(int,input().split()))
print(A.index(0)+1)

Solution (Python):
x = input().split()
sum = 0
for i in range(5):
  sum += i+1
  sum -= int(x[i])
print(sum)

Solution (Python):
print(15-sum(map(int,input().split())))

Solution (Python):
li=list(map(int,input().split()))
print(li.index(0)+1)

Solution (Python):
a,b,c,d,e=map(int, input().split())

if a == 0:
    print('1')
elif b == 0:
    print('2')
elif c == 0:
    print('3')
elif d == 0:
    print('4')
elif e == 0:
    print('5')
else :
    print('none')

Solution (Python):
A = list(map(int, input().split()))
for i in range(0,5):
  if A[i] == 0:
    print(i+1)

Solution (Python):
def main():
  input_number = list(map(int, input().split()))
  for i in range(5):
    if input_number[i]==0:
      print(i+1)
      exit()

if __name__=='__main__':
  main()

Solution (Python):
x = list(map(int, input().split()))
for i in range(5):
    if x[i] == 0:
        print(i+1)
        exit()

Solution (Python):
a = list(map(int,input().split()))
print(a.index(0)+1)

Solution (Python):
x1, x2, x3, x4, x5 = map(int, input().split())
if x1 == 0:
  print(1)
if x2 == 0:
  print(2)
if x3 == 0:
  print(3)
if x4 == 0:
  print(4)
if x5 == 0:
  print(5)

Solution (Python):
num = list(map(int, input().split()))
count = 0
for i in num:
  if i == 0:
    count += 1
    print(count)
  else:
    count += 1

Solution (Python):

num_list = list(map(int, input().split()))  
for i in range(len(num_list)):
    if num_list[i] == 0:
        print(i+1)
        break

Solution (Python):
print(int(input().split().index("0"))+1)

Solution (Python):
x = list(map(int, input().split()))

print(x.index(0)+1)

Solution (Python):
print(list(map(int, input().split())).index(0) + 1)

Solution (Python):
x = list(map(int,input().split()))

for i in range(5):
    if x[i] == 0:
        print(i+1)
    else:
      pass

Solution (Python):

import numpy as np
from collections import deque
from collections import defaultdict
import heapq
import collections
import itertools
import bisect


def zz():
    return list(map(int, input().split()))


def z():
    return int(input())


def S():
    return input()


def C(line):
    return [input() for _ in range(line)]


a, b, c, d, e = zz()
if(a == 0):
    print(1)
    exit()
if(b == 0):
    print(2)
    exit()
if(c == 0):
    print(3)
    exit()
if(d == 0):
    print(4)
    exit()
if(e == 0):
    print(5)
    exit()

Solution (Python):
A = list(map(int, input().split()))
k = A.index(0)
print(k+1)

Solution (Python):
x = [int(i) for i in input().split()]

for j in range(5):
    if x[j] == 0:
        print(j+1)
    else:
        pass

Solution (Python):
n = list(map(int, input().split()))

for (i, v) in enumerate(n):
  if v == 0:
    print(i+1)
    break

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


def input_int(): return int(input())

def map_int_input(): return map(int, input())

MII = map_int_input

def MII_split(): return map(int, input().split())

def MII_to_index(): return map(to_index, input())

def MII_split_to_index(): return map(to_index, input().split())


def list_int_inputs(): return list(map(int, input()))

LII = list_int_inputs

def LII_split(): return list(map(int, input().split()))


def LII_2D(rows_number): return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number): return [LII_split() for _ in range(rows_number)]

xs = LII_split()
for i in range(1, len(xs)+1):
    if xs[i-1] == 0:
        print(i)

Solution (Python):
x = list(map(int,input().split()))
for loop in range(len(x)):
    if x[loop]==0:
        print( 1+ loop)
        exit()

Solution (Python):
x = [0 for i in range(5)]
x[0], x[1], x[2], x[3], x[4] = input().split()
for i in range(1, 6, 1):
    if int(x[i-1]) == 0:
        print(i)
        break

Solution (Python):
x = list(map(int, input().split()))

for i, j in enumerate(x, 1):
    if i != j:
        print(i)

Solution (Python):
print(input().split().index('0')+1)

Solution (Python):
x = list(map(int, input().split()))
for i in range(len(x)):
  if x[i] == 0:
    print(i+1)
    break

Solution (Python):
x = input()
a,b,c,d,e = map(int,x.split())
print(15 - a-b-c-d-e)

Solution (Python):
print(*[i+1 for i, x in enumerate(map(int, input().split())) if x == 0])

Solution (Python):
a = input().split()
print(1 + a.index('0'))

Solution (Python):
import sys
from sys import setrecursionlimit

setrecursionlimit(10 ** 5)



readline = sys.stdin.readline

def proc():
    a = list(map(int, readline().rstrip().split()))
    for i,j in enumerate(a):
        if not j:
            print (i+1)
            return




proc()

Solution (Python):

x = map(int, input().split())
print(15 - sum(x))

Solution (Python):
n=list(map(int, input().split()))
print(n.index(0)+1)

Solution (Python):
li = list(map(int,input().split()))
for i in range(5):
    if li[i] == 0:
        print(i+1)

Solution (Python):
def check(a):
    for i in a:
        if i==0:
            ans = a.index(i)+1
            return ans

a = list(map(int, input().split()))
print(check(a))

Solution (Python):
def main():
    n = input().split()
    print(n.index('0')+1)

if __name__ == "__main__":
    main()

Solution (Python):
a = list(map(int, input().split()))
ans = 0

if a[0]==0:
    ans = 1
if a[1]==0:
    ans = 2
if a[2]==0:
    ans = 3
if a[3]==0:
    ans = 4
if a[4]==0:
    ans = 5

print(ans)

Solution (Python):
X = list(map(int, input().split()))

for i in range(5):
    if X[i] == 0:
        ans = i + 1

print(ans)

Solution (Python):
arr=list(map(int,input().split()))
for i in range(5):
  if arr[i]==0:
    print(i+1)
    break

Solution (Python):
x_list = list(map(int, input().split()))
for i in range(5):
    if x_list[i] == 0:
        print(i+1)

Solution (Python):
X = map(int,input().split())

for i,j in enumerate(X):
    if(j == 0):
        print(i + 1)

Solution (Python):
input=input()
x = input.split()
for i in range(5):
    if(x[i]=='0'):
        print(i+1)
        break

Solution (Python):
i = list(map(int,input().split()))
for x in range(5):
  if i[x] != x+1:
    print(x+1)

Solution (Python):
a = list(map(int, input().split()))
for i in range(len(a)):
    if a[i] == 0:
        print(i + 1)

Solution (Python):
a,b,c,d,e=map(int,input().split())
if a==0:
  print(1)
elif b==0:
  print(2)
elif c==0:
  print(3)
elif d==0:
  print(4)
elif e==0:
  print(5)

Solution (Python):
l = input().split()

ans = l.index('0')

print(ans + 1)

Solution (Python):
print(list(map(int,input().split())).index(0)+1)

Solution (Python):
def main():
    *x, = map(int, input().split())
    print(x.index(0) + 1)
    return


main()

Solution (Python):
nums = [int(x) for x in input().split(" ")]

for i in range(5):
    if nums[i] == 0:
        print(i + 1)
        exit(0)

Solution (Python):
print(list(map(int, input().split())).index(0)+1)

Solution (Python):
A=[int(_) for _ in input().split()]
B=sum(A)
S=15-B
print(S)

Solution (Python):
import sys
import time
st = time.perf_counter()


ls = list(map(int, input().split()))
print(ls.index(0)+1)


ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)

Solution (Python):
l = list(map(int, input().split()))

x = l.index(0) + 1

print(x)

Solution (Python):
x=input().split()
print((x.index('0'))+1)

Solution (Python):
i=0
for c in input().split():
    i +=1
    if c=="0":
        print(i)

Solution (Python):


import sys
import math
from collections import Counter
import itertools
import fractions
from decimal import *




def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())

def LI(): return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")


X=LI()

i = 0
for x in X:
    i+=1
    if x == 0:
        print(i)
        exit()

Solution (Python):
import numpy as np

a,b,c,d,e = map(int, input().split())
if(a==0):
  print(1)
if(b==0):
  print(2)
if(c==0):
  print(3)
if(d==0):
  print(4)
if(e==0):
  print(5)

Solution (Python):
print(list(map(int,input().split())).index(0)+1)

Solution (Python):



import os
import sys







def main():
    x1, x2, x3, x4, x5 = map(int, input().split())
    list = []
    list.append(x1)
    list.append(x2)
    list.append(x3)
    list.append(x4)
    list.append(x5)
    for i, x in enumerate(list):
        if x == 0: print(i+1)
    return


if __name__ == '__main__':
    main()