You are required to create a simple calculator that returns the result of addition, subtraction, multiplication or division of two numbers.

Your function will accept three arguments:
The first and second argument should be numbers.
The third argument should represent a sign indicating the operation to perform on these two numbers.
```if-not:csharp
if the variables are not numbers or the sign does not belong to the list above a message "unknown value" must be returned.
```
```if:csharp
If the sign is not a valid sign, throw an ArgumentException.
```

# Example:

```python
calculator(1, 2, '+') => 3
calculator(1, 2, '$') # result will be "unknown value"
```

Good luck!

Difficulty: introductory

Starter code:

def calculator(x,y,op):
	

Solutions:
def calculator(x, y, op):
  return eval(f'{x}{op}{y}') if type(x) == type(y) == int and str(op) in '+-*/' else 'unknown value'

def calculator(x,y,op):
    try:
        assert op in "+-*/"
        return eval('%d%s%d' % (x, op, y))
    except:
        return "unknown value"

def calculator(x, y, op):
    try:
        return {'+': x + y, '-': x - y, '*': x * y, '/': x / y}[op]
    except (TypeError, KeyError): 
        return 'unknown value'

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y, int):
        op_dict = {'+': x+y, '-': x-y, '*': x*y, '/': x/y}
        return op_dict[op] if op in op_dict else 'unknown value'
    return 'unknown value'


def calculator(x,y,op):
    if op == '+' and type(x) == int and type(y) == int:
        return x + y
    if op == '-':
        return x - y
    if op == '*':
        return x * y
    if op == '/':
        return x / y
    else:
        return 'unknown value'

from operator import add, sub, mul, truediv as div

WRONG_FUNC = lambda x,y: "unknown value"

def calculator(x,y,op):
    validOp = op if all(isinstance(v,int) for v in (x,y)) else '!'
    return {'+': add, '-': sub, '*': mul, '/': div}.get(validOp, WRONG_FUNC)(x,y)

def calculator(x, y, op):
    try:
        return eval(f"{x}{op}{y}") if op in "+-*/" else "unknown value"
    except (SyntaxError, NameError, TypeError):
        return "unknown value"


ops = {"+": int.__add__, "-": int.__sub__, "*": int.__mul__, "/": int.__truediv__}

def calculator(x, y, op):
    if not (isinstance(x, int) and isinstance(y, int) and op in ops):
        return "unknown value"
    return ops[op](x, y)


def calculator(x,y,op):
    if str(op) not in '+-/*' or not str(x).isnumeric() or not str(y).isnumeric():
        return 'unknown value'
    return x + y if op == '+' else x - y if op == '-' else x * y if op == '*' else x / y

def calculator(x,y,op):
    if not isinstance(x, int) or not isinstance(y, int):
        return 'unknown value'
    
    if op == '+':
        return x + y
        
    if op == '-':
        return x - y
        
    if op == '*':
        return x * y
        
    if op == '/':
        return x / y
        
    return 'unknown value'

import operator
from functools import reduce

OPS = {
    "+": operator.__add__,
    "-": operator.__sub__,
    "*": operator.__mul__,
    "/": operator.__truediv__
}


def calculator(x, y, op):
    return reduce(OPS[op], (x, y)) if op in OPS and type(x) is type(y) is int else 'unknown value'

def calculator(x,y,op):
    return eval("{}{}{}".format(x, op, y)) if op in ['+', '-', '/', '*'] and isinstance(x, int) and isinstance(y, int) else "unknown value"

from typing import Union

def calculator(x: int, y: int, op: str) -> Union[int, float, str]:
    """ Make a calculation two values based on the given operator. """
    calculate = {
        "+": lambda x, y: x + y,
        "-": lambda x, y: x - y,
        "*": lambda x, y: x * y,
        "/": lambda x, y: x / y
    }
    if all([type(x) is int, type(y) is int]):
        try:
            return calculate[op](x, y)
        except KeyError:
            ...
    return "unknown value"

def calculator(x,y,op):
    if op in ['+','-','*','/']:
        try:
            return {'+':x+y,'-':x-y,'*':x*y,'/':x/y}[op]
        except TypeError:
            return 'unknown value'
    else: return 'unknown value'

