Problem:
シールの重なり

1 辺の長さが 10 の正方形の折り紙に半径 1 の円形のシールを n 枚貼ります。シールは重ねて貼ることができます。シールを貼る位置の座標を読み込んで、折り紙上でもっとも多くシールが重なっている場所(シールが１枚だけでも"重なっている"とする)でのシールの枚数を出力するプログラムを作成してください。

折り紙の左下を原点とした x, y 座標を与えます。この x, y を円の中心としてシールを貼ることとします。円の中心が折り紙の外に出ることはありません。また、同一座標に複数のシールが貼られることはありません。

Input

複数のデータセットが与えられます。各データセットは以下のような形式で与えられます。

n
x1,y1
x2,y2
:
xn,yn

１行目にシールの枚数 n (0 ≤ 100) が与えられます。続く n 行に、各シールの中心座標が与えられます。
xi, yi は i 枚目のシールの中心の x 座標と y 座標を表します。各値は小数点以下最大 6 桁までの数字を含む実数で与えられます。

n が 0 のとき、入力の最後とします。データセットの数は 50 を超えません。

Output

各データセットに対し、折り紙上で最も多くシールが重なっている場所でのシールの枚数（整数）を出力して下さい。

Sample Input

15
3.14979,8.51743
2.39506,3.84915
2.68432,5.39095
5.61904,9.16332
7.85653,4.75593
2.84021,5.41511
1.79500,8.59211
7.55389,8.17604
4.70665,4.66125
1.63470,4.42538
7.34959,4.61981
5.09003,8.11122
5.24373,1.30066
0.13517,1.83659
7.57313,1.58150
0

Output for the Sample Input

4

Hint

入力例のようにシールを貼った図です。円はシール、数字は入力例の行数を表しています。
点(2.3,4.6)では、入力例の 2 行目、3 行目、6 行目、10 行目の 4 枚のシールが重なっています。

6 と 9 のおのおのの中心の距離は 2.01293 なので、シールは重なっていません。1 と 12 のおのおのの中心の距離は 1.98231 なので、シールは重なっています。

２つの円が接しているとき（おのおのの中心の距離が 2 のとき）は、重なっているものとします。

Solution in Scala (judge verdict: Wrong Answer)

import java.util

import scala.collection.mutable

object Main extends App {
  type Radian = Double
  import scala.math.{sin, cos, sqrt, Pi, acos}
  import scala.io.StdIn.{readLine}
  import Main.Angle._
  loop(readLine().toInt)
  def loop(n:Int):Unit = {
    if (n == 0) return
    val circles = Array.tabulate(n) { _ ⇒
      val Array(x, y) = readLine().split(',').map(_.toDouble)
      Circle(Coordinate(x, y))
    }
    println(circles.map { circle ⇒
      val flag = Flag.Empty
      val stack = mutable.Stack[EndPoint]()
      var overlapped: Int = 0
      for (i ← 0 until circles.size) {
        if (circle == circles(i)) {
          overlapped += 1
        } else {
          circle.CrossPoint(circles(i)) match {
            case Some((begin, end)) ⇒
              stack.push(EndPoint(Begin, i, begin), EndPoint(End, i, end))
            case _ ⇒
          }
        }
      }
      var max = 0
      var current = overlapped
      stack.sortBy { case EndPoint(_, _, a) ⇒ a }.foreach {
        case EndPoint(Begin, id, _) ⇒
          flag.SetFlag(id)
          current += 1
        case EndPoint(_, id, _) if flag.IsSet(id) ⇒
          flag.UnsetFlag(id)
          if (max < current) max = current
          current -= 1
        case EndPoint(_, _, _) ⇒
          if (max < current) max = current
          max += 1
      }
      if (max < current) max = current
      max
    }.max)
    loop(readLine().toInt)
  }
  sealed trait EndType
  object Begin extends EndType{
    override def toString: String = "Begin"
  }
  object End extends EndType{
    override def toString: String = "End"
  }
  case class EndPoint(endType: EndType, id:Int, angle: Angle)
  case class Coordinate(x:Double, y:Double){
    def +(other:Coordinate):Coordinate = Coordinate(x + other.x, y + other.y)
    def -(other:Coordinate):Coordinate = Coordinate(x - other.x, y - other.y)
    def Length:Double = sqrt(x * x + y * y)

    override def toString: String = s"($x, $y)"
    override def equals(obj: scala.Any): Boolean = {
      obj match{
        case Coordinate(a, b) ⇒ x == a && y == b
        case _ ⇒ false
      }
    }
  }
  implicit class ImplicitCoordinateManipulator(val coordinate: Coordinate){
    def Fmap(transformer:Double => Double):Coordinate = Coordinate(transformer(coordinate.x), transformer(coordinate.y))
    def *(other:Int):Coordinate = Coordinate(coordinate.x * other, coordinate.y * other)
    def /(other:Int):Coordinate = Coordinate(coordinate.x / other, coordinate.y / other)
  }
  class Angle private (val Sin:Double, val Cos:Double) extends Ordered[Angle]{
    def +(other:Angle):Angle = new Angle(Sin * other.Cos + Cos * other.Sin, Cos * other.Cos - Sin * other.Sin)
    def -(other:Angle):Angle = new Angle(Sin * other.Cos - Cos * other.Sin, Cos * other.Cos + Sin * other.Sin)
    private def ToRadian:Radian = if (Sin >= 0) acos(Cos) else 2 * Pi - acos(Cos)
    override def compare(that: Angle): Int = ToRadian.compareTo(that.ToRadian)

