Buggy python submission (verdict: Runtime Error):
def plus(number_list):
    return sum([int(num) for num in number_list])


def minus(number_list):
    numbers = [int(num) for num in number_list]
    
    return numbers[0] - sum(numbers[1:])


def multiply(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)*list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]


def divide(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)/list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]



store_result = []
store_num = []
result = 0

for  i,c in enumerate(input_list.split()):
    
    
    if i < len(input_list.split())-1:
        print('result',result)
        print('store_num',store_num)
        print('store_result',store_result)
        
        if c == '+' :
            result = plus(store_num)
            store_num = []
            store_result.append(result)
        elif c== "-":
            result = minus(store_num)
            store_num = []
            store_result.append(result)
        elif c =='*':
            result = multiply(store_num)
            store_num = []
            store_result.append(result)     
        elif c == '/':
            result = divide(store_num)
            store_num = []
            store_result.append(result)
        else:
            store_num.append(int(c))
    
    
    else:
        if c == '+' :
            result = plus(store_result)
        elif c== "-":
            result = minus(store_result)
        elif c =='*':
            result = multiply(store_result)
        elif c == '/':
            result = divide(store_result)
        
print(result)
        
        


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
def plus(number_list):
    return sum([int(num) for num in number_list])


def minus(number_list):
    numbers = [int(num) for num in number_list]
    
    return numbers[0] - sum(numbers[1:])


def multiply(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)*list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]


def divide(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)/list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]



store_result = []
store_num = []

result = 0

for  i,c in enumerate(input_list.split()):
    
    
    
    if i < len(input_list.split())-1:
        print('result',result)
        print('store_num',store_num)
        print('store_result',store_result)
        
        if c == '+' :
            result = plus(store_num)
            store_num = []
            store_result.append(result)
        elif c== "-":
            result = minus(store_num)
            store_num = []
            store_result.append(result)
        elif c =='*':
            result = multiply(store_num)
            store_num = []
            store_result.append(result)     
        elif c == '/':
            result = divide(store_num)
            store_num = []
            store_result.append(result)
        else:
            store_num.append(int(c))
    
    
    
    else:
        if c == '+' :
            result = plus(store_result)
        elif c== "-":
            result = minus(store_result)
        elif c =='*':
            result = multiply(store_result)
        elif c == '/':
            result = divide(store_result)
        
print(result)
        
        


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
def plus(number_list):
    return sum([int(num) for num in number_list])


def minus(number_list):
    numbers = [int(num) for num in number_list]
    
    return numbers[0] - sum(numbers[1:])


def multiply(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)*list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]


def divide(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)/list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]



store_result = []
store_num = []

result = 0

for  i,c in enumerate(input_list.split()):
    
    
    
    if i < len(input_list.split())-1:

        
        if c == '+' :
            result = plus(store_num)
            store_num = []
            store_result.append(result)
        elif c== "-":
            result = minus(store_num)
            store_num = []
            store_result.append(result)
        elif c =='*':
            result = multiply(store_num)
            store_num = []
            store_result.append(result)     
        elif c == '/':
            result = divide(store_num)
            store_num = []
            store_result.append(result)
        else:
            store_num.append(int(c))
    
    
    
    else:
        if c == '+' :
            result = plus(store_result)
        elif c== "-":
            result = minus(store_result)
        elif c =='*':
            result = multiply(store_result)
        elif c == '/':
            result = divide(store_result)
        
print(result)
        
        


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
def plus(number_list):
    return sum([int(num) for num in number_list])


def minus(number_list):
    numbers = [int(num) for num in number_list]
    return numbers[0] - sum(numbers[1:])


def multiply(number_list):
    
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)*list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]


def divide(number_list):
    numbers = [int(num) for num in number_list]
    
    def recrusive(repeat_num, list_):
    
        if repeat_num == 0:
            return list_[0]
        else:
            return recrusive(repeat_num -1,list_)/list_[repeat_num]
    
    return [recrusive(i,number_list) for i in range(len(number_list))][-1]



store_result = []
store_num = []
result = 0

for  i,c in enumerate(input_list.split()):
    
    if i < len(input_list.split())-1:

        
        if c == '+' :
            result = plus(store_num)
            store_num = []
            store_result.append(result)
        elif c== "-":
            result = minus(store_num)
            store_num = []
            store_result.append(result)
        elif c =='*':
            result = multiply(store_num)
            store_num = []
            store_result.append(result)     
        elif c == '/':
            result = divide(store_num)
            store_num = []
            store_result.append(result)
        else:
            store_num.append(int(c))
    
    
    
    else:
        if c == '+' :
            result = plus(store_result)
        elif c== "-":
            result = minus(store_result)
        elif c =='*':
            result = multiply(store_result)
        elif c == '/':
            result = divide(store_result)
        
print(str(result))
        
        


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
stack = []
store_num = []
store_result = []

for i,c in enumerate(input_list.split()):

        
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])           





Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):



stack = []
store_num = []
store_result = []

for i,c in enumerate(input_list.split()):

        
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1]) 


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
stack = []
store_num = []
store_result = []

for i,c in enumerate(input.split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1]) 


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
stack = []
store_num = []
store_result = []

for i,c in enumerate(input.split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
 
print(input())         
#print(stack[-1]) 


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])

Buggy python submission (verdict: Runtime Error):
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
 
print(input())         
#print(stack[-1]) 


Fixed submission:
stack = []
store_num = []
store_result = []

for i,c in enumerate(input().split()): 
        
        def pop_and_stack(list_,num):
                     
            list_.pop()
            list_.pop()
            list_.append(num)
            
            return list_
            
    
        if c == '+' :
            a = stack[-2]
            b = stack[-1]
            num = a+b
            pop_and_stack(stack,num)

        elif c== "-":
            a = stack[-2]
            b = stack[-1]
            num = a-b
            pop_and_stack(stack,num)
        elif c =='*':
            a = stack[-2]
            b = stack[-1]
            num = a*b
            pop_and_stack(stack,num)  
        elif c == '/':
            a = stack[-2]
            b = stack[-1]
            num = a/b
            pop_and_stack(stack,num)
        else:
            stack.append(int(c))
            
print(stack[-1])