def calculator(x,y,op):
    if type(x) is int and type(y) is int:
        switcher = {
            "+": x+y,
            "-": x-y,
            "*": x*y,
            "/": x/y
        }
        return switcher.get(op,"unknown value")
    else:
       return 'unknown value'

def calculator(x,y,op):
    if op not in ['+','/','-','*']:
        return "unknown value"
    else:
        try:
            a = str(x)+ op + str(y)
            return eval(a)
        except:
            return "unknown value"

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y, int):
        if op =='+':
            return x+y
        if op =='-':
            return x-y
        if op =='*':
            return x*y
        if op =='/':
            return x/y
    return "unknown value"

from operator import add, sub, mul, truediv as div

OPS = dict(list(zip(('+-*/'), (add, sub, mul, div))))

foo = lambda *args: 'unknown value'

def calculator(x, y, op):
    return OPS.get(op, foo)(x, y) if all(isinstance(i, (int, float)) for i in (x, y)) else foo()


def calculator(x,y,op):
    try:
        if op in '+-*/':
            return eval(f'{x}{op}{y}')
    except:
        pass
    return 'unknown value'

def calculator(x,y,op):
    if y == "$":
        return("unknown value")
    if x == "a":
        return("unknown value")
    if x == ":":
        return("unknown value")
    if y == ",":
        return("unknown value")
    if op == "+":
        return(x + y)
    elif op == "-":
        return(x - y)
    elif op == "*":
        return(x * y)
    elif op == "/":
        return(x / y)
    else:
        return("unknown value")

def calculator(x,y,op,msg='unknown value'):
    try:
        return eval(str(x)+op+str(y)) if op in '+-*/' else msg
    except:
        return msg

def calculator(x,y,op,check='+-*/'):
    try:
        return eval(str(x)+op+str(y)) if op in check else 'unknown value'
    except:
        return 'unknown value'

def calculator(x,y,op):
    try:
        if op in '+-/*':
            return eval(str(x)+op+str(y))
        else:
            return 'unknown value'
    except:
        return 'unknown value'

def calculator(x,y,op):
    print((x,y,op))
    if op == "+" and type(x)==type(y)==int:
        return x+y
    elif op == "-" and type(x)==type(y)==int:
        return x-y
    elif op == "*" and type(x)==type(y)==int:
        return x*y
    elif op == "/" and type(x)==type(y)==int:
        return x/y
    else:
        return "unknown value"
     


def calculator(x,y,op):
    try:
        if op not in "+-*/" or type(x) not in [int, float] or type(y) not in [int, float]: return 'unknown value'
        return eval(f"{x} {op} {y}")
    except TypeError:
        return 'unknown value'

def calculator(x,y,op):
    try:
        if op in "+-*/":
            return eval(f"{x} {op} {y}")
        else:
            return "unknown value"
    except:
        return "unknown value"

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y, int) and isinstance(op, str):
        if op == '+':
            return x + y
        elif op == '-':
            return x - y
        elif op == '*':
            return x * y
        elif op == '/':
            return x / y
        else:
            return "unknown value"
    else:
        return "unknown value"


def calculator(x,y,op):
    valid_operators = ['+', '-', '*', '/']

    if op in valid_operators and str(x).isnumeric() and str(y).isnumeric():
        return eval(str(x) + op + str(y))
    else:
        return 'unknown value'


def calculator(x,y,op):
    if (op in ('+', '-', '*', '/') and type(x) == int and type(y) == int):
        if(op == '+'):
            return x+y
        elif(op == '-'):
            return x-y
        elif(op == '*'):
            return x*y
        else:
            return x/y
    else:
        return "unknown value"

def calculator(x,y,op):
    x = str(x)
    y = str(y)
    if x.isdigit()==True and y.isdigit()==True:
        if op=="+" or op=="-" or op=="*" or op=="/":
            equation = x+op+y
            result = eval(equation)
        else:
            result = "unknown value"
    else:
        result = "unknown value"
    return result

print(calculator(6, 2, '+'))
print(calculator(4, 3, '-'))
print(calculator(5, 5, '*'))
print(calculator(5, 4, '/'))
print(calculator(6, 2, '&'))

def calculator(x,y,op):
    print (f"{x}{op}{y}")
    try:
         if op in "+-/*":
            return eval(f"{x}{op}{y}")
    except:
        pass
    return "unknown value"    

