The city administration of IT City decided to fix up a symbol of scientific and technical progress in the city's main square, namely an indicator board that shows the effect of Moore's law in real time.

Moore's law is the observation that the number of transistors in a dense integrated circuit doubles approximately every 24 months. The implication of Moore's law is that computer performance as function of time increases exponentially as well.

You are to prepare information that will change every second to display on the indicator board. Let's assume that every second the number of transistors increases exactly 1.000000011 times.


-----Input-----

The only line of the input contains a pair of integers n (1000 ≤ n ≤ 10 000) and t (0 ≤ t ≤ 2 000 000 000) — the number of transistors in the initial time and the number of seconds passed since the initial time.


-----Output-----

Output one number — the estimate of the number of transistors in a dence integrated circuit in t seconds since the initial time. The relative error of your answer should not be greater than 10^{ - 6}.


-----Examples-----
Input
1000 1000000

Output
1011.060722383550382782399454922040

Source: codeforces | Difficulty: EASY
Tags: Mathematics


Solutions:
(a, b) = map(int, input().split())
y = b // (60 * 60 * 24 * 30 * 24)
print(a * pow(1.000000011, b))


(n, t) = map(int, input().split())
print('%.10f' % (n * pow(1.000000011, t)))


def f(l):
	(n, t) = l
	return n * 1.000000011 ** t
l = list(map(int, input().split()))
print(f(l))


import math
INCREASE = 1.000000011
(n, t) = map(int, input().split(' '))
print(n * math.pow(INCREASE, t))


(n, k) = map(int, input().split())
print(1.000000011 ** k * n)


(n, t) = map(int, input().split())
x = 1.000000011
p = x ** t
print(n * p)


(n, t) = list(map(int, input().split()))
print(n * 1.000000011 ** t)


(n, m) = map(int, input().split(' '))
print(n * pow(1.000000011, m))


ln = input().split(' ')
n = int(ln[0])
t = int(ln[1])
print(n * 1.000000011 ** t)


(x, y) = [int(x) for x in input().split()]
i = 1.000000011 ** y
x = x * i
print(x)


import math
name = input()
raw = name.split(' ')
print(float(raw[0]) * math.pow(1.000000011, float(raw[1])))


(n, t) = [int(i) for i in input().split()]
print(n * pow(1.000000011, t))


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


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


import sys
(a, b) = map(int, sys.stdin.readline().split())
print(a * pow(1.000000011, b))


def pow(a, b):
	ans = 1
	while b > 0:
		if b & 1:
			ans *= a
		a *= a
		b >>= 1
	return ans
(n, t) = map(int, input().split())
print(n * pow(1.000000011, t))


import operator as op
from functools import reduce
from decimal import Decimal

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom
(a, n) = [int(x) for x in input().split()]

def foo(a, n, x):
	ans = 0
	i = 0
	prev = 1
	while abs(ans - prev) > 1e-07:
		prev = ans
		ans += Decimal(ncr(n, i)) * Decimal(x ** i)
		i += 1
	print(i)
	return a * ans
x = 1.1 * 1e-08
print(a * (1 + x) ** n)


from math import *
(n, t) = input().split()
(n, t) = [int(n), int(t)]
print(n * 1.000000011 ** t)


3
(n, t) = tuple(map(int, input().split()))
ans = n * 1.000000011 ** t
print(str(ans))


import math
t = [float(i) for i in input().split()]
n = t[0] * pow(1.000000011, t[1])
print(n)


(base, time) = map(int, input().split())
print('%.6f' % (base * 1.000000011 ** time))


a = input().split(' ')
print(int(a[0]) * 1.000000011 ** int(a[1]))


import collections
import math
(n, m) = map(int, input().split())
print(1.000000011 ** m * n)


def transistorsandtimetaken(n, t):
	return print('%.24f' % (n * 1.000000011 ** t))
(n, t) = [int(x) for x in input().split()]
n = float(n)
transistorsandtimetaken(n, t)


(n, t) = map(int, input().rstrip().split())
answer = n * 1.000000011 ** t
print(answer)


import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def SieveOfEratosthenes(n):
	prime = []
	primes = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if primes[p] == True:
			prime.append(p)
			for i in range(p * p, n + 1, p):
				primes[i] = False
		p += 1
	return prime

