#include <iostream>
#include <map>
#include <set>
#include <cmath>
#include <random>
#include <tuple>
#include <chrono>
 
//boilerplate point/vector class
template<typename T>
struct Point
{
	T x, y;
	Point(T x = T{}, T y = T{}) noexcept
	: x{x}
	, y{y}
	{
	}
	Point(Point const &) noexcept = default;
	Point(Point &&) noexcept = default;
	Point &operator=(Point const &) noexcept = default;
	Point &operator=(Point &&) noexcept = default;
 
	template<typename U>
	Point &operator*=(U const &u) noexcept
	{
		x = static_cast<T>(x*u);
		y = static_cast<T>(y*u);
		return *this;
	}
	template<typename U>
	friend Point operator*(Point const &p, U const &u) noexcept
	{
		return Point{p} *= u;
	}
	template<typename U>
	friend Point operator*(U const &u, Point const &p) noexcept
	{
		return Point{p} *= u;
	}
	template<typename U>
	Point &operator/=(U const &u) noexcept
	{
		x = static_cast<T>(x/u);
		y = static_cast<T>(y/u);
		return *this;
	}
	template<typename U>
	friend Point operator/(Point const &p, U const &u) noexcept
	{
		return Point{p} /= u;
	}
	template<typename U>
	friend Point operator/(U const &u, Point const &p) noexcept
	{
		return Point{p} /= u;
	}
	Point &operator+=(Point const &p) noexcept
	{
		x += p.x;
		y += p.y;
		return *this;
	}
	friend Point operator+(Point const &a, Point const &b) noexcept
	{
		return Point{a} += b;
	}
	Point &operator-=(Point const &p) noexcept
	{
		x -= p.x;
		y -= p.y;
		return *this;
	}
	friend Point operator-(Point const &a, Point const &b) noexcept
	{
		return Point{a} -= b;
	}
 
	friend bool operator==(Point const &a, Point const &b) noexcept
	{
		return std::tie(a.x, a.y) == std::tie(b.x, b.y);
	}
	friend bool operator<(Point const &a, Point const &b) noexcept
	{
		return std::tie(a.x, a.y) < std::tie(b.x, b.y);
	}
 
	friend std::ostream &operator<<(std::ostream &o, Point const &p) noexcept
	{
		return o << '(' << p.x << ", " << p.y << ')';
	}
};
 
using real_point = Point<double>;
using int_point = Point<long long>;
 
int_point cast(real_point const &p)
{
	return {static_cast<long long>(std::floor(p.x)), static_cast<long long>(std::floor(p.y))};
}
 
int main()
{
	std::size_t num_points;
	std::cin >> num_points;
	double radius;
	std::cin >> radius;
 
	std::mt19937 gen {std::random_device{}()};
	std::uniform_real_distribution<double> dist {-radius, radius};
 
	std::set<real_point> points;
	while(points.size() < num_points)
	{
		points.emplace(dist(gen), dist(gen));
	}
 
	std::multimap<int_point, real_point> grid;
	for(auto const &p : points)
	{
		grid.emplace(cast(p), p);
	}
 
	long long r_min = static_cast<long long>(std::floor(-radius*2.0));
	long long r_max = static_cast<long long>(std::ceil(radius*2.0));
	std::set<std::set<real_point>> solutions;
	auto start = std::chrono::high_resolution_clock::now();
	{
		for(auto it = std::begin(grid); it != std::end(grid); ++it)
		{
			auto const &a = it->second;
			auto jt = it;
			for(++jt; jt != std::end(grid); ++jt)
			{
				auto const &b = jt->second;
				auto slope = b - a;
				auto const abs = std::sqrt(slope.x*slope.x + slope.y*slope.y);
				slope /= abs;
 
				std::set<real_point> coincidences;
				coincidences.emplace(a);
				coincidences.emplace(b);
				for(auto r = r_min; r < r_max; ++r)
				{
					auto sector = grid.equal_range(cast(a + slope*r));
					for(auto kt = sector.first; kt != sector.second; ++kt)
					{
						auto const &c = kt->second;
						if(c == a || c == b)
						{
							continue;
						}
						auto slope2 = c - a;
						auto const abs2 = std::sqrt(slope2.x*slope2.x + slope2.y*slope2.y);
						slope2 /= abs2;
						slope2 -= slope;
						if(std::abs(slope2.x) < 0.0001 && std::abs(slope2.y) < 0.0001)
						{
							coincidences.emplace(c);
						}
					}
				}
				if(coincidences.size() >= 4)
				{
					solutions.emplace(std::move(coincidences));
				}
			}
		}
	}
	auto end = std::chrono::high_resolution_clock::now();
	std::chrono::duration<double> diff = end - start;
	std::cout << std::endl << "Time spent searching: " << diff.count() << 's' << std::endl;
	for(auto const &coincidences : solutions)
	{
		for(auto const &p : coincidences)
		{
			std::cout << p << " ";
		}
		std::cout << std::endl;
	}
}
 

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

NTAwCjEwCg==

500
10