output_description: 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}.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      T X
attempt: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  
  input = sys.stdin.readline
  
  import math
  from collections import deque
  from fractions import gcd
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9 + 7
  INF = float("inf")
  
  #############
  # Functions #
  #############
  
  
  ######INPUT######
  def inputI():
      return int(input().strip())
  
  
  def inputS():
      return input().strip()
  
  
  def inputIL():
      return list(map(int, input().split()))
  
  
  def inputSL():
      return list(map(str, input().split()))
  
  
  def inputILs(n):
      return list(int(input()) for _ in range(n))
  
  
  def inputSLs(n):
      return list(input().strip() for _ in range(n))
  
  
  def inputILL(n):
      return [list(map(int, input().split())) for _ in range(n)]
  
  
  def inputSLL(n):
      return [list(map(str, input().split())) for _ in range(n)]
  
  
  #####Inverse#####
  def inv(n):
      return pow(n, MOD - 2, MOD)
  
  
  ######Combination######
  kaijo_memo = []
  
  
  def kaijo(n):
      if len(kaijo_memo) > n:
          return kaijo_memo[n]
      if len(kaijo_memo) == 0:
          kaijo_memo.append(1)
      while len(kaijo_memo) <= n:
          kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
      return kaijo_memo[n]
  
  
  gyaku_kaijo_memo = []
  
  
  def gyaku_kaijo(n):
      if len(gyaku_kaijo_memo) > n:
          return gyaku_kaijo_memo[n]
      if len(gyaku_kaijo_memo) == 0:
          gyaku_kaijo_memo.append(1)
      while len(gyaku_kaijo_memo) <= n:
          gyaku_kaijo_memo.append(
              gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo), MOD - 2, MOD) % MOD
          )
      return gyaku_kaijo_memo[n]
  
  
  def nCr(n, r):
      if n == r:
          return 1
      if n < r or r < 0:
          return 0
      ret = 1
      ret = ret * kaijo(n) % MOD
      ret = ret * gyaku_kaijo(r) % MOD
      ret = ret * gyaku_kaijo(n - r) % MOD
      return ret
  
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-(n**0.5) // 1)) + 1):
          if temp % i == 0:
              cnt = 0
              while temp % i == 0:
                  cnt += 1
                  temp //= i
              arr.append([i, cnt])
      if temp != 1:
          arr.append([temp, 1])
  
      if arr == []:
          arr.append([n, 1])
      return arr
  
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd(a, b)
  
  
  #############
  # Main Code #
  #############
  
  T, X = inputIL()
  pirnt(T / X)
  
problem_description: 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?
samples: [{"input": "8 3", "output": "2.6666666667\n    \n\nWhile Taro studies for eight hours in World B where time passes three times as\nfast, 2.6666... hours will pass in World A.\n\nNote that an absolute or relative error of at most 10^{-3} is allowed.\n\n* * *"}, {"input": "99 1", "output": "99.0000000000\n    \n\n* * *"}, {"input": "1 100", "output": "0.0100000000"}]