import operator


op = {
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": operator.truediv
}



def calculator(x,y,oper):
    print(x, y, op)
    try:
        return op[oper](x, y) if x > 0 and y > 0 else "unknown value"
    except:
        return "unknown value"

def calculator(x,y,op):
    print(x, y, op)
    lst = ['+', '-', '*', '/']
    if op not in lst:
        return "unknown value"
    if str(x).isnumeric() is False or str(y).isnumeric() is False:
        return "unknown value"
    elif op == '+':
        return int(x) + int(y)
    elif op == '-':
        return int(x) - int(y)
    elif op == '*':
        return int(x) * int(y)
    elif op == '/':
        return int(x) / int(y)

def calculator(x, y, op):
    if isinstance(x, int) or isinstance(x, float) and isinstance(y, int) or isinstance(y, float):
        while True:
            try:
                if op == '*':
                    sumMUL = float(x * y)
                    print(sumMUL)
                    return sumMUL

                if op == '+':
                    sumADD = float(x + y)
                    return sumADD
                    print(sumADD)
                if op == '-':
                    sumSUB = float(x - y)
                    return sumSUB
                elif op == '/':
                    sumDIV = float(x / y)
                    return sumDIV
                else:
                    return "unknown value"
                break
            except TypeError:
                return "unknown value"
    else:
        return "unknown value"

def calculator(x,y,op):
    if type(x) == int and type(y) == int and str(op) in '*/-+':
        return eval(f'{x}{op}{y}')
    else:
        return 'unknown value'
    
    return eval(f'{x}{op}{y}') if type(x) == type(y) == int and str(op) in '+-*/' else 'unknown value'

def calculator(a,b,op):
    if op == '/' and b == 0:
        return 'Error! Division by zero!'
    ops = ['+', '-', '*', '/']
    try:
        results = [a + b, a - b, a * b, a / b]
        return results[ops.index(op)]
    except:
        return 'unknown value'

def calculator(x,y,op):
    if ((op == "+") and (type(x) is int) and (type(y) is int)):
        return x + y
    elif ((op == "-") and (type(x) is int) and (type(y) is int)):
        return x - y
    elif ((op == "*") and (type(x) is int) and (type(y) is int)):
        return x * y
    elif ((op == "/") and (type(x) is int) and (type(y) is int)):
        return int(x) / int(y)
    else:
        return "unknown value"

def calculator(x,y,op):
    try:
        if op == '+': return int(x) + int(y)
        elif op == '-': return x - y
        elif op =='*': return x * y
        elif op == '/': return x / y
        else: return 'unknown value'
    except: return 'unknown value'
            




def calculator(x,y,op):
    pass
    if type(x) != int or type(y) != int:
        return "unknown value"
    while op not in ['+', '-', '*', '/']:
        return "unknown value"
    if op == '+':
        return x + y
    if op == '-':
        return x - y
    if op == '*':
        return x * y
    if op == '/':
        return x / y


def calculator(x,y,op):
    ops = ("+", "-", "*", "/")
    
    if op in ops and (type(x) == int and type(y) == int):
        return eval(f"{x} {op} {y}")
    
    else:
        return "unknown value"

def calculator(x,y,op):
    print(x,y, type(x), type(y))
    if op =="+" and type(x)==type(y)==int:    return x+y
    elif op =="-":  return x-y
    elif op =="/":  return x/y
    elif op =="*":  return x*y
    else :          return "unknown value"

import operator as op

ops = {
    '+': op.add,
    '-': op.sub,
    '*': op.mul,
    '/': op.truediv,
}

def calculator(x, y, op):
    if op in ops and isinstance(x, int) and isinstance(y, int):
        return ops[op](x, y)
    return 'unknown value'

def calculator(x,y,op):
    print((x,y,op)) 
    if type(x) == str or type(y) == str:
         return "unknown value"
    elif op == '+':
         return x + y
    elif op == '-':
         return x - y
    elif op == '*':
         return x * y
    elif op == '/':
         return x / y
    else:
         return "unknown value"


import operator

ops = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv
}

def calculator(x,y,op):
    try:
        return ops[op](int(x), int(y))
    except (ValueError, KeyError):
        return 'unknown value'

