Problem:
 Score : 100 points    Problem Statement In order to pass the entrance examination tomorrow, Taro has to study for T more hours.  Fortunately, he can leap to World B where time passes X times as fast as it does in our world (World A).  While (X \times t) hours pass in World B, t hours pass in World A.  How many hours will pass in World A while Taro studies for T hours in World B?      Constraints  All values in input are integers.  1 \leq T \leq 100  1 \leq X \leq 100         Input Input is given from Standard Input in the following format:  T  X       Output Print the number of hours that will pass in World A.  The output will be regarded as correct when its absolute or relative error from the judge's output is at most 10^{-3} .        Sample Input 1 8 3      Sample Output 1 2.6666666667  While Taro studies for eight hours in World B where time passes three times as fast, 2.6666... hours will pass in World A.  Note that an absolute or relative error of at most 10^{-3} is allowed.       Sample Input 2 99 1      Sample Output 2 99.0000000000       Sample Input 3 1 100      Sample Output 3 0.0100000000

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

Solution (Python):
a,b=map(int, input().split())
print(a/b)

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

print(T/X)

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

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

print((float)(t/x))

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

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

print(a / b)

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

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

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

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

Solution (Python):
a,b = map(int,input().split())
print(a/b)

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

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

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())


T,X = MI()
print(T/X)

Solution (Python):
t,x = map(int, input().split(" "))
print(t/x)

Solution (Python):
print(eval(input().replace(" ",".0/")))

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

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

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

print(n/m)

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

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

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

Solution (Python):
t, x = map(int, input().split())
print('{:.10f}'.format(t/x))

Solution (Python):
a, b = map(int, input().split())
print(a / b)

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

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

Solution (Python):
def resolve():
    T, X = list(map(int, input().split(" ")))
    print(T/X)
    

if '__main__' == __name__:
    resolve()

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

result = hours / multi_time
print(result)

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

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

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

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

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

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

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

print(T / X)

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

    print(f"{t / x:.11f}")


if __name__ == "__main__":
    main()

Solution (Python):
N,M=map(int, input().split())
print(N/M)

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

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

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

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

Solution (Python):


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter  
from itertools import combinations as comb  
from itertools import permutations as permutate
from bisect import bisect_left as bl



from bisect import bisect_right as br
from bisect import bisect







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)





from types import GeneratorType


def iterative(f, stack=[]):
    def wrapped_func(*args, **kwargs):
        if stack: return f(*args, **kwargs)
        to = f(*args, **kwargs)
        while True:
            if type(to) is GeneratorType:
                stack.append(to)
                to = next(to)
                continue
            stack.pop()
            if not stack: break
            to = stack[-1].send(to)
        return to

    return wrapped_func







mod = 1000000007


def inp(): return sys.stdin.readline().rstrip("\r\n")  


def out(var): sys.stdout.write(str(var))  


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 zerolist(n): return [0] * n


def nextline(): out("\n")  


def testcase(t):
    for p in range(t):
        solve()


def printlist(a):
    for p in range(0, len(a)):
        out(str(a[p]) + ' ')

import heapq as hp
def solve():
    a,b=sep()
    print(a/b)
    







solve()

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

print(a/b)

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

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

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

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

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

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

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

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

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

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

print(T/X)

Solution (Python):
t,x=map(int,input().split())
ans=t/x
print(ans)

Solution (Python):
print(eval(input().replace(" ","/")))

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

Solution (Python):
a,b= map(int,input().split())
print(a/b)

Solution (Python):
def readinput():
    t,x=map(int,input().split())
    return t,x

def main(t,x):
    return t/x

if __name__=='__main__':
    t,x=readinput()
    ans=main(t,x)
    print(ans)

Solution (Python):
a,b=input().split()
a=int(a)
b=int(b)
print(a/b)

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')


t, x = LI()
t_a = t / x
print(t_a)

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

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

Solution (Python):
n,m=map(int,input().split())
print(n/m)

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

Solution (Python):
a, b = map(int, input().split())
print( a / b)

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

Solution (Python):

T,X = map(int,input().split())
print('{:.11f}'.format(T/X))

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

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

print(t/x)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    T, X = map(int, readline().split())

    print(T / X)

    return


if __name__ == '__main__':
    main()

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

print(T/X)

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

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

Solution (Python):
a, b = map(int, input().split())
print(a/b)

Solution (Python):
T,X=map(int,input().split())
print(float(T/X))

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

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

Solution (Python):
a,b=map(int, input().split())
print(a/b)

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

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

print(t / x)

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

Solution (Python):
a,b = map(int, input().split())
print(a/b)

Solution (Python):
a = [int(s) for s in input().split()]
print(a[0] / a[1])

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

print(T/X)

Solution (Python):








t,x=map(int,input().split())

print(t/x)

Solution (Python):
a, b = map(int, input().split())
print(float(a/b))

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