def primefactors(n):
	fac = []
	while n % 2 == 0:
		fac.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 2):
		while n % i == 0:
			fac.append(i)
			n = n // i
	if n > 1:
		fac.append(n)
	return sorted(fac)

def factors(n):
	fac = set()
	fac.add(1)
	fac.add(n)
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			fac.add(i)
			fac.add(n // i)
	return list(fac)

def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
(n, time) = map(int, input().split())
print(n * pow(1.000000011, time))


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def int_array():
	return list(map(int, input().strip().split()))

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def solve():
	(n, t) = map(int, input().split())
	print('{:.9f}'.format(n * 1.000000011 ** t))
for _ in range(1):
	solve()


s = input().split()
n = float(s[0])
t = float(s[1])
print(n * 1.000000011 ** t)


import re
st = input()
s = re.split('[\\s]', st)
n = int(s[0])
t = int(s[1])
print(n * 1.000000011 ** t)


(n, t) = input().split()
n = int(n)
t = int(t)
n *= 1.000000011 ** t
print(n)


n = input().split()
m = int(n[0])
t = int(n[1])
print(m * 1.000000011 ** t)


import time
(n, t) = (int(i) for i in input().split())
start = time.time()
print(n * 1.000000011 ** (t - 1))
finish = time.time()


s = input()
S = s.split()
transistors = int(S[0])
seconds = int(S[1])
a1 = 1
a2 = 1
a3 = 1
for i in range(1000):
	a1 = a1 * 1.000000011
for i in range(1000):
	a2 = a2 * a1
for i in range(1000):
	a3 = a3 * a2
local0 = seconds % 1000
seconds = int((seconds - local0) / 1000)
local1 = seconds % 1000
seconds = int((seconds - local1) / 1000)
local2 = seconds % 1000
seconds = int((seconds - local2) / 1000)
local3 = seconds % 1000
for i in range(local0):
	transistors = transistors * 1.000000011
for i in range(local1):
	transistors = transistors * a1
for i in range(local2):
	transistors = transistors * a2
for i in range(local3):
	transistors = transistors * a3
print(transistors)


s = input()
list = s.split(' ')
n = int(list[0])
secs = int(list[1])
ans = n * 1.000000011 ** secs
print(ans)


import math
(n, t) = map(float, input().split())
res = n * math.pow(1.000000011, t)
print('%.20f' % res)


(n, power) = map(int, input().split())
cnt = 1.000000011
ans = 1
while power:
	if power % 2:
		ans *= cnt
	power >>= 1
	cnt *= cnt
print(ans * n)


(n, t) = map(int, input().split())
print(round(n * 1.000000011 ** t, 20))


(n, t) = map(int, input().split())
rate = 1.000000011
print(n * rate ** t)


(n, t) = map(int, input().split())
print((1 + 1.1e-08) ** t * n)


(n, t) = map(int, input().split())
n = n * 1.000000011 ** t
print('%.12f' % n)


(n, t) = (int(x) for x in input().split())
print(n * pow(1.000000011, t))


import decimal
a = input().split(' ')
result = (int(a[1]) * decimal.Decimal('1.000000011').ln()).exp() * int(a[0])
print(result)


(n, t) = map(float, input().split())
print(n * 1.000000011 ** t)


(p, q) = map(int, input().split())
base = 1.000000011
print(p * base ** q)


(n, t) = [int(x) for x in input().split()]
mul = 1.000000011
mul = mul ** t
print(n * mul)


from decimal import *
context = Context(prec=40)
setcontext(context)
(n, t) = [i for i in input().split()]
n += '.000000000000000000'
n = Decimal(n)
multiplier = Decimal('1.000000011')

def recursexp(t):
	global multiplier
	if t == 0:
		return 1
	elif t == 1:
		return multiplier
	elif t % 2 == 0:
		rec = recursexp(t / 2)
		return rec * rec
	else:
		return recursexp(t // 2) * recursexp(t // 2 + 1)
t = int(t)
print(n * recursexp(t))


a = 1.000000011
(n, t) = [int(x) for x in input().split()]
print(n * a ** t)


c = input().split()
n = int(c[0])
t = int(c[1])
print(n * 1.000000011 ** t)


(s, k) = map(int, input().split())
print(s * 1.000000011 ** k)


(n, t) = map(float, input().split())
val = 1.000000011

def mpow(a, b):
	r = 1.0
	while b > 0:
		if b & 1:
			r = r * a
		a = a * a
		b //= 2
	return r
print(n * mpow(val, int(t)))


(n, t) = map(int, input().split())
k = float(1.000000011)
print(n * pow(k, t))


(n, t) = map(int, input().split())
b = 1.000000011
print(n * pow(b, t))


(n, T) = map(int, input().split())
print(n * 1.000000011 ** T)


(n, m) = map(float, input().split())
k = 1.000000011
print(n * k ** m)


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
mod = 1000000007
for i in range(1):
	(n, t) = mi()
	a = 1.000000011
	c = pow(a, t)
	print(n * c)


from sys import stdin, stdout
from gc import disable

def main() -> int:
	disable()
	(a, b) = map(int, stdin.readline().split())
	m = 1.000000011
	ans = a * m ** b
	stdout.write('%.6F' % ans)
	return 0
main()


(n, t) = map(int, input().split())
e = 1.000000011
print(n * e ** t)


x = input().split()
print(int(x[0]) * pow(1.000000011, int(x[1])))


snt = input().split()
n = int(snt[0])
t = int(snt[1])
print(n * 1.000000011 ** t)


(a, b) = map(lambda x: int(x), input().split(' '))
print(a * 1.000000011 ** b)


(n, m) = map(int, input().split())
s = 1.000000011
print(n * s ** m)


(n, t) = map(int, input().split())
a = float(n * 1.000000011 ** t)
print(a)


(n, t) = map(int, input().split())
r = 1.000000011
r = pow(r, t)
print(n * r)


(n, t) = map(int, input().split())
c = pow(1.000000011, t)
print(n * c)


import math
(n, t) = map(int, input().split())
print(10 ** (math.log(n, 10) + t * math.log(1.000000011, 10)))


x = input().split(' ')
a = int(x[0])
b = int(x[1])
print(a * 1.000000011 ** b)


(r, s) = (int(i) for i in input().split(' '))
print(r * 1.000000011 ** s)


ch = input()
d = ch.split(' ')
n = int(d[0])
t = int(d[1])
f = 1.000000011 ** t
print(f * n)


(n, m) = map(int, input().split())
q = 1.000000011
ans = n * q ** m
print(ans)


(n, t) = map(int, input().split())
print('{:.30}'.format(n * pow(1.000000011, t)))


(n, t) = map(float, input().split())
print('%.10f' % (n * pow(1.000000011, t)))


(n, k) = map(float, input().split())
p = n * 1.000000011 ** k
print(p)


(x, y) = map(int, input().split())
print(x * 1.000000011 ** y)


(x, t) = map(int, input().split())
result = x * (1 + 1.1e-08) ** t
print(result)


fact = 1.000000011
(n, t) = map(int, input().split())
print(n * pow(fact, t))


import decimal
(n, t) = map(int, input().split())
n = decimal.Decimal(n)
t = decimal.Decimal(t)
r = decimal.Decimal(1.000000011)
print('{:.18f}'.format(n * r ** t))


(n, t) = map(int, input().split())
d = 1.000000011
print(n * d ** t)


I = lambda : int(input())
IL = lambda : list(map(int, input().split()))
(n, t) = IL()
print(n * 1.000000011 ** t)


(n, t) = map(int, input().split())
print('%.8f' % (n * 1.000000011 ** t))


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))
ilelec = lambda : map(int1, input().split())
alelec = lambda : list(map(int1, input().split()))

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])

