Language: C++

#ifdef MY_LOCAL
#define MY_NAMESPACE(ns) namespace ns {
#define MY_NAMESPACE_    }
#define MY_DEBUG(s)      s
#else
#define MY_NAMESPACE(ns) 
#define MY_NAMESPACE_    
#define MY_DEBUG(s)      
#endif

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

#define EPS (1e-7)
#define IINF ((int)1e9)
#define PI (acos(-1))

namespace
{
// int       - 4 bytes: -0.2e10 to 0.2e10 (-2,147,483,648 to 2,147,483,647)
// long long - 8 bytes: -0.9e19 to 0.9e19
//
// a double loop of 0.1e5 x 0.1e5 doesn't finish in 2 sec
// the limitation is said to be 0.1e8

int get_pi()
{
	double x = PI;
	return 0;
}

ll gcd(ll a, ll b)
{
	if (a < b)
		swap(a, b);
	if (b == 0)
		return a;
	return gcd(b, a % b);
}

ll extgcd(ll a, ll b, ll& x, ll& y)  // solve (x, y) which satisfies ax+by=gcd(a,b).
{
	if (a < b)
		return extgcd(b, a, y, x);

	if (b == 0)
	{
		x = 1;
		y = 0;  // can be any value
		return a;
	}

	ll g = extgcd(b, a % b, y, x);
	y -= (a / b) * x;
	return g;
}

ll modinv(ll a, ll mod)  // a and mod must be mutually prime
{
	ll x, y;
	ll g = extgcd(a, mod, x, y);
	x %= mod;
	x += mod;  // x may be negative
	x %= mod;
	return x;
}

ll modpow(ll base, ll exponent, ll mod)
{
	ll retval = 1;
	while (exponent > 0)
	{
		if (exponent % 2)
			retval = (retval * base) % mod;
		exponent /= 2;
		base = (base * base) % mod;
	}
	return retval;
}

class ModComb
{
public:
	ModComb(int max_n, ll mod) : m_mod(mod)  // mod and any i (1<i<=max_n) must be mutually prime. in reality mod must be a prime number and mod>max_n
	{
		m_fac.resize(max_n + 1);
		m_inv.resize(max_n + 1);
		m_fin.resize(max_n + 1);
		m_fac[0] = 1;
		m_fac[1] = 1;
		m_inv[0] = 1;
		m_inv[1] = 1;
		m_fin[0] = 1;
		m_fin[1] = 1;
		for (int i = 2; i <= max_n; i++)
		{
			m_fac[i] = m_fac[i - 1] * i % mod;
			m_inv[i] = mod - m_inv[mod % i] * (mod / i) % mod;
			m_fin[i] = m_fin[i - 1] * m_inv[i] % mod;
		}
	}

	ll v(int n, int k)
	{
		if (n < 0 || k < 0)
			return 0;
		if (n < k)
			return 0;
		return m_fac[n] * (m_inv[k] * m_fin[n - k] % m_mod) % m_mod;
	}

private:
	ll m_mod;
	vector<ll> m_fac;  // factorial
	vector<ll> m_inv;  // inverse element
	vector<ll> m_fin;  // factorial of inverse
};

class HashPair
{
public:
	template<class T1, class T2>
	size_t operator()(const pair<T1, T2>& p) const
	{
		auto hash1 = hash<T1>{}(p.first);
		auto hash2 = hash<T2>{}(p.second);

		size_t seed = 0;
		seed ^= hash1 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
		seed ^= hash2 + 0x9e3779b9 + (seed << 6) + (seed >> 2);
		seed ^= m_hash_pair_random + 0x9e3779b9 + (seed << 6) + (seed >> 2);
		return seed;
	}

private:
	static size_t m_hash_pair_random;
};

size_t HashPair::m_hash_pair_random = (size_t)random_device()();

vector<pll> prime_factorize(ll number)
{
	vector<pll> res;
	for (ll divisor = 2; divisor * divisor <= number; divisor++)
	{
		if (number % divisor != 0)
			continue;
		ll exponent = 0;
		while (number % divisor == 0)
		{
			number /= divisor;
			exponent++;
		}
		res.push_back({ divisor, exponent });
	}
	if (number != 1)
		res.push_back({ number, 1 });
	return res;
}

}

Compiler output:
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x17): undefined reference to `main'
collect2: error: ld returned 1 exit status