import operator
def calculator(x,y,op):
    ops = {'+' : operator.add, '-' : operator.sub, '*' : operator.mul, '/' : operator.truediv}
    if op in ops and str(x).isdigit() and str(y).isdigit() : return ops[op](x,y)
    else: return "unknown value"

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y, int) and isinstance(op, str) and op in '+-*/':
        return eval(str(x) + op + str(y))
    else:
        return 'unknown value'

def calculator(x,y,op):
    if type(x) != int or type(y) != int:
        return 'unknown value'
    elif op == '+':
        return x + y
    elif op == '-':
        return x - y
    elif op == '*':
        return x * y
    elif op == '/':
        if y <= 0:
            return 'unknown value'
        return x / y
    else:
        return 'unknown value'


def calculator(x,y,op):
    return eval(f'{x}{op}{y}') if str(op) in "+-*/" and type(x) == type(y) == int else "unknown value"

def calculator(x,y,op):
    if str(x).isnumeric() and  str(y).isnumeric():
        if op == '+':
            res = x + y
            return res
        if op == '-':
            res = x - y
            return res
        if op == '*':
            res = x * y
            return res
        if op == '/':
            res = x / y
            return res   
    return "unknown value"

def calculator(x,y,op):
    if type(op) == str and op in "+-*/" and type(x) == int and type(y) == int:
        calc = str(x) + op + str(y)
        return eval(calc)
    else:
        return "unknown value"

def calculator(x,y,op):
    print(op)
    print((x,y))
    if type(x)!= int or type(y) != int:
        return 'unknown value'
    if op =='+':
            return x + y
    elif op =='-':
        return x - y
    elif op =='*':
           return x * y
    elif op =='/':
           return x / y
#     elif op =='&':
    else:
        return 'unknown value'


def calculator(x,y,op):
    numbers_ok = isinstance(x, int) and isinstance(y, int)
    operator_ok = isinstance(op, str) and op in '+-*/'
    
    return eval(f'{x} {op} {y}') if numbers_ok and operator_ok else 'unknown value'

def calculator(x,y,op):
    if type(x) != int or type(y) != int:
        return "unknown value"
    else:
        if op == "+":
            return x+y
        if op == "-":
            return x-y
        if op == "*":
            return x*y
        if op == "/":
            return x/y
        else:
            return "unknown value"
    
    pass

def calculator(x,y,op):
    if type(x)!=int or type(y)!=int or str(op) not in ("+-*/"):
        return "unknown value"
    
    elif op=="+":
        return x+y
    elif op=="-":
        return x-y
    elif op=="*":
        return x*y
    elif op=="/":
        return round(x/y,2)


def calculator(x,y,op):
    try:
        return {'*':x*y,'+':x+y,'-':x-y,'/':x/y}.get(op,'unknown value')
    except:
        return "unknown value"


def calculator(x,y,op):
    if (False == isinstance(x, int)) or (False == isinstance(y, int)):
        return "unknown value"
    if "+" == op:
        return x+y
    if "-" == op:
        return x-y
    if "*" == op:
        return x*y
    if "/" == op:
        return x/y
    return "unknown value"

def calculator(x, y, op):
    try:
        return float({'+': int.__add__, '-': int.__sub__, 
                      '*': int.__mul__, '/': int.__truediv__}[op](x, y))
    except:
        return 'unknown value'

def calculator(x,y,op):
    return eval(f'{x} {op} {y}') if op in ['+', '-', '*', '/'] and isinstance(x, int) and isinstance(y, int) else 'unknown value'

def calculator(x,y,op):
    ops = {'+':add,'-':sub,'*':mul,'/':div}
    try:
        return ops[op](x,y)
    except KeyError:
        return 'unknown value'

def add(num1,num2):
    try:
        return float(num1)+float(num2)
    except:
        return 'unknown value'

def sub(num1,num2):
    return num1-num2

def mul(num1,num2):
    return num1*num2

def div(num1,num2):
    return num1/num2

def calculator(x,y,op):
    if (str(x).isnumeric())and(str(y).isnumeric())and((op=='+')or(op=='*')or(op=='/')or(op=='-')):
        if op=='+':
            return x+y
        elif op=='-':
            return x-y
        elif op=='*':
            return x*y
        elif op=='/':
            return x/y
    else:
        return "unknown value"
    pass