def power(x, y):
	res = 1
	if x == 0:
		return 0
	while y > 0:
		if y & 1:
			res = res * x
		y = y >> 1
		x = x * x
	return res
a = 1.000000011
(x, y) = ilele()
print(x * power(a, y))


(n, t) = map(int, input().split())
ans = 1.000000011 ** t * n
print(ans)


transistors_increase = 1.000000011
(transistors, time) = map(int, input().split())
result = transistors * transistors_increase ** time
print(result)


import math
(a, b) = map(int, input().split())
c = 1.000000011
ans = math.pow(c, b)
ans = ans * a
print(ans)


from sys import stdin, stdout
from math import gcd, ceil, sqrt
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
(n, t) = iia()
print(n * 1.000000011 ** t)


L = input()
L = L.split()
n = int(L[0])
t = int(L[1])
increases = 1.000000011
aux = n * increases ** t
print('%.30f' % aux)


n = 1.000000011
a = input().split()
k = int(a[0])
z = int(a[1])
print(k * n ** z)


import math
string = input()
lst = string.split()
a = int(lst[0])
b = int(lst[1])
I = 1.000000011
print(a * I ** b)


a = input().split()
b = int(a[0])
c = int(a[1])
print(b * 1.000000011 ** c)


from decimal import *
a = input().split(' ')
print(Decimal(a[0]) * Decimal(Decimal(1.000000011) ** Decimal(a[1])))


