#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <type_traits>
 
using namespace std;
 
template <typename F, typename I>
enable_if_t<is_floating_point<F>::value && is_unsigned<I>::value, void> func(const I n) {
  const auto d = static_cast<F>(n);
  auto msb = static_cast<I>(numeric_limits<I>::digits - 1);
 
  while(((static_cast<I>(1) << msb) & n) == static_cast<I>(0)) {
    --msb;
  }
 
  cout << "Original:          " << n << endl << setprecision(50);
 
  if(msb < numeric_limits<F>::digits)
  {
    cout << "*Lower bound:      " << d << "\n*Upper bound:      " << d << "\nPrecision loss:    " << 0.0 << "\n\n";
  }
  else
  {
    const auto zero_based_lost_bits = static_cast<I>(msb - numeric_limits<F>::digits);
    const auto one_based_lost_bits = static_cast<I>(msb - numeric_limits<F>::digits + 1);
    const auto midway = static_cast<I>(1) << zero_based_lost_bits;
    const auto mask = static_cast<I>(1) << one_based_lost_bits;
    const auto lost_precision = ~(bitset<numeric_limits<F>::digits>().set().to_ullong() << one_based_lost_bits) & n;
 
    if(midway > lost_precision || midway == lost_precision && (mask & n) == static_cast<I>(0)) {
      const auto f = nextafter(d, numeric_limits<F>::infinity());
 
      cout << "*Lower bound:      " << d << "\nUpper bound:       " << f << "\nPrecision loss:    " << lost_precision << "\n\n";
    } else {
      const auto f = nextafter(d, -numeric_limits<F>::infinity());
 
      cout << "Lower bound:       " << f << "\n*Upper bound:      " << d << "\nPrecision loss:    " << mask - lost_precision << "\n\n";
    }
  }
}
 
int main()
{
  func<double>(1ULL);
  func<double>(9007199254740991ULL);
  func<double>(18014398509481982ULL);
  func<double>(18014398509481983ULL);
  func<double>(9223372036854775295ULL);
  func<double>(9223372036854775296ULL);
  func<double>(numeric_limits<uint64_t>::max());         // Rounds up
  func<double>(numeric_limits<uint64_t>::max() - 2046);  // Rounds down
}

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