{

using boost::int128::uint128;

using boost::int128::int128;

std::cout << "=== Greatest Common Divisor (gcd) ===" << std::endl;

// Basic gcd

constexpr uint128 a {48};

constexpr uint128 b {18};

std::cout << "gcd(" << a << ", " << b << ") = " << boost::int128::gcd(a, b) << std::endl;

// gcd with larger values

constexpr uint128 large_a {123456789012345678ULL};

constexpr uint128 large_b {987654321098765432ULL};

std::cout << "gcd(" << large_a << ", " << large_b << ") = "

<< boost::int128::gcd(large_a, large_b) << std::endl;

// gcd with 128-bit values

constexpr uint128 huge_a {uint128{1} << 100};

constexpr uint128 huge_b {uint128{1} << 80};

std::cout << "gcd(2^100, 2^80) = " << boost::int128::gcd(huge_a, huge_b) << " (= 2^80)" << std::endl;

// Signed gcd (always returns positive)

constexpr int128 neg_a {-48};

constexpr int128 neg_b {18};

std::cout << "gcd(" << neg_a << ", " << neg_b << ") = "

<< boost::int128::gcd(neg_a, neg_b) << " (always positive)" << std::endl;

std::cout << "\n=== Least Common Multiple (lcm) ===" << std::endl;

// Basic lcm

constexpr uint128 x {12};

constexpr uint128 y {18};

std::cout << "lcm(" << x << ", " << y << ") = " << boost::int128::lcm(x, y) << std::endl;

// lcm with coprime numbers

constexpr uint128 p {7};

constexpr uint128 q {11};

std::cout << "lcm(" << p << ", " << q << ") = " << boost::int128::lcm(p, q)

<< " (coprime: lcm = p * q)" << std::endl;

// Relationship: gcd(a,b) * lcm(a,b) = a * b

std::cout << "\nVerifying gcd * lcm = a * b:" << std::endl;

auto g {boost::int128::gcd(x, y)};

auto l {boost::int128::lcm(x, y)};

std::cout << "gcd(" << x << ", " << y << ") * lcm(" << x << ", " << y << ") = "

<< (g * l) << std::endl;

std::cout << x << " * " << y << " = " << (x * y) << std::endl;

std::cout << "\n=== Midpoint ===" << std::endl;

// Unsigned midpoint

constexpr uint128 low {10};

constexpr uint128 high {20};

std::cout << "midpoint(" << low << ", " << high << ") = "

<< boost::int128::midpoint(low, high) << std::endl;

// Midpoint with odd sum (rounds toward first argument)

constexpr uint128 odd_low {10};

constexpr uint128 odd_high {21};

std::cout << "midpoint(" << odd_low << ", " << odd_high << ") = "

<< boost::int128::midpoint(odd_low, odd_high) << " (rounds toward first arg)" << std::endl;

std::cout << "midpoint(" << odd_high << ", " << odd_low << ") = "

<< boost::int128::midpoint(odd_high, odd_low) << " (rounds toward first arg)" << std::endl;

// Midpoint avoids overflow (unlike (a+b)/2)

std::cout << "\n--- Overflow-safe midpoint ---" << std::endl;

constexpr auto uint_max {std::numeric_limits<uint128>::max()};

constexpr auto uint_max_minus_10 {uint_max - 10U};

std::cout << "midpoint(uint128_max, uint128_max - 10) = "

<< boost::int128::midpoint(uint_max, uint_max_minus_10) << std::endl;

std::cout << "(This would overflow if computed as (a + b) / 2)" << std::endl;

// Signed midpoint

std::cout << "\n--- Signed midpoint ---" << std::endl;

constexpr int128 neg {-100};

constexpr int128 pos {100};

std::cout << "midpoint(" << neg << ", " << pos << ") = "

<< boost::int128::midpoint(neg, pos) << std::endl;

constexpr int128 neg2 {-100};

constexpr int128 neg3 {-50};

std::cout << "midpoint(" << neg2 << ", " << neg3 << ") = "

<< boost::int128::midpoint(neg2, neg3) << std::endl;

return 0;

}