a = input().split(' ')
a = [int(i) for i in a]
print(a[0] * pow(1.000000011, a[1]))


def main():
	(n, t) = map(int, input().split())
	print(n * pow(1.000000011, t))
main()


import sys
(a, b) = [int(x) for x in input().split()]
print(a * 1.000000011 ** b)


(x, y) = [int(a) for a in input().split()]
s = x * pow(1.000000011, y)
print(s)


(n, t) = input().split()
n = int(n)
t = int(t)
res = n * pow(1.000000011, t)
print(res)


from math import pow
(num, p) = map(int, input().split())
print(num * pow(1.000000011, p))


(N, T) = map(int, input().split())
print(N * 1.000000011 ** T)


(n, t) = (int(x) for x in input().split())
print('%.30f' % (n * 1.000000011 ** t))


import math

def ncr(n, x):
	ans = n
	f = 1
	for i in range(1, x):
		ans *= n - i
		f *= i + 1
	return ans // f
(n, x) = map(int, input().split())
f = 1.000000011
c = math.pow(f, x)
print(n * c)


entrada = input()
partes = entrada.split(' ')
n = int(partes[0])
t = int(partes[1])
p = 1.000000011
print(p ** t * n)


def fast_pow(x, y):
	res = n
	a = x
	while y > 0:
		if y % 2 == 1:
			res *= a
		a = a * a
		y = y // 2
	return res
(n, b) = map(int, input().split())
print(fast_pow(1.000000011, b))


import re
n = re.split(' ', input())
C = 1.000000011
print(int(n[0]) * C ** int(n[1]))


import sys
input = sys.stdin.buffer.readline
from math import *
(n, t) = map(int, input().split())
val = pow(1.000000011, t)
print(n * val)


a = input()
b = []
b = a.split()
number = int(b[0])
degree = int(b[1])
res = number * 1.000000011 ** degree
print(res)


(n, t) = [int(num) for num in input().split()]
print(n * 1.000000011 ** t)


(n, t) = [float(x) for x in input().split()]
const = 1.000000011
print(float(n * const ** t))


__author__ = 'konstantinzhivotov'
(n, t) = map(int, input().split())
a = 1.000000011
print(n * a ** t)


from decimal import Decimal
(n, t) = list(map(Decimal, input().split()))
k = Decimal('1.000000011')
print(n * k ** t)


import math
(n, t) = map(int, input().split())
n1 = float(n)
x = pow(1.000000011, t) * n1
print('%.9f' % x)


from sys import stdin
(n, t) = map(int, stdin.readline().split())
result = n * 1.000000011 ** t
print(result)


def numberoftransitors(n, t):
	n = float(n)
	t = int(t)
	n = n * pow(1.000000011, t)
	print(n)
(n, t) = input().split()
numberoftransitors(n, t)


s = input()
l = s.split(' ')
n = int(l[0])
t = int(l[1])
x = 1.000000011 ** t
y = x * n
print(y)


import math
RATE = 1.000000011
(s, t) = input().split(' ')
(s, t) = (int(s), int(t))
print(s * RATE ** t)


def main():
	(n, t) = (int(x) for x in input().split())
	print(solver(n, t))

