#define FOLD__SCOPE



#ifdef  FOLD__SCOPE  /// includes



#include <cstddef>

#include <vector>

#include <algorithm>

#include <fstream>

#include <sstream>



#endif

#ifdef  FOLD__SCOPE  /// typedefs



typedef  ::std::size_t     stsz;

typedef  long long signed  stws;



#endif

#ifdef  FOLD__SCOPE  /// point



struct ptst

{

  stws  x;

  stws  y;



  ptst () noexcept : x(0), y(0) {  }



};



#endif

#ifdef  FOLD__SCOPE  /// comparator



bool

dnlt

(

  ptst const  & A

, ptst const  & B

)

noexcept

{

  return (A.y == B.y) ? (A.x > B.x) : (A.y > B.y);

}





#endif

#ifdef  FOLD__SCOPE  /// typedefs



typedef  ::std::vector < ptst >  vtpt;



typedef  ::std::ifstream      stis;

typedef  ::std::ofstream      stos;

typedef  ::std::stringstream  stss;



typedef  ::std::string  stsg;





#endif

#ifdef  FOLD__SCOPE  /// input



bool

read_input

(

  vtpt  & P

)

{

  stsz  const min_n = 1;

  stsz  const max_n = 1000;

  stws  const min_v = -99999999;

  stws  const max_v =  99999999;



  stis  is ("patrate3.in");

  stsg  il;

  stss  ss;



  getline(is, il);

  ss << il << '\n';



  stsz  n = 0;

  ss >> n;



  bool  ok = false;



  ok = ( (min_n <= n) && (max_n >= n)  );



  if ( ! ok  )

  {

    /// Invalid input.

    return false;

  }



  vtpt  p(n);



  stsz  i = 0;

  stsz  s = 0;

  stws  x = 0;

  stws  y = 0;



  ptst  z;



  for ( i = 0; n > i; ++ i  )

  {

    getline(is, il);





    s = il.find('.');



    ok = ( ( ::std::string::npos) != s );



    if ( ! ok  )

    {

      /// Failure.  The called logged.

      return false;

    }



    il.erase(s, 1);





    s = il.find('.');



    ok = ( ( ::std::string::npos) != s );



    if ( ! ok  )

    {

      /// Failure.  The called logged.

      return false;

    }



    il.erase(s, 1);





    ss << il << '\n';



    ss >> x >> y;



    ok = ( (min_v <= x) && (max_v >= x) &&

           (min_v <= y) && (max_v >= y)     );



    if ( ! ok  )

    {

      /// Invalid input.

      return false;

    }



    z.x = x;

    z.y = y;



    p[i] = z;



  }



  ::std::sort(p.begin(), p.end(), dnlt);



  for ( i = 0; n-1 > i; ++ i  )

  {

    ok = (  ( p[i].x != p[1+i].x) || (p[i].y != p[1+i].y)  );



    if ( ! ok  )

    {

      /// Invalid input.

      return false;

    }



  }



  /// Excelent!



  P.swap(p);



  return true;



}



#endif

#ifdef  FOLD__SCOPE  /// search



bool

side

(

  vtpt  const      & P

, stsz         const i

, stsz         const j

)

{



  if ( ( P[i].y >  P[j].y ) &&

       ( P[i].x <= P[j].x )     )

  {

    return false;

  }





  ptst const  & A = P[i];

  ptst const  & B = P[j];



  stws  const xD = (A.x) + ((A.y) - (B.y));

  stws  const yD = (A.y) + ((B.x) - (A.x));



  ptst  D;

  D.x = xD;

  D.y = yD;





  bool  found = false;



  found = ::std::binary_search(P.begin(), P.end(), D, dnlt);



  if ( ! found  )

  {

    return false;

  }





  stws  const xC = (D.x) + ((D.y) - (A.y));

  stws  const yC = (D.y) + ((A.x) - (D.x));



  ptst  C;

  C.x = xC;

  C.y = yC;



  found = ::std::binary_search(P.begin(), P.end(), C, dnlt);



  return found;



}



#endif

#ifdef  FOLD__SCOPE  /// solve



stsz

count

(

  vtpt const  & P

)

{

  stsz  const n = P.size();



  stsz  i = 0;

  stsz  j = 0;

  bool  s = 0;

  stsz  k = 0;



  for ( i = 0; n > i; ++ i )

  {

    for ( j = 1 + i; n > j; ++ j  )

    {

      s = side(P, i, j);

      k = s ? (1 + k) : k;

    }



  }



  return k;



}



#endif

#ifdef  FOLD__SCOPE  /// output



void

write_output

(

  stsz  const answer

)

{

  stos  os("patrate3.out");

  os << answer << '\n';

}



#endif

#ifdef  FOLD__SCOPE  /// demo



bool

demo

()

{

  vtpt  P;

  stsz  a = 0;



  bool  ok = false;



  ok = read_input(P);



  if ( ! ok  )

  {

    return false;

  }



  a = count(P);



  write_output(a);



  return true;



}



#endif

#ifdef  FOLD__SCOPE  /// main



int

main

()

{

  int  status = 2;



  try

  {

    bool  const ok = demo();

    status = ( ok ? 0 : 1 );

  }

  catch ( ... )

  {

    status = 3;

  }



  return status;



}



#endif