import random
import heapq

heap = []
subseqs = {}
prevElem = []
bestL = 0


def merge(x, p, rec):
  length1 = rec[1][p][0]
  length2 = rec[0][x][0]
  length = length1 + 1 + length2
  begin = rec[1][p][1]
  end = rec[0][x][1]
  del rec[0][x]
  del rec[1][p]
  rec[0][begin] = (length, end)
  rec[1][end] = (length, begin)


def growLeft(x, p, rec):
  length = 1 + rec[0][x][0]
  end = rec[0][x][1]
  del rec[0][x]
  rec[0][p] = (length, end)
  rec[1][end] = (length, p)


def growRight(x, p, rec):
  length = rec[1][p][0] + 1
  begin = rec[1][p][1]
  del rec[1][p]
  rec[0][begin] = (length, x)
  rec[1][x] = (length, begin)


def insert(x, p, rec):
  rec[0][p] = (1, x)
  rec[1][x] = (1, p)


def update(x, p, d):
  if d not in subseqs:
    heapq.heappush(heap, d)
    subseqs[d] = ({},{})

  rec = subseqs[d]

  if x in rec[0]:
    if p in rec[1]:
      merge(x, p, rec)
    else:
      growLeft(x, p, rec)
  else:
    if p in rec[1]:
      growRight(x, p, rec)
    else:
      insert(x, p, rec)


def init(src):
  prevElem.insert(0, None)

  for i in xrange(1, len(src)):
    prevElem.insert(i, i-1)
    d = src[i] - src[i-1]
    update(i, i-1, d)


def chooseTheBest(d):
  global bestL
  l = max(list(zip(*subseqs[d][0].values()))[0])
  bestL = max(bestL, l)


def updateIndexes(src, rec):
  for end in rec[1].keys():
    l = rec[1][end][0]
    i = end

    for n in xrange(l):
      link = prevElem[i]

      if link != 0:
        prevElem[i] -= 1
        d = src[i] - src[prevElem[i]]
        update(i, prevElem[i], d)
        i = link


def findLESS(src):
  global bestL
  init(src)

  while len(heap) > 0:
    d = heapq.heappop(heap)
    chooseTheBest(d)
    updateIndexes(src, subseqs[d])
    del subseqs[d]

    if bestL * d > s[-1] - s[0]:
      break

  return bestL


a = [random.randint(0,40000) for r in xrange(28000)]
s = sorted(list(set(a)))

print(findLESS(s) + 1)