Language: C++

#pragma region Macros
#pragma GCC target ("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <set>
#include <map>
#include <unordered_map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>
#include <tuple>
#include <functional>

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int INF = 1'000'000'000;
const int MOD = 13;
const ll LINF = 1e18;
// repeat for 0-indexed col
#define rep(i, n) rep3(i, 0, n)
// repeat for 1-indexed col
#define rep2(i, n) rep3(i, 1, n+1)
#define rep3(i, x, n) for(ll i = x; i < (ll)(n); i++)
#define FOREACH(x, a) for(auto& (x) : (a) )

// pair
#define pii pair<int,int>
#define pll pair<ll,ll>
#define fi first
#define se second
// vector
#define pb push_back
#define eb emplace_back
#define vll vector<ll>
#define vpll vector<pll>
#define vvl(a,b) vector<vector<ll>>(a,vector<ll>(b))
#define vvl2(a,b,c) vector<vector<ll>>(a,vector<ll>(b,c))
// iterator
#define all(c) begin(c),end(c)
#define lb(c,x) distance((c).begin(),lower_bound(all(c),(x)))
#define ub(c,x) distance((c).begin(),upper_bound(all(c),(x)))
// input
#define INT(...) int __VA_ARGS__;IN(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;IN(__VA_ARGS__)
#define ULL(...) ull __VA_ARGS__;IN(__VA_ARGS__)
#define STR(...) string __VA_ARGS__;IN(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__;IN(__VA_ARGS__)
#define DBL(...) double __VA_ARGS__;IN(__VA_ARGS__)
#define LD(...) ld __VA_ARGS__;IN(__VA_ARGS__)
#define VEC(type,name,size) vector<type> name(size);IN(name)
#define VV(type,name,h,w) vector<vector<type>>name(h,vector<type>(w));IN(name)
int scan(){ return getchar(); }
void scan(int& a){ cin>>a; }
void scan(long long& a){ cin>>a; }
void scan(char &a){cin>>a;}
void scan(double &a){ cin>>a; }
void scan(long double& a){ cin>>a; }
void scan(char a[]){ scanf("%s", a); }
void scan(string& a){ cin >> a; }
template<class T> void scan(vector<T>&);
template<class T, size_t size> void scan(array<T, size>&);
template<class T, class L> void scan(pair<T, L>&);
template<class T, size_t size> void scan(T(&)[size]);
template<class T> void scan(vector<T>& a){ for(auto& i : a) scan(i); }
template<class T> void scan(deque<T>& a){ for(auto& i : a) scan(i); }
template<class T, size_t size> void scan(array<T, size>& a){ for(auto& i : a) scan(i); }
template<class T, class L> void scan(pair<T, L>& p){ scan(p.first); scan(p.second); }
template<class T, size_t size> void scan(T (&a)[size]){ for(auto& i : a) scan(i); }
template<class T> void scan(T& a){ cin >> a; }
void IN(){}
template <class Head, class... Tail>    void IN(Head& head, Tail&... tail){ scan(head); IN(tail...); }
// print
void print(){ putchar(' '); }
void print(bool a){ printf("%d", a); }
void print(int a){ printf("%d", a); }
void print(unsigned a){ printf("%u", a); }
void print(long long a){ printf("%lld", a); }
void print(unsigned long long a){ printf("%llu", a); }
void print(char a){ printf("%c", a); }
void print(char a[]){ printf("%s", a); }
void print(float a){ printf("%.15f", a); }
void print(double a){ printf("%.15f", a); }
void print(long double a){ printf("%.15Lf", a); }
void print(const string& a){ for(auto&& i : a) print(i); }
template<class T>               void print(const vector<T>&);
template<class T, size_t size>  void print(const array<T, size>&);
template<class T, class L>      void print(const pair<T, L>& p);
template<class T, size_t size>  void print(const T (&)[size]);
template<class T>               void print(const vector<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar('\n'); print(*i); } }
template<class T>               void print(const deque<T>& a){ if(a.empty()) return; print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar('\n'); print(*i); } }
template<class T, size_t size>  void print(const array<T, size>& a){ print(a[0]); for(auto i = a.begin(); ++i != a.end(); ){ putchar('\n'); print(*i); } }
template<class T, class L>      void print(const pair<T, L>& p){ print(p.first); putchar(' '); print(p.second); }
template<class T, size_t size>  void print(const T (&a)[size]){ print(a[0]); for(auto i = a; ++i != end(a); ){ putchar(' '); print(*i); } }
template<class T>               void print(const T& a){ cout << a; }
int out(){ putchar('\n'); return 0; }
template<class T>                   int out(const T& t){ print(t); putchar('\n'); return 0; }
template<class Head, class... Tail> int out(const Head& head, const Tail&... tail){ print(head); putchar(' '); out(tail...); return 0; }

// convinience
template<class T> void UNIQUE(vector<T> &x){sort(all(x));x.erase(unique(all(x)),x.end());}
vector<pll> factor(ll x){ vector<pll> ans; for(ll i = 2; i * i <= x; i++) if(x % i == 0){ ans.push_back({i, 1}); while((x /= i) % i == 0) ans.back().second++; } if(x != 1) ans.push_back({x, 1}); return ans; }
vector<int> divisor(int x){ vector<int> ans; for(int i=1;i*i<=x;i++)if(x%i==0){ans.pb(i);if(i*i!=x)ans.pb(x/i);} return ans;}
int popcount(ll x){return __builtin_popcountll(x);}
#define dump(x) cout<<#x<<"="<<x<<endl

#pragma endregion