Solution (Python):
if __name__ == '__main__':
	t,x = map(int,input().split())
	
	print(t/x)

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

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

Solution (Python):
t, x = map(int, input().split())
print(float(t/x))

Solution (Python):

def main():
    a, b = map(int, input().split())
    print(float(a) / float(b))


if __name__ == "__main__":
    main()

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

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

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

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

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

print(t/x)

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

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

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    t, x = nm()
    print(t / x)


if __name__ == '__main__':
    main()

Solution (Python):
print(eval(input().replace(' ', '/')))

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

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

Solution (Python):
from decimal import Decimal
t, x = input().split()
print(Decimal(t)/Decimal(x))

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

print(T / X)

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

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

Solution (Python):
a,b=map(int,input().split())
print(a/b)

Solution (Python):

import sys

def main():
    input = sys.stdin.readline
    t, x = map(int, input().split())
    print(t / x)



if __name__ == '__main__':
    main()

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

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

Solution (Python):
a, b = list(map(int, input().split()))
my_result = a / b
print(my_result)

Solution (Python):
a,b=map(int,input().split());print(a/b)

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

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

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

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

Solution (Python):
ary = input().split(" ")
print(int(ary[0]) / int(ary[1]))

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

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

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

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

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

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

Solution (Python):
















































def calculation(lines):
    
    
    T, X = list(map(int, lines[0].split()))
    
    
    

    result = T/X

    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['8 3']
        lines_export = ['2.6666666667']
    if pattern == 2:
        lines_input = ['99 1']
        lines_export = ['99.0000000000']
    if pattern == 3:
        lines_input = ['1 100']
        lines_export = ['0.0100000000']
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    T, X = map(int, input().split())
    ans = T / X
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):

t, x = map(int, input().split())
print(t/x)

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

print(t/x)

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

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

print(t / x)

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

Solution (Python):
t, x = map(int, input().split())
ans = t / x
print(ans)

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

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

def main():
    t, x = map(int, input().split())
    print(t/x)
        
if __name__ == '__main__':
    main()

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

print(t / x)

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

print(T/X)

Solution (Python):
t, x = map(int, input().split())
a = t/x
print(a)

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

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

Solution (Python):
a,b=map(int,input().split())
print(a/b)

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
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 li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]





A, B = mi()

print(A / B)

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

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

t,x = map(int, input().split())
print('{:.12f}'.format(t / x))

Solution (Python):
T,X=map(int,input().split())
res = T/X
print(res)

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

t,x = I()
print(t/x)

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

print(x/t)

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

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

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

print(T/X)

Solution (Python):
def main():
 t,x = map(int,input().split())
 print(t / x)
main()

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

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

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

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

Solution (Python):
a,b=map(int,input().split())
print("%.10lf"%(a/b))

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

Solution (Python):






def main():
    T, X = map(int, input().split())

    return T / X


print(main())

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

Solution (Python):
import sys
T,X = map(int,input().split())
if not ( 1 <= T <= 100 and 1 <= X <= 100 ): sys.exit()

print(T/X)

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

Solution (Python):
t,x = map(float,input().split())
print(t/x)

Solution (Python):
T,X = (int(X) for X in input().split())
print(T/X)

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

print(float(t/x))

Solution (Python):
a,b = map(int,input().split())
print(a/b)

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

print(T/X)

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

print(t / x)

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

T,X = list(map(int,input().split()))
print(T/X)

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

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

Solution (Python):
a, b = map(int,input().split())
print(a/b)

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b = rm()
print(a/b)

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

Solution (Python):
t,x=map(int,input().split());print(t/x)

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

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

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

Solution (Python):
def main():
    a,b=map(int,input().split(' '))
    print("%.4f"%(a/b))

main()

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

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

Solution (Python):
a,b = map(float, raw_input().split(' '))
print a/b

Solution (Python):
t,x=map(int,input().split())
a=float(t/x)
print('{:.10f}'.format(a))

Solution (Python):

import sys
input = sys.stdin.readline
T,X = (int(i) for i in input().split())
ans =T/X
print(ans)

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

ans = T/X

print(ans)

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

Solution (Python):
A,B = map(int,input().split())
print(A / B)

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

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

num = (T/X)
print("{:.10f}".format(num))

Solution (Python):
print(eval(input().replace(" ","/")))

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

t = T / X

print(t)

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

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

Solution (Python):
t, x = map(int, input().split())
print('{:.10f}'.format(t/x))

Solution (Python):
t,x=map(float, input().split())
print("{:.4f}".format(t/x))

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

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

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

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

Solution (Python):
print(eval(input().replace(*' /')))

Solution (Python):
print(eval(input().replace(*' /')))

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

Solution (Python):
a,b = map(float,input().split())
print(a/b)

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

ans=t/x

print(ans)

Solution (Python):
import sys
from collections import deque,Counter
from decimal import Decimal
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())

