#include <iostream>
#include <stdexcept>
#include <limits>

// tons of ways to make this faster on the bithacks page
int maxbitpos(int n) // assume positive
{
    int p = 0;
    while(n >>= 1) ++p;
    return p;
}

// doing power as n*n*n*n*n*... is as pointless as bubble sort
int mypow(int n, int p)
{
    if(p<0) 
        throw std::runtime_error("negative power not supported");
    if(p==0) return 1; // not hanlding negative powers for this
    if(p==1) return n; // avoid overflow in squaring

    if(2*maxbitpos(n) >= std::numeric_limits<int>::digits)
        throw std::overflow_error("integer overflow in pow()");

    int r = mypow(n*n, p/2);

    if(p&1) {
        if(maxbitpos(n) + maxbitpos(r) >= std::numeric_limits<int>::digits)
            throw std::overflow_error("integer overflow in pow()");
        return n*r;
    } else {
        return r;
    }
}

int main()
{
    for(;;) {
        std::cout << "integer: ";
        int n;
        std::cin >> n;

        std::cout << "power: ";
        int p;
        std::cin >> p;

        if(!std::cin) break; // quit on EOF

        try {
            std::cout << "result = " << mypow(n, p) << '\n';
        } catch(const std::exception& e) {
            std::cout << "could not pow(): " << e.what() << '\n';
        }
    }
}