output_description: Print the maximum possible sum of the digits (in base 10) of a positive
  integer not greater than N.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
attempt: from math import acos, hypot, pi
  
  
  class Point:
      def __init__(self, i, x, y):
          self.i = i
          self.x = int(x)
          self.y = int(y)
  
  
  class Line:
      def __init__(self, p1, p2):
          self.p1 = p1
          self.p2 = p2
          self.d2 = (p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2
          if p1.x == p2.x:
              self.a = 1
              self.b = 0
          else:
              self.a = p2.y - p1.y
              self.b = p1.x - p2.x
          self.c = -p1.y * self.b - p1.x * self.a
  
      def dist(self, p):
          f = self.a * p.x + self.b * p.y + self.c
          if f == 0:
              d12 = (self.p1.x - p.x) ** 2 + (self.p1.y - p.y) ** 2
              d22 = (self.p2.x - p.x) ** 2 + (self.p2.y - p.y) ** 2
              if self.d2 < max(d12, d22):
                  return None
              return 0
          if f < 0:
              return -1
          else:
              return 1
  
      def kaku(self, other):
          x = self.a * other.a + self.b * other.b
          x /= hypot(self.a, self.b) * hypot(other.a, other.b)
          return pi - acos(x)
  
  
  def make_p(n, pp):
      pids = {p.i: [] for p in pp}
      for i in range(n):
          if len(pids[i]) == 2:
              continue
          p1 = pp[i]
          for j in pids:
              if i == j or len(pids[j]) == 2:
                  continue
              p2 = pp[j]
              line = Line(p1, p2)
              ptype = {0: 0, 1: 0, -1: 0, None: 0}
              for k in pids:
                  if k == i or k == j:
                      continue
                  ptype[line.dist(pp[k])] += 1
              if ptype[None]:
                  continue
              if ptype[1] == 0 or ptype[-1] == 0:
                  pids[i].append(j)
                  pids[j].append(i)
      return pids
  
  
  def main():
      n = int(input())
      if n == 2:
          print(0.5)
          print(0.5)
          return
      pp = []
      for i in range(n):
          p = Point(i, *input().split())
          pp.append(p)
      pids = make_p(n, pp)
      prob = [0.0] * n
      for i, nei in pids.items():
          if len(nei) == 2:
              l1 = Line(pp[i], pp[nei[0]])
              l2 = Line(pp[i], pp[nei[1]])
              kaku = l1.kaku(l2)
              prob[i] += kaku / (2 * pi)
      for p in prob:
          print(p)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Find the maximum possible sum of the digits (in base 10) of a positive integer
  not greater than N.
samples: [{"input": "100", "output": "18\n    \n\nFor example, the sum of the digits in 99 is 18, which turns out to be the\nmaximum value.\n\n* * *"}, {"input": "9995", "output": "35\n    \n\nFor example, the sum of the digits in 9989 is 35, which turns out to be the\nmaximum value.\n\n* * *"}, {"input": "3141592653589793", "output": "137"}]