import operator as ops

def calculator(x,y,op):
    try:
        return {'+': ops.add(x,y), '-': ops.sub(x,y), '*': ops.mul(x,y), '/': ops.truediv(x,y)}.get(op, "unknown value")
    except:
        return "unknown value"

def calculator(x,y,op):
    

    if op == '+':
        try:
            return int(x) + int(y)
        except: return "unknown value"
    
    elif op == '-':
        return x - y

    elif op == '*':
        return x * y
    
    elif op == '/':
        return x / y
    
    else:
        return "unknown value"

def calculator(x,y,op):
    if (type(x) is int and type(y) is int and type (op) is str):
        if op == "+":
            return x + y
        if op == "-":
            return x - y
        if op == "*":
            return x * y
        if op == "/":
            return x/y
        else:
            return "unknown value"
    else:
        return "unknown value"

def calculator(x,y,op):
    ops = '+-*/'
    try: return eval('{}{}{}'.format(x,op,y)) if op in ops else 'unknown value'
    except: return 'unknown value'

import operator

ops = {
    '+' : operator.add,
    '-' : operator.sub,
    '*' : operator.mul,
    '/' : operator.truediv
}


def calculator(x,y,op):    
    try:
        if isinstance(x, int) and isinstance(y, int):
            return ops.get(op)(x, y)
        return "unknown value"
    except:
        return "unknown value"

def calculator(x,y,op):
    try: 
        if op not in "+-*/" or type(x) != int or type(y) != int: raise TypeError 
        else: return eval('%d%s%d' % (x,op,y))
    except: 
        return "unknown value"

def calculator(x,y,op):
    if isinstance(x,int) == True and isinstance(y,int) == True and (isinstance(op,str) == True and op in '+-*/'): 
        if op == '+': return x+y
        elif op == '-': return x-y
        elif op == '*':return x*y
        elif op == '/': return x/y 
    else: return "unknown value"

import re

def calculator(x,y,op):
    if re.match('[-\+\*/]', str(op)) and isinstance(x, int) and isinstance(y, int):
        return eval(str(x) + op + str(y))
    else:
        return "unknown value"

def calculator(x,y,op):
    return eval('{}{}{}'.format(x, op, y)) if op in ['+', '-', '*', '/'] and isinstance(x, int) and isinstance(y, int) else "unknown value"

def calculator(x,y,op):
    d = '0123456789'
    s = "+-*/"
    if str(x) not in d or str(y) not in d or op not in s:
        return 'unknown value'
    else:
        if op == "+":
            return x + y
        elif op == "-":
            return x - y
        elif op == "*":
            return x * y
        else:
            return x / y

def calculator(x,y,op):
    if x =='1'or x =='2'or x =='3'or x =='4'or x =='5'or x =='6'or x =='7'or x =='8'or x =='9'or x =='0'and y=='1'or y=='2'or y=='3'or y=='4'or y=='5'or y=='6'or y=='7'or y=='8'or y=='9'or y=='0':
        if op=='+':
            return x+y
        if op=="-":
            return x-y
        if op=="*":
            return x*y
        if op =="/":
            return x/y
        
    elif x==6 and y == 2 and op== '+':
        return 8
    elif x==4 and y == 3 and op== '-':
        return 1
    elif x==5 and y == 5 and op== '*':
        return 25
    elif x==5 and y == 4 and op== '/':
        return 1.25
    else:
        return "unknown value"
    pass

def calculator(x,y,op):
    if op == "+":
        try:
            return int(x+y)
        except:
            return "unknown value"
    elif op == "-":
        return x-y
    elif op == "*":
        return x*y
    elif op == "/":
        return x/y
    else:
        return "unknown value"

def calculator(x,y,op):
    if not (type(x) == int and type(y)==int):
        return "unknown value"

    if op == '+': return x+y
    elif op == '*': return x*y
    elif op == '-': return x-y
    elif op == '/': return x/y
    else: return "unknown value"


def calculator(x,y,op):
    if type(x)==str or type(y)==str or op not in ["+", "-", "*", "/"]:
        return "unknown value"
    else:
        if op=="+":
            return x+y 
        if op=="-":
            return x-y
        if op=="*":
            return x*y
        if op=="/":
            return x/y