def Main():
    t,x = SL()
    t = Decimal(t)
    x = Decimal(x)
    ans = t/x
    print(ans)
    return

if __name__=='__main__':
    Main()

Solution (Python):
t,x=map(int,input().split())
T = t/x
print(T)

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

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

Solution (Python):


t, x = map(int, input().split())

print(t / x)

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

print(T / X)

Solution (Python):

import itertools

def solve(T,X):
    """
    >>> solve(8,3)
    2.6666666667
    """
    print(T/X)


def main():
    T,X = map(int,input().split())
    solve(T,X)


def _test():
    import doctest
    doctest.testmod()


if __name__ == "__main__":
    import sys
    argv = sys.argv
    if len(sys.argv) == 1:
        
        main()
    elif sys.argv[1] == "-t":
        _test()
    else:
        input = open(sys.argv[1]).buffer.readline

Solution (Python):
def main():
    t,x=map(int,input().split())
    print(t/x)
    
if __name__ == "__main__":
    main()

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

Solution (Python):


import math



from collections import deque
from collections import Counter




t,x=map(int,input().split())
print(t/x)

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

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

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

Solution (Python):
t,x = map(float,input().split())
print(t / x)

Solution (Python):
from decimal import *

def main():
    t, x = map(int, input().split())
    print(Decimal(t) / Decimal(x))

main()

Solution (Python):
def solve():
    t, x = map(int, input().split())
    print(t / x)


if __name__ == '__main__':
    solve()

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

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

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

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

print(T/X)

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

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

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

print(T/X)

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

Solution (Python):
T,X = map(int,input().split())
print('{:.10f}'.format(T/X))

Solution (Python):
a,b = input().split()
print(int(a) / int(b) )

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

Solution (Python):
print(eval(input().replace(' ','/')))

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

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

print(T/X)

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

print(t/x)

Solution (Python):
nums = input().split(" ")
print(int(nums[0])/int(nums[1]))

Solution (Python):

t, s = map(int, input().split())
print(t/s)

Solution (Python):
T, X = map(int, input().split())
print('{:5f}'.format(T / X))

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

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

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

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

print(t/x)

Solution (Python):
t,x  = map(float,input().split())
print(t/x)

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

print(t/x)

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

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

Solution (Python):
def inp():return map(int,input().split())

t,x=inp()
print(t/x)

Solution (Python):
t,x = map(int,input().split())
print("{:.4f}".format(t/x))

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

Solution (Python):
n = input()
n_ls = n.split()
t = int(n_ls[0])
x = int(n_ls[1])

print(t / x)

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

Solution (Python):
t,x=map(int,input().split());print(t/x)

Solution (Python):
t,x=map(int,input().split());print(t/x)

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

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

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

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

print(T / X)

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

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

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

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

Solution (Python):
T, X = map(int,input().rstrip().split())
print(T/X)

Solution (Python):
A,B = list(map(int, input().split()))
print(A/B)

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

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

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

print(t / x)

Solution (Python):
t,x=map(float,input().split())
print(t/x)

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

print(T/X)

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

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

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

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

Solution (Python):



t, x = list(map(int, input().split()))

print(t/x)

Solution (Python):
a, b = map(int, input().split())
print(a/b)

Solution (Python):
import sys
T, X = map(int, sys.stdin.readline().rstrip().split())
print(T / X)

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

Solution (Python):
def main():
    a, b = map(int, input().split())
    print(a/b)


if __name__ == '__main__':
    main()

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

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

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

print(t/x)

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

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

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

Solution (Python):
a, b = map(int,input().split())
print(a/b)

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

print(t/x)

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

Solution (Python):

t,x=map(int,input().split())

print(t/x)

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

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

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

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

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

Solution (Python):
def main():
  num = list(map(int,input().split()))
  print( num[0]/num[1] )
  
main()

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
t, x = M()
print(t/x)

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

print(T/X)

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

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

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

Solution (Python):
t, x = map(float, input().split())
print(t/x)

Solution (Python):
T,X = [int(x) for x in input().split()]

print(T/X)

Solution (Python):
a, b = map(int,input().split())
print(a/b)

Solution (Python):
tmp = input().split(" ")
t = float(tmp[0])
x = float(tmp[1])

print(t/x)

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

Solution (Python):
t,x=map(float,input().split())
print(t/x)

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

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

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

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

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

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

Solution (Python):
A, B = map(int, input().split())
print(A/B)

Solution (Python):
T,X = map(float,input().split())
print(T/X)

Solution (Python):
x, y = map(int, input().split())
print(round(x/y, 10))

Solution (Python):

T, X = map(int, input().split()) 

print(T / X)

Solution (Python):
a,b=map(int,input().split())
print(a/b)

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

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

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

ans = t_b / x
print('{:.5f}'.format(ans))

Solution (Python):
A,B=map(int,input().split())
print(A/B)