#include <algorithm>
#include <cstddef>
#include <fstream>
#include <iterator>
#include <tuple>
#include <utility>
#include <vector>

constexpr auto eq(double const a, double const b) noexcept -> bool
{
    constexpr double margin = 0.00001;
    return std::abs(a - b) < margin;
}

struct coord_t
{
    double x{ 0 };
    double y{ 0 };

    constexpr coord_t() noexcept = default;
    constexpr coord_t(coord_t const&) noexcept = default;
    constexpr coord_t(coord_t&&) noexcept = default;
    ~coord_t() noexcept = default;

    constexpr coord_t(double const a, double const b) noexcept
        : x{ a }
        , y{ b }
    {
    }

    auto operator=(coord_t const&) noexcept -> coord_t& = default;
    auto operator=(coord_t&&) noexcept -> coord_t& = default;
};

constexpr auto operator==(coord_t const& a, coord_t const& b) noexcept -> bool
{
    return eq(a.x, b.x) && eq(a.y, b.y);
}

constexpr auto operator<(coord_t const& a, coord_t const& b) noexcept -> bool
{
    return std::tie(a.x, a.y) < std::tie(b.x, b.y);
}

auto operator/(coord_t const& a, int const b) noexcept -> coord_t
{
    return { a.x / b, a.y / b };
}

auto operator+(coord_t const& a, coord_t const& b) noexcept -> coord_t
{
    return { a.x + b.x, a.y + b.y };
}

auto main() noexcept -> int
{

    std::ifstream f{ "patrate3.in" };
    std::ofstream g{ "patrate3.out" };

    std::vector<coord_t> points{};
    std::size_t n{ 0 };
    std::size_t count{ 0 };

    f >> n;
    points.reserve(n);

    for(std::size_t i = 0; i < n; ++i) {
        double x{ 0 };
        double y{ 0 };

        f >> x >> y;

        points.emplace_back(x, y);
    }

    std::sort(points.begin(), points.end());

    for(std::size_t i = 0; i < n - 1; ++i) {
        for(std::size_t j = i + 1; j < n; ++j) {
            auto const mid = (points[i] + points[j]) / 2;
            coord_t const distance{ mid.x - points[i].x, mid.y - points[i].y };
            coord_t const point1{ mid.x + distance.y, mid.y - distance.x };
            coord_t const point2{ mid.x - distance.y, mid.y + distance.x };

            auto from = points.begin();
            std::advance(from, i);
            auto to = points.end();

            if(std::binary_search(from, to, point1) &&
               std::binary_search(from, to, point2)) {
                ++count;
            }
        }
    }

    g << count << std::endl;
}