// mod
template <std::uint_fast64_t Modulus> class modint {
  using u64 = std::uint_fast64_t;

public:
  u64 a;

  constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
  constexpr u64 &value() noexcept { return a; }
  constexpr const u64 &value() const noexcept { return a; }
  constexpr modint operator+(const modint rhs) const noexcept {
    return modint(*this) += rhs;
  }
  constexpr modint operator-(const modint rhs) const noexcept {
    return modint(*this) -= rhs;
  }
  constexpr modint operator*(const modint rhs) const noexcept {
    return modint(*this) *= rhs;
  }
  constexpr modint operator/(const modint rhs) const noexcept {
    return modint(*this) /= rhs;
  }
  constexpr modint &operator+=(const modint rhs) noexcept {
    a += rhs.a;
    if (a >= Modulus) {
      a -= Modulus;
    }
    return *this;
  }
  constexpr modint &operator-=(const modint rhs) noexcept {
    if (a < rhs.a) {
      a += Modulus;
    }
    a -= rhs.a;
    return *this;
  }
  constexpr modint &operator*=(const modint rhs) noexcept {
    a = a * rhs.a % Modulus;
    return *this;
  }
  constexpr modint &operator/=(modint rhs) noexcept {
    u64 exp = Modulus - 2;
    while (exp) {
      if (exp % 2) {
        *this *= rhs;
      }
      rhs *= rhs;
      exp /= 2;
    }
    return *this;
  }
};
#define mint modint<MOD>
const int N=100;
mint inv[N],fac[N],invfac[N];   // mod MODの逆元, 階乗, 階乗の逆元
void calc_inv(){
    inv[1]=1;
    rep3(i,2,N){ // 2以上N-1以下
        inv[i]=inv[MOD%i]*(MOD-MOD/i);
    }
    return;
}
void calc_product(){
    fac[0]=fac[1]=1;
    invfac[0]=invfac[1]=1;
    rep3(i,2,N){ // 2以上N-1以下
        fac[i]=fac[i-1]*i;
        invfac[i]=inv[i]*invfac[i-1];
    }
    return;
}

mint cmb(int a,int b){
    if(a<b)return 0;
    if(a<0||b<0)return 0;
    return {fac[a]*invfac[b]*invfac[a-b]};
}
mint modpow(mint x,ll n){
    if(n==0) return 1;
    mint res=modpow(x*x,n/2);
    if(n&1) res=res*x;
    return res;
}

// nPnの順列に対して処理を実行する
void foreach_permutation(int n, std::function<void(int *)> f) {
  int indexes[n];
  for (int i = 0; i < n; i++) indexes[i] = i;
  do {
    f(indexes);
  } while (std::next_permutation(indexes, indexes + n));
}

void recursive_comb(int *indexes, int s, int rest, std::function<void(int *)> f) {
  if (rest == 0) {
    f(indexes);
  } else {
    if (s < 0) return;
    recursive_comb(indexes, s - 1, rest, f);
    indexes[rest - 1] = s;
    recursive_comb(indexes, s - 1, rest - 1, f);
  }
}

// nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(int *)> f) {
  int indexes[k];
  recursive_comb(indexes, n - 1, k, f);
}

int main() {
    std::cout << std::fixed << std::setprecision(15);
    INT(n);
    VEC(pll, ab, n);
    VEC(pll, cd, n);
    rep(i,n) {
        double rx = ab[i].fi;
        double ry = ab[i].se;
        double bx = cd[i].fi;
        double by = cd[i].se;
        ab[i] = {(rx+ry)/sqrt(2), (-rx+ry)/sqrt(2)};
        cd[i] = {(bx+by)/sqrt(2), (-bx+by)/sqrt(2)};
    }
    // x座標だけ見る
    vector<double> r,b;
    vector<bool> paired(100, false);
    rep(i,n){
        r.pb(ab[i].fi);
        b.pb(cd[i].fi);
    }
    sort(all(r));
    sort(all(b));
    int res = 0;
    rep(i,n){
        int k = 0;
        // dump(i);
        while(k<n){
            // dump(k);
            // dump(r[i]);
            // dump(b[k]);
            double x = b[i] - r[i];
            double y = abs(cd[i].se - ab[i].se);
            if (paired[k] == false && r[i] + 10e-4 < b[k] && y < x) {
                res++;
                paired[k] = true;
                // dump(res);
                break;
            }
            k++;
        }
        // out();
    }
    print(res);
    // print(r);
    // out();out();
    // print(b);
}


Compiler output:
a.cc:130:11: error: 'std::uint_fast64_t' has not been declared
  130 | template <std::uint_fast64_t Modulus> class modint {
      |           ^~~
a.cc:131:20: error: 'uint_fast64_t' in namespace 'std' does not name a type
  131 |   using u64 = std::uint_fast64_t;
      |                    ^~~~~~~~~~~~~
a.cc:33:1: note: 'std::uint_fast64_t' is defined in header '<cstdint>'; this is probably fixable by adding '#include <cstdint>'
   32 | #include <functional>
  +++ |+#include <cstdint>
   33 | 
a.cc:134:3: error: 'u64' does not name a type
  134 |   u64 a;
      |   ^~~
a.cc:136:26: error: 'u64' does not name a type
  136 |   constexpr modint(const u64 x = 0) noexcept : a(x % Modulus) {}
      |                          ^~~
a.cc:137:13: error: 'u64' does not name a type
  137 |   constexpr u64 &value() noexcept { return a; }
      |             ^~~
a.cc:138:19: error: 'u64' does not name a type
  138 |   constexpr const u64 &value() const noexcept { return a; }
      |                   ^~~