    override def toString: String = s"${ToRadian * 180 / Pi}"
  }
  object Angle{
    implicit class ImplicitCoordinateAngleConverter(val coordinate:Coordinate){
      def ToAngle:Angle = new Angle(coordinate.y / coordinate.Length, coordinate.x / coordinate.Length)
    }
    implicit class ImplicitAngleCoordinateConverter(val angle: Angle){
      def ToCoordinate:Coordinate = Coordinate(angle.Cos, angle.Sin)
    }
    implicit class ImplicitRadianToAngleConverter(val rad:Radian){
      def ToAngle:Angle = new Angle(sin(rad), cos(rad))
    }
  }
  case class Circle(center:Coordinate){
    def CrossPoint(other:Circle):Option[(Angle, Angle)] = {
      (center - other.center).Length match{
        case len if len >= 2 => None
        case len =>
          val angle = (other.center - center).ToAngle
          val diff = acos(len / 2).ToAngle
          val posA = angle - diff
          val posB = angle + diff
          Some((posA, posB))
      }
    }
  }
  class Flag private (private var first:Int = 0, private var second:Int = 0, private var third:Int = 0, private var forth:Int = 0){
    def SetFlag(n:Int):Unit = {
      n match{
        case _ if n > 96 ⇒ forth |= 1 << (n - 96)
        case _ if n > 64 ⇒ third |= 1 << (n - 64)
        case _ if n > 32 ⇒ second |= 1 << (n - 32)
        case _ ⇒ first |= 1 << n
      }
    }
    def IsSet(n:Int):Boolean = {
      n match{
        case _ if n > 96 ⇒ (forth & (1 << (n - 96))) != 0
        case _ if n > 64 ⇒ (third & (1 << (n - 64))) != 0
        case _ if n > 32 ⇒ (second & (1 << (n - 32))) != 0
        case _ ⇒ (first & (1 << n)) != 0
      }
    }
    def UnsetFlag(n:Int):Unit = {
      n match{
        case _ if n > 96 ⇒ forth &= ~(1 << (n - 96))
        case _ if n > 64 ⇒ third &= ~(1 << (n - 64))
        case _ if n > 32 ⇒ second &= ~(1 << (n - 32))
        case _ ⇒ first &= ~(1 << n)
      }
    }
  }
  object Flag{
    def Empty= new Flag()
  }
}