EPS = 1e-5

include Math

k = 0
loop do
  n = gets.to_i
  break if n == 0
  points = (1..n).map { gets.split.map(&:to_i) }
  best = 0

  points.combination(2).each do |p1, p2|
    x1, y1 = p1
    x2, y2 = p2
    # p [x1, y1, x2, y2]
    t = atan2(y2 - y1, x2 - x1)
    shifted = points.map {|x, y| [x - x1, y - y1] }
    normalized = shifted.map {|x, y| [cos(-t) * x - sin(-t) * y, sin(-t) * x + cos(-t) * y] }

    zero_point_type = {}

    (normalized + [normalized[0]]).each_cons(2) do |p1, p2|
      x1, y1 = p1
      x2, y2 = p2
      next if y1.abs < EPS || y2.abs < EPS
      next if y1 * y2 > 0
      if (x1 - x2).abs < EPS
        x = x1
      else
        x = (y2 * x1 - y1 * x2) / (y2 - y1)
      end
      zero_point_type[x] = :VERTICAL
    end

    (normalized + normalized[0..1]).each_cons(3) do |p0, p1, p2|
      x0, y0 = p0
      x1, y1 = p1
      x2, y2 = p2
      # p [p0, p1, p2]
      if y1.abs >= EPS
        next
      end
      if y0.abs < EPS && y2.abs < EPS
        next
      end

      if y0.abs < EPS
        if x0 < x1
          if y2 > EPS
            zero_point_type[x1] = :RIGHT_UP
          else
            zero_point_type[x1] = :RIGHT_DOWN
          end
        else
          if y2 > EPS
            zero_point_type[x1] = :DOWN_RIGHT
          else
            zero_point_type[x1] = :UP_RIGHT
          end
        end
      elsif y2.abs < EPS
        if x2 < x1
          if y0 > EPS
            zero_point_type[x1] = :RIGHT_UP
          else
            zero_point_type[x1] = :RIGHT_DOWN
          end
        else
          if y0 > EPS
            zero_point_type[x1] = :DOWN_RIGHT
          else
            zero_point_type[x1] = :UP_RIGHT
          end
        end
      elsif y0 * y2 < EPS
        zero_point_type[x1] = :VERTICAL
      end
    end

    # p zero_point_type
    
    state = :OUT
    from = nil
    prev_state = nil
    prev_type = nil

    zero_point_type.keys.sort.each do |x|
      type = zero_point_type[x]

      enter = proc do
        state = :IN
        from = x
      end

      leave = proc do
        state = :OUT
        len = x - from
        best = len if len > best
      end

      case type
      when :VERTICAL
        state == :OUT ? enter[] : leave[]
      when :UP_RIGHT
        prev_state = state
        enter [] if state == :OUT
        prev_type = type
      when :DOWN_RIGHT
        prev_state = state
        enter [] if state == :OUT
        prev_type = type
      when :RIGHT_UP
        if prev_type == :UP_RIGHT
          leave[] if prev_state == :IN
        else
          leave[] if prev_state == :OUT
        end
      when :RIGHT_DOWN
        if prev_type == :DOWN_RIGHT
          leave[] if prev_state == :IN
        else
          leave[] if prev_state == :OUT
        end
      end

    end

    # p best
    # puts
  end

  puts "Case #{k += 1}: #{best}"
end