def solver(n, t):
	return n * pow(1.000000011, t)
main()


from sys import stdin
c = 1.000000011
(ns, ts) = stdin.readline().split()
m = c ** int(ts)
print(int(ns) * m)


import math
from decimal import Decimal
import heapq

def na():
	n = int(input())
	b = [int(x) for x in input().split()]
	return (n, b)

def nab():
	n = int(input())
	b = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	return (n, b, c)

def dv():
	(n, m) = map(int, input().split())
	return (n, m)

def dva():
	(n, m) = map(int, input().split())
	a = [int(x) for x in input().split()]
	b = [int(x) for x in input().split()]
	return (n, m, b)

def eratosthenes(n):
	sieve = list(range(n + 1))
	for i in sieve:
		if i > 1:
			for j in range(i + i, len(sieve), i):
				sieve[j] = 0
	return sorted(set(sieve))

def nm():
	n = int(input())
	b = [int(x) for x in input().split()]
	m = int(input())
	c = [int(x) for x in input().split()]
	return (n, b, m, c)

def dvs():
	n = int(input())
	m = int(input())
	return (n, m)
(n, m) = map(int, input().split())
s = Decimal(n * Decimal(pow(1.000000011, m)))
print(s)


import math
l = input().split(' ')
n = int(l[0])
t = int(l[1])
print(n * math.pow(1.000000011, t))


(N, T) = map(int, input().split())
print('%.30f' % (N * pow(1.000000011, T)))


N = 1.000000011
(n, m) = map(int, input().split())
print(n * N ** m)


n = input()
n = n.split()
a = int(n[0])
t = int(n[1])
x = 1.000000011 ** t
x = x * a
s = '%.30f' % x
print(s)


s = input().split()
a = int(s[0])
b = int(s[1])
print(a * 1.000000011 ** b)


s = 1.000000011
(n, t) = map(int, input().split())
print(s ** t * n)


from decimal import Decimal
(n, t) = map(int, input().split())
print(Decimal(n) * pow(Decimal('1.000000011'), int(t)))


import sys
import datetime

def main():
	(n, t) = map(int, input().split())
	print('{0:.10f}'.format(n * 1.000000011 ** t))
main()


(a, t) = map(int, input().split())
print(a * pow(1.000000011, t))


(n, t) = map(int, input().split())

def power(a, n):
	bi = str(format(n, 'b'))
	res = 1
	for i in range(len(bi)):
		res = res * res
		if bi[i] == '1':
			res = res * a
	return res
ans = n * power(1.000000011, t)
print(ans)


3
(n, t) = [int(i) for i in input().split()]
delta = 1.000000011
print(n * delta ** t)


from math import *
s = input()
s = s.split()
time = int(s[1])
a = int(s[0])
temp = pow(1.000000011, time)
print(a * temp)


(n, t) = map(int, input().split())
m = 1.000000011
print(n * m ** t)


(n, t) = map(int, input().split())
print(1.0 * n * 1.000000011 ** t)


def __starting_point():
	(n, t) = map(int, input().split())
	print(n * 1.000000011 ** t)
__starting_point()


num = input().split(' ')
print('%.9f' % (int(num[0]) * 1.000000011 ** int(num[1])))


(a, b) = map(int, input().split())
print((11 / 10 ** 9 + 1) ** b * a)


from decimal import *
getcontext().prec = 1000
(n, t) = map(int, input().split())
c = 1.000000011
print(n * c ** t)


def law_muur(n, t):
	z = 1.000000011
	return format(z ** t * n, '.10f')
(N, T) = [int(i) for i in input().split()]
print(law_muur(N, T))


from decimal import *
import math
(n, t) = map(int, input().split())
tp = Decimal(math.log(Decimal(1.000000011)))
tp *= t
tp = math.exp(tp)
tp *= n
print(Decimal(tp))


def iter_pow(x, n):
	res = 1
	while n:
		if n & 1:
			res = res * x
		x = x * x
		n = n >> 1
	return res
(a, b) = input().split(' ')
print(iter_pow(1.000000011, int(b)) * int(a))


def exp(a, b):
	res = 1
	while b > 0:
		if b % 2:
			res = res * a
		a = a * a
		b >>= 1
	return res

