template <typename T, typename U>
constexpr inline bool CanTypeRepresentValue(const U value) {
    return ((value > U()) == (static_cast<T>(value) > T())) &&
           (value == static_cast<U>(static_cast<T>(value)));
}

#include <cmath>
#include <iostream>
#include <limits>

template <typename T>
class Number {
    T rep;
public:
    constexpr Number(T t = T()) : rep(t) {}
    constexpr operator T () const { return rep; }
};

int main(int argc, char **argv) {
#define TEST(type, value) static_assert(CanTypeRepresentValue<type>(value), #type " can't represent " #value)
#define FAIL(type, value) static_assert(!CanTypeRepresentValue<type>(value), #type " can represent " #value)
    TEST(int, std::numeric_limits<int>::max());
    FAIL(int, unsigned(std::numeric_limits<int>::max()) + 1);
    TEST(unsigned, std::numeric_limits<int>::max());
    FAIL(unsigned, -3);
    TEST(char,122ULL);
    FAIL(char,256ULL);
    TEST(int,2.0f);
    FAIL(char,3.1415926535);
    TEST(Number<int>,250LL);
    TEST(Number<long>,-3.0);
    FAIL(Number<int>,2.1);
    FAIL(Number<char>,3.1415926535);
#undef TEST
#undef FAIL

#define CanTypeFitValue CanTypeRepresentValue

    long long value;
    while(std::cin >> value) {
        std::cout << value << ": ";
        std::cout << CanTypeFitValue<int8_t>(value) << " ";
        std::cout << CanTypeFitValue<uint8_t>(value) << " ";
        std::cout << CanTypeFitValue<int16_t>(value) << " ";
        std::cout << CanTypeFitValue<uint16_t>(value) << " ";
        std::cout << CanTypeFitValue<int32_t>(value) << " ";
        std::cout << CanTypeFitValue<uint32_t>(value) << " ";
        std::cout << CanTypeFitValue<int64_t>(value) << " ";
        std::cout << CanTypeFitValue<uint64_t>(value) << std::endl;
    }

}