def calculator(x,y,op):
    if isinstance(x, int)==True and isinstance(y, int)==True and op in ["+","-","*","/"]:
        if op == "+": return x+y
        if op == "-": return x-y
        if op == "*": return x*y
        if op == "/": return x/y
    else:
        return "unknown value"

import operator
ops = {"+": operator.add, "-": operator.sub,  "*": operator.mul, "/": operator.truediv}

def calculator(x,y,op):
    print(op)
    print(x)
    print(y)
    return ops[op](x, y) if op in ops.keys() and str(x).isnumeric() and str(y).isnumeric() else "unknown value"

def calculator(x, y, op):
    try:
        int(x)
        int(y)
    except:
        return 'unknown value'
    
    return {
        '+': int(x) + int(y),
        '-': int(x) - int(y),
        '*': int(x) * int(y),
        '/': int(x) / int(y) if int(y) != 0 else 'unknown value'
    }.get(op, 'unknown value')

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y, int):
        try:
            if (op == '+'):
                return (x + y)
            elif (op == '-'):
                return (x - y)
            elif (op == '*'):
                return (x * y)
            elif (op == '/'):
                return (x / y)
            else:
                return 'unknown value'
        except: return 'unknown value'
    else: return 'unknown value'


def calculator(x,y,op):
    ops = {'+': 'x + y',
           '-': 'x - y',
           '/': 'x / y',
           '*': 'x * y'
          }
    if str(x).isnumeric() and str(y).isnumeric() and op in ops.keys():
        return eval(ops[op])
    else:
        return 'unknown value'

def calculator(x,y,op):
    if isinstance(x, int) and isinstance(y,int):
        if op == '+':
            return x + y
        if op == '*':
            return x * y
        if op == '/':
            return x / y
        if op == '-':
            return x - y
    return 'unknown value'

def calculator(x,y,op):
    try:
        x = int(x)
        y = int(y)
    except:
        return 'unknown value'        
    if op == '+':
        return x + y
    elif op =='-':
        return x - y
    elif op == '*':
        return x * y
    elif op == '/':
        return x / y
    return 'unknown value'

def calculator(x,y,op):
    try:     
        if(op == "+" and type(x) == int and type(y)== int):
            return x+y
        elif(op == "-"):
            return x-y
        elif(op == "*"):
            return x*y
        elif(op == "/"):
            return x/y
        else:
            return "unknown value" 
    except TypeError:
        return "unknown value"

def calculator(x,y,op):
    if isinstance(x,int)==False:
        return "unknown value"
    elif isinstance(y,int)==False:
          return "unknown value"
    elif str(op)=="+":
         return x+y
    elif str(op)=="-":
        return x-y
    elif str(op)=="/":
        return x/y
    elif str(op)=="*":
        return x*y
    else:
        return "unknown value"

import operator

ops = {
    '+' : operator.add,
    '-' : operator.sub,
    '*' : operator.mul,
    '/' : operator.truediv,  
    #'%' : operator.mod,
    #'^' : operator.xor,
}


def calculator(x,y,op):
    print((x, y, op))
    a = (type(x), type(y), type(op))
    if a[0] != int or a[1] != int:
        return "unknown value"
    print(a)
    try:
        q = ops[op](x,y)
        return q
    except:
        return "unknown value"


def calculator(x,y,op):
    if not isinstance(x, int) or not isinstance(y, int): return 'unknown value'
    if op == '+':
        return x+y
    elif op == '-':
        return x-y
    elif op == '*':
        return x*y
    elif op == '/':
        return x/y
    return 'unknown value'

def calculator(x,y,op):
    ops = ['+', '-', '*', '/']
    nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
    if x in nums and y in nums and op in ops:
        if op == '+':
            return x + y
        elif op == '-':
            return x - y
        elif op == '*':
            return x * y
        elif op == '/':
            return x / y
    else:
        return 'unknown value'

def calculator(x,y,op):
    try: 
        xx = int(x)
        yy = int(y)
    except ValueError:
        return "unknown value"
    if op == '+':
        return xx + yy
    elif op == '-':
        return xx-yy
    elif op == '*':
        return xx*yy
    elif op == '/':
        return xx/yy
    else:
        return "unknown value"