def main():
	(n, t) = map(int, input().split())
	print(n * exp(1.000000011, t))
main()


def e(a, b):
	x = 1
	while b > 0:
		if b & 1 == 1:
			x = x * a
		a = a * a
		b >>= 1
	return x
(a, b) = map(int, input().split(' '))
print(a * e(1.000000011, b))


a = input()
a = a.split()
n = int(a[0])
t = int(a[1])
print(n * 1.000000011 ** t)


(q, w) = map(int, input().split())
print(q * 1.000000011 ** w)


from decimal import *
getcontext().prec = 10
(n, t) = input().split()
n = int(n)
t = int(t)
aux = Decimal(1.000000011) ** Decimal(t)
print(aux * n)


import math
(n, t) = map(float, input().split())
khuti = 1.000000011
n *= khuti ** t
print(n)


def bin_pow(a, b):
	if b == 1:
		return a
	if b % 2 == 0:
		x = bin_pow(a, b // 2)
		return x * x
	else:
		return bin_pow(a, b - 1) * a
(n, t) = map(int, input().split())
if t == 0:
	print(n)
else:
	delta = 1.000000011
	x = bin_pow(delta, t)
	print(n * x)


(n, time) = map(int, input().split())
print(n * pow(1.000000011, time))


(a, s) = map(float, input().split())
print(a * 1.000000011 ** s)


(a, b) = [int(x) for x in input().split()]
p = 1.000000011
print(a * pow(p, b))


import math
(n, t) = map(int, input().split())
print(n * math.exp(t * math.log(1.000000011, 2.718281828459045)))


inc = 1.000000011
(n, t) = map(int, input().split(' '))
fold = 1.0
while t > 0:
	if t % 2 == 1:
		fold *= inc
	inc *= inc
	t = t // 2
print(n * fold)


import math
input = input().split(' ')
n = float(input[0])
t = float(input[1])
k = 1.000000011
print(n * math.pow(k, t))


(n, m) = map(int, input().split())
d = 1.000000011 ** (m - 1)
print(n * d)


(n, t) = [int(i) for i in input().split()]
x = 1.000000011
print(n * x ** t)


from decimal import *
getcontext().prec = 30
(n, k) = map(int, input().split())
print(Decimal(n) * Decimal(1.000000011 ** k))


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from operator import *
from itertools import accumulate
inf = float('inf')
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
en = lambda x: list(enumerate(x))
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
(a, b) = r()
x = 1.000000011
a = a * x ** b
print(f'{a:.30f}')


def f(t):
	z = 1.000000011
	p = 1
	while t:
		if t % 2:
			t -= 1
			p *= z
		else:
			t //= 2
			z *= z
	return p
(n, t) = map(int, input().split())
print(n * f(t))


(n, t) = (int(_) for _ in input().split())
print(n * 1.000000011 ** t)


from sys import stdin
line = stdin.readline().strip().split(' ')
n = int(line[0])
p = int(line[1])
print(n * 1.000000011 ** p)


from decimal import *
getcontext().prec = 100
(n, t) = [Decimal(int(i)) for i in input().split()]
rate = Decimal(1.000000011)
print(n * rate ** t)


import os, sys, pdb
import time, calendar, datetime
import math, itertools
import operator as op
from functools import reduce

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom
(n, t) = list(map(int, input().split()))
m = 1.0110607223835504
print(n * m ** (t // 1000000) * 1.000000011 ** (t % 1000000))


(x, y) = map(int, input().split())
z = x * 1.000000011 ** y
print('%.32f' % z)


from math import pow
s = input().split(' ')
n = int(s[0])
m = int(s[1])
ans = n * pow(1.000000011, m)
print(ans)


a = list(map(int, input().split()))
print(float(a[0]) * 1.000000011 ** a[1])


import sys
import math

def main():
	(n, t) = map(int, sys.stdin.readline().strip().split()[:2])
	print(n * 1.000000011 ** t)
main()


a = input('').split(' ')
print(float(a[0]) * 1.000000011 ** float(a[1]))


from decimal import *
ins = lambda x: map(x, input().split())
(n, t) = ins(int)
print(n * Decimal(1.000000011) ** t)