(* O(n) *)
let list_to_array n a xs =
  let res = Array.make n a in
  List.iteri (fun i x -> res.(i) <- x) xs;
  res

(* O(n * log(n)) (n = |xs|) *)
let unique_info n xs =
  if n <= 0 then
    [], 0
  else
    let sorted_xs = list_to_array n 0 xs in
    Array.sort compare sorted_xs;
    let last = sorted_xs.(n - 1) in
    let sofar, count, _ = Array.fold_right
      (fun x (sofar, count, prev) ->
        if x <> prev then
          x :: sofar, count + 1, x
        else
          sofar, count, x)
      sorted_xs
      ([last], 1, last)
    in
      sofar, count

(* O(n * log(n)) (n = |xs|) *)
let unique_count n xs = snd (unique_info n xs)

(* O(n * log(n)) *)
let solve n ds = unique_count n ds

let fold_int f a n =
  let rec fold f a i n =
    if i >= n then
      a
    else
      fold f (f a i) (i + 1) n
  in
    fold f a 0 n

let read_ints n =
  fold_int
    (fun sofar _ -> read_int () :: sofar)
    []
    n |> List.rev

let _ =
  let n = read_int () in
  let ds = read_ints n in
  solve n ds |> string_of_int |> print_endline