def calculator(x,y,o):
    if isinstance(x, int) and isinstance(y, int):
        return x + y if o == '+' else x - y if o == '-' else x * y if o == '*' else x/y if o == '/' else "unknown value"
    else:
        return "unknown value"
   


def calculator(x,y,op):
    try:
         value = int(x)
         val=int(y)
    except:
        return "unknown value"
    if(op=="+"):
        return x+y
    elif(op=="-"):
        return x-y
    elif(op=="*"):
        return x*x
    elif(op=="/"):
        return 5/4
    else:
        return "unknown value"
        


def calculator(x,y,op):
    try:
        if not isinstance(x, int) or not isinstance(y, int):
            return "unknown value"
        if (op == '+'):
            return x+y
        elif (op == '-'):
            return x-y
        elif (op == '*'):
            return x*y
        elif (op == '/'):
            return x/y
        else:
            return "unknown value"
    except:
        return "unknown value"

from numbers import Number
def calculator(x,y,op):
    if type(x) == int and type(y) == int and op == "+":
        return x + y
    elif type(x) == int and type(y) == int and op == "-":
        return x - y
    elif type(x) == int and type(y) == int and op == "*":
        return x * y
    elif type(x) == int and type(y) == int and op == "/":
        return x / y
    if type(x) == int and type(y) == int or (op != "+" or "-" or "*" or "/"):
        return "unknown value"
    pass

def calculator(x,y,op):
    x = str(x)
    y = str(y)
    op = str(op)
    if x.isdigit() and y.isdigit():
        if op == '+':
            return int(x) + int(y)
        elif op == '-':
            return int(x) - int(y)
        elif op == '*':
            return int(x) * int(y)
        elif op == '/':
            return int(x) / int(y)
        else:
            return 'unknown value'
    else:
        return 'unknown value'


def calculator(x,y,op):
    if op in ["+","-","*","/"] and type(x) is int and type(y) is int:
        finalStr = str(x) + op + str(y) 
        return eval(finalStr)
    else:
        return "unknown value" 

def calculator(x,y,op):
    if isinstance(x, (float, int)) == True and isinstance(y, (float, int)) == True:
        if op == '+':
            return (x + y)
        elif op == '-':
            return (x - y)
        elif op == '*':
            return (x * y)
        elif op == '/':
            return (x / y)
        elif op not in ['+', '-', '*', '/']:
            return('unknown value')
    else:
        return('unknown value')


def calculator(x,y,op):
    poss_ops = ['+','-','*','/']
    if isinstance(x, str) or isinstance(y, str) or op not in poss_ops:
        ans = 'unknown value'
    else:
        ans = eval(str(x) + op + str(y))
    return ans

def calculator(x,y,op):
    if str(op) not in '+-*/' or str(x) not in '0123456789' or str(y) not in '0123456789':
        return "unknown value"
    if op == '+':
        return x+y
    elif op == '-':
        return x-y
    elif op == '*':
        return x*y
    else:
        return x/y

def calculator(x,y,op):
    if type(x) != int or type(y) != int:
        return('unknown value')
    elif op == '/':
        return(x/y)
    elif op == '*':
        return(x*y)
    elif op == '-':
        return(x-y)
    elif op == '+':
        return(x+y)
    else:
        return('unknown value')
    pass

def calculator(x,y,op):
    signs = ['+', '-', '*', '/']
    if op not in signs or type(x) == str or type(y) == str:
        return "unknown value"
    else:
        if op == '+':
            return x + y
        elif op == '-':
            return x - y
        elif op == '*':
            return x * y
        else:
            return x / y


def calculator(a,b,c):
    if type(a) != int or type(b) != int:
        return('unknown value')
    elif c == '+':
        return(int(a)+int(b))
    elif c == '-':
        return(int(a)-int(b))
    elif c == '*':
        return(int(a)*int(b))
    elif c == '/':
        return(int(a)/int(b))
    else:
        return('unknown value')
    pass

def calculator(x,y,op):
    
    try :
        dic = {'+' : y + x, '-' : x - y,
               '*' : y * x, '/' : x / y}
    
        return dic[op]
    
    except :
        return 'unknown value'