Завершение программы

a, b = map(int, input().split())
print(a ** b)

# import signal
# import os
from threading import Timer
from _thread import interrupt_main
 
 
TIMEOUT = 10
 
 
def exit():
    # os._exit(1)  # внезапная смерть
    # os.kill(os.getpid(), signal.SIGINT)  # внезапная смерть
    interrupt_main()  # прощание с близкими, завещание
    print('break after', TIMEOUT, 'seconds...')
    
def fib(n):
    if n <= 2:
        return 1
    return fib(n-1) + fib(n-2)
 
def main():
    print(fib(70))
 
 
if __name__ == '__main__':
    breaker = Timer(TIMEOUT, exit)
    breaker.start()    
    try:
        main()
    except KeyboardInterrupt:
        pass
    else:
        breaker.cancel()
        print('done')

def main():
    print(1000000000000000 ** 10000000000000000)

import threading
 
TIMEOUT = 1
 
 
class MyThread(threading.Thread):
 
    def run(self):
        # while True:
        #     pass
        return 1000000000000000 ** 10000000000000000
 
 
if __name__ == '__main__':
    t = MyThread()
    t.setDaemon(True)
    t.start()
    t.join(TIMEOUT)

import multiprocessing
from multiprocessing import Pool as ProcessPool
 
TIMEOUT = 5
 
 
def run_with_timeout(f, timeout, *args, **kwargs):
    res = None
    with ProcessPool(processes=1) as pool:
        ares = pool.apply_async(f, args, kwargs)
        try:
            res = ares.get(timeout=timeout)
        except multiprocessing.TimeoutError:
            print('break after', timeout, 'seconds...', flush=True)
    return res
 
 
def main():
    a = 10000000000000000
    b = 10000000000000000
    return a ** b
 
 
if __name__ == '__main__':
    run_with_timeout(main, TIMEOUT)

# import dis
 
def f():
    return 10000000000000000 ** 10000000000000000
# dis.dis(f)