output_description: Print the probability that Snuke wins the game. The output is considered
  correct when the absolute or relative error is at most 10^{-9}.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
attempt: # for #!/usr/bin/env python
  import os
  import sys
  from io import BytesIO, IOBase
  
  
  # region fastio
  
  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")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  
  # endregion
  class union_find:
      def __init__(self, n):
          self.n = n
          self.rank = [0] * n
          self.parent = [int(j) for j in range(n)]
  
      def union(self, i, j):
          i = self.find(i)
          j = self.find(j)
          if self.rank[i] == self.rank[j]:
              self.parent[i] = j
              self.rank[j] += 1
  
          elif self.rank[i] > self.rank[j]:
              self.parent[j] = i
          else:
              self.parent[i] = j
  
      def find(self, i):
          temp = i
          if self.parent[temp] != temp:
              self.parent[temp] = self.find(self.parent[temp])
          return self.parent[temp]
  
  
  from math import log2, ceil
  
  
  def main():
      # Enter your code here. Read input from STDIN. Print output to STDOUT
      n, k = [int(j) for j in input().split()]
      a = max(n - k + 1, 0)
      for x in range(1, min(k, n + 1)):
          tmp = (1 / 2) ** ceil(log2(k / x))
          # print(tmp,x,ceil(log2(k/x)))
          a += tmp
      print(a / n)
      # if
  
      # s[k-1] = s[k-1].lower()
      # print("".join(s))
  
      # ls[i+1]=
      # base = f
      # print()
  
      # l = [int(j) for j in input().split()]
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Snuke has a fair N-sided die that shows the integers from 1 to N with equal
  probability and a fair coin. He will play the following game with them:
  
    1. Throw the die. The current score is the result of the die.
    2. As long as the score is between 1 and K-1 (inclusive), keep flipping the coin. The score is doubled each time the coin lands heads up, and the score becomes 0 if the coin lands tails up.
    3. The game ends when the score becomes 0 or becomes K or above. Snuke wins if the score is K or above, and loses if the score is 0.
  
  You are given N and K. Find the probability that Snuke wins the game.
samples: [{"input": "3 10", "output": "0.145833333333\n    \n\n  * If the die shows 1, Snuke needs to get four consecutive heads from four coin flips to obtain a score of 10 or above. The probability of this happening is \\frac{1}{3} \\times (\\frac{1}{2})^4 = \\frac{1}{48}.\n  * If the die shows 2, Snuke needs to get three consecutive heads from three coin flips to obtain a score of 10 or above. The probability of this happening is \\frac{1}{3} \\times (\\frac{1}{2})^3 = \\frac{1}{24}.\n  * If the die shows 3, Snuke needs to get two consecutive heads from two coin flips to obtain a score of 10 or above. The probability of this happening is \\frac{1}{3} \\times (\\frac{1}{2})^2 = \\frac{1}{12}.\n\nThus, the probability that Snuke wins is \\frac{1}{48} + \\frac{1}{24} +\n\\frac{1}{12} = \\frac{7}{48} \\simeq 0.1458333333.\n\n* * *"}, {"input": "100000 5", "output": "0.999973749998"}]