You are given a positive decimal number x.

Your task is to convert it to the "simple exponential notation".

Let x = a·10^{b}, where 1 ≤ a < 10, then in general case the "simple exponential notation" looks like "aEb". If b equals to zero, the part "Eb" should be skipped. If a is an integer, it should be written without decimal point. Also there should not be extra zeroes in a and b.


-----Input-----

The only line contains the positive decimal number x. The length of the line will not exceed 10^6. Note that you are given too large number, so you can't use standard built-in data types "float", "double" and other.


-----Output-----

Print the only line — the "simple exponential notation" of the given number x.


-----Examples-----
Input
16

Output
1.6E1

Input
01.23400

Output
1.234

Input
.100

Output
1E-1

Input
100.

Output
1E2

Difficulty: MEDIUM_HARD

Solutions:
from math import *

def is_even(p):
	n = len(p)
	count = 0
	for i in range(n):
		index = p.index(i, i, n)
		if i == index:
			pass
		else:
			count += 1
			temp = p[i]
			p[i] = p[index]
			p[index] = temp
	if count % 2 == 0:
		return True
	else:
		return False
prime = []

def SieveOfEratosthenes():
	global prime
	prime = [1] * 2000010
	prime[1] = 0
	p = 2
	while p * p <= 2000001:
		if prime[p]:
			for i in range(p * p, 2000002, p):
				prime[i] = 0
lpf = []

def precompute():
	global lpf
	lpf = [0] * 1000001
	for i in range(2, 1000001):
		if not lpf[i]:
			for j in range(i, 1000001, i):
				if not lpf[j]:
					lpf[j] = i

def binpow(a, b):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
		a *= a
		b >>= 1
	return res

def modpow(a, b, x):
	res = 1
	while b > 0:
		if b & 1:
			res *= a
			res %= x
		a *= a
		a %= x
		b >>= 1
	return res
cont = []

def f(x):
	global cont
	total = 0
	for i in cont:
		total += abs(i - x)
	return total

def bs(low, high, target):
	while low + 3 < high:
		mid = (low + high) / 2
		if arr[mid] < target:
			low = mid
		else:
			high = mid - 1
	for i in range(high, low - 1, -1):
		if arr[o] < target:
			return i
	return -1

def ternary_search(l, r):
	while r - l > 10:
		m1 = l + (r - l) / 3
		m2 = r - (r - l) / 3
		f1 = f(m1)
		f2 = f(m2)
		if f1 > f2:
			l = m1
		else:
			r = m2
	mino = f(l)
	for i in range(l, r + 1):
		mino = min(mino, f(i))
	return mino
s = input()
s = s.replace('0', ' ')
s = s.lstrip()
s = s.replace(' ', '0')
l = s.find('.')
if l == -1:
	sz = len(s)
	tr = s[0] + '.' + s[1:]
	tr = tr.replace('0', ' ')
	tr = tr.rstrip()
	tr = tr.replace(' ', '0')
	if tr[-1] == '.':
		tr = tr[0:-1]
	if sz == 1:
		print(tr)
	else:
		tr += 'E' + str(sz - 1)
		print(tr)
elif l == 0:
	s = s[1:]
	sz = len(s)
	s = s.replace('0', ' ')
	s = s.lstrip()
	s = s.replace(' ', '0')
	new_sz = len(s)
	counter = -1
	counter -= sz - new_sz
	s = s.replace('0', ' ')
	s = s.rstrip()
	s = s.replace(' ', '0')
	tr = s[0] + '.' + s[1:]
	if tr[-1] == '.':
		tr = tr[0:-1]
	tr += 'E' + str(counter)
	print(tr)
else:
	diff = l - 1
	s = s.replace('0', ' ')
	s = s.rstrip()
	s = s.replace(' ', '0')
	if diff == 0:
		if s[-1] == '.':
			s = s[0:-1]
		print(s)
	else:
		tr = s[0] + '.' + s[1:l] + s[l + 1:]
		tr = tr.replace('0', ' ')
		tr = tr.rstrip()
		tr = tr.replace(' ', '0')
		if tr[-1] == '.':
			tr = tr[0:-1]
		tr += 'E' + str(diff)
		print(tr)


s = input()
if not '.' in s:
	s = s + '.'
i = 0
zer = 0
step = 0
while s[i] == '0':
	zer += 1
	i += 1
s = s[zer:]
zer = 0
i = len(s) - 1
while s[i] == '0':
	zer += 1
	i -= 1
if zer > 0:
	s = s[:-zer]
i = s.index('.')
if len(s[i:]) > 1 and i == 0:
	i += 1
	step -= 1
	while s[i] == '0':
		i += 1
		step -= 1
elif i == len(s) - 1:
	i -= 1
	while s[i] == '0':
		i -= 1
		step += 1
i = s.index('.')
if len(s) == 2 and step == 0:
	print(s[0])
elif len(s[:-step - 1]) == 1 and step > 0:
	print(s[0] + 'E' + str(step))
elif len(s[:i]) == 1 and step == 0:
	print(s[0] + '.' + s[i + 1:])
elif step == 0:
	print(s[0] + '.' + s[1:i] + s[i + 1:] + 'E' + str(len(s[1:i])))
elif step > 0:
	print(s[0] + '.' + s[1:i - step] + s[i + 1:] + 'E' + str(len(s[1:i - step]) + step))
elif step < 0 and len(s[-step:]) == 1:
	print(s[-step] + s[-step + 1:] + 'E' + str(step))
elif step < 0:
	print(s[-step] + '.' + s[-step + 1:] + 'E' + str(step))


S = input()
beg = 0
end = len(S)
while beg < end and S[beg] == '0':
	beg += 1
if '.' in S:
	while beg < end and S[end - 1] == '0':
		end -= 1
	if beg < end and S[end - 1] == '.':
		end -= 1
if '.' in S:
	i = S.index('.')
if beg == end:
	print('0')
elif '.' in S and i < end:
	if i == beg and end - beg == 2:
		print('%sE-1' % S[beg + 1])
	elif i == beg + 1:
		print(S[beg:end])
	elif i > beg + 1:
		print('%s.%s%sE%d' % (S[beg], S[beg + 1:i], S[i + 1:end], i - beg - 1))
	else:
		c = -1
		beg += 1
		while beg < end and S[beg] == '0':
			beg += 1
			c -= 1
		print('%s%s%sE%d' % (S[beg], '.' if end - beg > 1 else '', S[beg + 1:end], c))
elif end - beg == 1:
	print(S[beg])
else:
	l = end - beg
	while beg < end and S[end - 1] == '0':
		end -= 1
	print('%s%s%sE%d' % (S[beg], '.' if end - beg > 1 else '', S[beg + 1:end], l - 1))


import sys, math
s = input()
h = 0
while h < len(s) and s[h] == '0':
	h += 1
s = s[h:]
if '.' in s and s[-1] == '0':
	g = 1
	while g <= len(s) and s[-g] == '0':
		g += 1
	s = s[:-g + 1]
if len(s) == 0:
	print(0)
	sys.exit(0)
idx = -1
for i in range(len(s)):
	if s[i] == '.':
		idx = i
		break
if idx == -1:
	idx = len(s)
elif s[0] == '.':
	h = 1
	while h < len(s) and s[h] == '0':
		idx -= 1
		h += 1
if 1:
	mul = idx - 1
	new = ''
	for i in range(len(s)):
		if s[i] != '.':
			new += s[i]
	s = new
	if len(s) > 0 and s[-1] == '0':
		h = 2
		while h <= len(s) and s[-h] == '0':
			h += 1
		s = s[:-h + 1]
	if len(s) > 0 and s[0] == '0':
		h = 1
		while h < len(s) and s[h] == '0':
			h += 1
		s = s[h:]
	mul = str(mul)
	if len(s) == 0:
		print(0)
		sys.exit(0)
	elif len(s) == 1:
		print(s[0], end='')
		if mul != '0':
			print('E' + mul)
		sys.exit(0)
	else:
		print(s[0] + '.' + s[1:], end='')
		if mul != '0':
			print('E' + mul)


import sys
import bisect
from bisect import bisect_left as lb
input_ = lambda : sys.stdin.readline().strip('\r\n')
from math import log
from math import gcd
from math import atan2, acos
from random import randint
sa = lambda : input_()
sb = lambda : int(input_())
sc = lambda : input_().split()
sd = lambda : list(map(int, input_().split()))
sflo = lambda : list(map(float, input_().split()))
se = lambda : float(input_())
sf = lambda : list(input_())
flsh = lambda : sys.stdout.flush()
mod = 10 ** 9 + 7
mod1 = 998244353
gp = []
cost = []
dp = []
mx = []
ans1 = []
ans2 = []
special = []
specnode = []
a = 0
kthpar = []

def dfs(root, par):
	if par != -1:
		dp[root] = dp[par] + 1
	for i in range(1, 20):
		if kthpar[root][i - 1] != -1:
			kthpar[root][i] = kthpar[kthpar[root][i - 1]][i - 1]
	for child in gp[root]:
		if child == par:
			continue
		kthpar[child][0] = root
		dfs(child, root)
ans = 0

def hnbhai(tc):
	s = sa() + '.'
	(a, b) = s.split('.')[:2]
	i = 0
	while i < len(a) and a[i] == '0':
		i += 1
	a = a[i:]
	i = len(b) - 1
	while i >= 0 and b[i] == '0':
		i -= 1
	b = b[:i + 1]
	a1 = len(a) - 1
	if len(b) == 0:
		i = len(a) - 1
		while i >= 0 and a[i] == '0':
			i -= 1
		a = a[:i + 1]
	if len(a) == 0:
		a1 = len(b) + 1
		i = 0
		while i < len(b) and b[i] == '0':
			i += 1
		b = b[i:]
		a1 = len(b) - a1
	ans = a + b
	if len(ans) > 1:
		ans = ans[0] + '.' + ans[1:]
	if a1 != 0 and ans:
		print(ans + 'E' + str(a1))
		return
	print(ans)
for _ in range(1):
	hnbhai(_ + 1)


x = input()
a = 0
b = 0
sc = x.lstrip('0')
if '.' not in sc:
	sc += '.'
if sc[0] == '.':
	sc = '0' + sc
if sc[-1] == '.':
	sc = sc + '0'
if sc[0] == '0':
	sc = sc.replace('.', '')
	i = 0
	while sc[i] == '0':
		i += 1
		b -= 1
	sc = sc[i] + '.' + sc[i + 1:]
if '.' not in sc and len(sc) > 1:
	sc = sc[0] + '.' + sc[1:]
	b += 1
b += sc.find('.') - 1
sc = sc.replace('.', '')
a = sc[0] + '.' + sc[1:]
a = a.strip('0')
if a[-1] == '.':
	a = a[:-1]
sc = a + ('' if b == 0 else 'E' + str(b))
print(sc)


x = input()
if '.' in x:
	x = x.strip('0')
else:
	x = x.lstrip('0')
l = len(x)
if '.' not in x:
	b = l - 1
	x = x.rstrip('0')
	x = x[0:1] + '.' + x[1:]
	x = x.rstrip('.')
	if b > 0:
		x += 'E'
		x += str(b)
elif x[0] == '.':
	if l == 2:
		x = x.lstrip('.')
		x += 'E'
		x += '-1'
	else:
		x = x.lstrip('.')
		x = x.lstrip('0')
		b = l - len(x)
		x = x[0:1] + '.' + x[1:]
		x = x.rstrip('.')
		x += 'E-'
		x += str(b)
elif x[l - 1] == '.':
	if l == 2:
		x = x.rstrip('.')
	else:
		b = l - 2
		x = x.rstrip('.')
		x = x[0:1] + '.' + x[1:]
		x = x.rstrip('0')
		x = x.rstrip('.')
		x += 'E'
		x += str(b)
elif x[1] == '.':
	pass
else:
	id = x.find('.')
	b = id - 1
	x = x[0:1] + '.' + x[1:id] + x[id + 1:]
	x += 'E'
	x += str(b)
print(x)


o = input()
s = o.replace('.', '')
if s == o:
	o = o + '.'
o = o.strip('0')
s = s.strip('0')
ans = len(o)
a = -1
for i in range(len(o)):
	if o[i] == '.':
		ans = i
	if o[i] != '0' and o[i] != '.' and (a == -1):
		a = i
if a == -1:
	print(0)
else:
	e = 0
	if a > ans:
		e = ans - a
	else:
		e = ans - a - 1
	if len(s) > 1:
		s = s[0] + '.' + s[1:]
	if e == 0:
		print(s)
	else:
		print(s + 'E' + str(e))


s = input()
if '.' not in s:
	s = s + '.00'
s = s.strip('0')
if '.' == s[-1]:
	s = s.strip('.')
	if len(s) == 1:
		print(s.strip('.'))
	else:
		exp = len(s) - 1
		s = s[0] + '.' + s[1:]
		s = s.strip('0')
		s = s.strip('.')
		print(s + 'E' + str(exp))
elif '.' == s[0]:
	s = s.strip('.')
	exp = len(s)
	ind = 0
	while s[ind] == '0':
		ind += 1
	exp = ind + 1
	if ind == len(s) - 1:
		s = s[ind]
	else:
		s = s[ind] + '.' + s[ind + 1:]
	s = s + 'E-' + str(exp)
	print(s)
else:
	arr = s.split('.')
	if len(arr[0]) == 1:
		print(s)
	else:
		exp = len(arr[0]) - 1
		print(arr[0][0] + '.' + arr[0][1:] + arr[1] + 'E' + str(exp))


def main():
	s = input()
	has_dot = False
	zero = True
	first_non_zero = 0
	last_non_zero = 0
	sep = len(s)
	for (i, c) in enumerate(s):
		if c != '0':
			if c == '.':
				sep = i
				has_dot = True
			elif zero:
				zero = False
				first_non_zero = i
				last_non_zero = i
			else:
				last_non_zero = i
	b = sep - first_non_zero
	if b > 0:
		b -= 1
	a = s[first_non_zero:last_non_zero + 1]
	a = ''.join(a.split('.'))
	if len(a) > 1:
		a = a[0] + '.' + a[1:]
	print((a if not zero else '0') + ('E' + str(b) if b != 0 else ''))
main()


s = str(input())
leng = len(s)
ind = s.find('.')
if ind == -1:
	i = 0
	while s[i] == '0':
		i += 1
	s = s[i:]
	if len(s) != 1:
		print(s[0:1] + ('.' + s.strip('0')[1:] if len(s.strip('0')) > 1 else '') + 'E' + str(len(s) - 1))
	else:
		print(s[0:1] + ('.' + s.strip('0')[1:] if len(s.strip('0')) > 1 else ''))
else:
	s = s.strip('0')
	ind = s.find('.')
	i = 0
	while s[i] == '0' or s[i] == '.':
		i += 1
	ind = s.find('.')
	if i >= ind:
		b = ind - i
	else:
		b = ind - 1
	ns = s[0:ind] + s[ind + 1:]
	ns = ns.strip('0')
	if ind != 1:
		print(ns[0:1] + ('.' + ns[1:] if len(ns) > 1 else '') + 'E' + str(b))
	else:
		print(ns[0:1] + ('.' + ns[1:] if len(ns) > 1 else ''))


string_list = input().split(sep='.')
integer = string_list[0].lstrip('0')
if len(string_list) == 1:
	fractional = ''
else:
	fractional = string_list[1].rstrip('0')
if integer:
	if fractional:
		a = '{}.{}{}'.format(integer[0], integer[1:], fractional)
	else:
		a = '{}.{}'.format(integer[0], integer[1:].rstrip('0'))
	d = len(integer) - 1
	if a[-1] == '.':
		a = a[:-1]
	if d > 0:
		print('E'.join((a, str(d))))
	else:
		print(a)
else:
	old_len = len(fractional)
	fractional = fractional.lstrip('0')
	zero_count = old_len - len(fractional)
	a = '{}.{}'.format(fractional[0], fractional[1:])
	d = -zero_count - 1
	if a[-1] == '.':
		a = a[:-1]
	print('E'.join((a, str(d))))


def task(n):
	(l, r) = n.partition('.')[::2]
	l = l.lstrip('0')
	exp = None
	if l:
		exp = len(l) - 1
		r = l[1:] + r
		l = l[0]
	else:
		strippedr = r.lstrip('0')
		exp = len(strippedr) - len(r) - 1
		l = strippedr[0]
		r = strippedr[1:]
	r = r.rstrip('0')
	return l + ('.%s' % r if r else '') + ('E%d' % exp if exp else '')
n = [input()]
for t in n:
	print(task(t))


x = str(input())
n = len(x)
d = 0
while d < n and x[d] == '0':
	d += 1
f = n - 1
while f >= 0 and x[f] == '0':
	f -= 1
f += 1
e = x.count('.')
if x.count('0') >= n - 1 and e:
	print(0)
elif x[d] == '.':
	i = d + 1
	while x[i] == '0':
		i += 1
	if f == i + 1:
		print(x[i] + 'E' + str(d - i))
	else:
		print(x[i] + '.' + x[i + 1:f] + 'E' + str(d - i))
elif x[f - 1] == '.':
	i = f - 2
	while x[i] == '0':
		i -= 1
	if d + 1 == i + 1:
		if f - d - 2:
			print(x[d] + 'E' + str(f - d - 2))
		else:
			print(x[d])
	else:
		print(x[d] + '.' + x[d + 1:i + 1] + 'E' + str(f - d - 2))
elif e == 0:
	if d == f - 1:
		if n - d - 1:
			print(x[d] + 'E' + str(n - d - 1))
		else:
			print(x[d])
	else:
		print(x[d] + '.' + x[d + 1:f] + 'E' + str(n - d - 1))
elif x.index('.') - d == 1:
	print(x[d:f])
else:
	e = x.index('.')
	print(x[d] + '.' + x[d + 1:e] + x[e + 1:f] + 'E' + str(e - d - 1))


s = input()
if '.' not in s:
	s += '.'
s = s.strip('0')
(a, b) = s.split('.')
if len(a):
	b = a[1:] + b
	b = b.rstrip('0')
	l = len(a) - 1
	a = a[0]
else:
	l = len(b.strip('0')) - len(b) - 1
	b = b.strip('0').rstrip('0')
	a = b[0]
	b = b[1:]
print(a, end='')
if len(b):
	print('.' + b, end='')
if l:
	print('E' + str(l))


s = input()
if '.' not in s:
	s = s + '.'
(p, q) = s.strip('0').split('.')
if not p:
	t = q.strip('0')
	e = len(t) - len(q) - 1
	l = t[0]
	r = t[1:]
else:
	e = len(p) - 1
	l = p[0]
	r = (p[1:] + q).rstrip('0')
if l:
	print(l, end='')
else:
	print(0, end='')
if r:
	print('.' + r, end='')
if e:
	print('E%d' % e, end='')


s = input().lstrip('0')
st = 0
if '.' in s:
	di = s.index('.')
	if di > 0:
		st = di - 1
	else:
		st = -1
		ind = 1
		while s[ind] == '0':
			ind += 1
			st -= 1
else:
	st = len(s) - 1
s = s.replace('.', '').strip('0')
if s != '':
	print(s[0], end='')
	if len(s) > 1:
		print('.', end='')
		print(s[1:], end='')
	if st != 0:
		print('E' + str(st))
else:
	print('')


s = list(input())
pos = 0
while s[pos] in ('0', '.'):
	pos += 1
if '.' not in s:
	dot_pos = len(s)
else:
	dot_pos = s.index('.')
	s.pop(dot_pos)
expv = dot_pos - pos
if expv > 0:
	expv -= 1
for t in range(2):
	while s[-1] == '0':
		s.pop()
	s.reverse()
if len(s) > 1:
	s.insert(1, '.')
if expv == 0:
	print(''.join(s))
else:
	print(''.join(s), 'E', expv, sep='')


t = '0' + input() + '.'
n = t.find('.')
s = t[:n] + t[n + 1:-1]
(l, r) = (0, len(s))
while l < r and s[l] == '0':
	l += 1
while l < r and s[r - 1] == '0':
	r -= 1
if l == r:
	exit(print(0))
e = n - l - 1
s = s[l] + '.' + s[l + 1:r] if r - l > 1 else s[l:r]
if e:
	s += 'E' + str(e)
print(s)


s = input().lstrip('0')
if s.find('.') != -1:
	s = s.rstrip('0')
po = s.find('.')
if po == -1:
	po = len(s) - 1
elif po == 0:
	po = -1
	s = s[1:]
	for i in range(len(s)):
		if s[i] == '0':
			po -= 1
		else:
			break
	s = s[-po - 1:]
else:
	po = len(s[:po]) - 1
s = s.replace('.', '')
if len(s) == 0:
	print('0')
else:
	print(s[0] + ('.' if len(s[1:].rstrip('0')) > 0 else '') + s[1:].rstrip('0') + ('E' + str(po) if po != 0 else ''))


x = input()
if '.' in x:
	(c, d) = x.split('.')
else:
	(c, d) = (x, '')
c = c.lstrip('0')
d = d.rstrip('0')
if c:
	b = len(c) - 1
	a = c + d
	a1 = a[0]
	a2 = a[1:].rstrip('0')
	a = (a1 + '.' + a2).rstrip('0').rstrip('.')
	if b == 0:
		print(a, sep='', end='')
	else:
		print(a, 'E', b, sep='', end='')
else:
	b = -1
	for i in d:
		if i == '0':
			b -= 1
		else:
			break
	a = d.lstrip('0')
	a1 = a[0]
	a2 = a[1:].rstrip('0')
	a = (a1 + '.' + a2).rstrip('0').rstrip('.')
	print(a, 'E', b, sep='', end='')


s = input()
if '.' not in s:
	s = s + '.'
s = '0' + s + '0'
dp = s.find('.')
pre = s[0:dp]
post = s[dp + 1:]
i = 0
while i < len(pre) - 1 and pre[i] == '0':
	i += 1
pre = pre[i:]
i = len(post) - 1
while i > 0 and post[i] == '0':
	i -= 1
post = post[:i + 1]
b = 0
if pre == '0':
	b -= len(post)
	pre = post
	post = '0'
	i = 0
	while i < len(pre) - 1 and pre[i] == '0':
		i += 1
	pre = pre[i:]
b += len(pre) - 1
post = pre[1:] + post
pre = pre[0]
i = len(post) - 1
while i > 0 and post[i] == '0':
	i -= 1
post = post[:i + 1]
if post == '0' or post == '':
	print(pre, end='')
else:
	print(pre + '.' + post, end='')
if b != 0:
	print('E' + str(b), end='')
print('')


import re
s = input()
if '.' not in s:
	s += '.'
(a, b) = s.split('.')
p = 0
while p < len(a) and a[p] == '0':
	p += 1
a = a[p:]
if a == '':
	a = '0'
tmp = a[1:]
e = len(tmp)
b = a[1:] + b
p = len(b) - 1
while p >= 0 and b[p] == '0':
	p -= 1
b = b[:p + 1]
a = a[0]
if a == '0' and b != '':
	p = 0
	while b[p] == '0':
		p += 1
	a = b[p]
	b = b[p + 1:]
	e = -p - 1
ans = a + ('.' if b != '' else '') + b + ('E' + str(e) if e != 0 else '')
print(ans)


from sys import stdin, stdout
mot = stdin.readline()
virgule = None
for i in range(len(mot)):
	if mot[i] == '.':
		virgule = i
if virgule != None:
	mot = mot.replace('.', '')
inf = 0
sup = len(mot) - 2
while mot[inf] == '0' and sup > inf:
	inf += 1
if virgule == None:
	puissance = sup - inf
else:
	puissance = virgule - inf - 1
while mot[sup] == '0' and sup > inf:
	sup -= 1
notation = mot[inf]
if inf == sup:
	notation = mot[inf]
else:
	notation = mot[inf] + '.' + mot[inf + 1:sup + 1]
if puissance != 0:
	notation += 'E' + str(puissance)
stdout.write(notation)


def convert(x):
	(a, b) = x.split('.')
	if a == '0' and b == '0':
		return 0
	b = a[1:] + b
	diff = len(a) - 1
	a = a[0]
	b = b.rstrip('0')
	if a == '0':
		for (i, c) in enumerate(b):
			if c != '0':
				a = c
				diff -= 1 + i
				b = b[i + 1:]
				break
	e = ''
	if diff:
		e = 'E{}'.format(diff)
	if b:
		return '{}.{}{}'.format(a, b, e)
	else:
		return '{}{}'.format(a, e)
x = input()
if '.' not in x:
	x += '.'
x = x.rstrip('0').lstrip('0')
if x.startswith('.'):
	x = '0' + x
if x.endswith('.'):
	x += '0'
print(convert(x))


def f(q):
	i = 0
	while i < len(q) and q[i] == '0':
		i += 1
	return q[i:]

def g(q):
	i = len(q)
	while i > 0 and q[i - 1] == '0':
		i -= 1
	return q[:i]
(a, b) = (input() + '.').split('.')[:2]
(a, b) = (f(a), g(b))
e = len(a) - 1
if not b:
	a = g(a)
if not a:
	e = len(b) + 1
	b = f(b)
	e = len(b) - e
s = a + b
s = s[0] + '.' + s[1:] if len(s) > 1 else s
print(s + 'E' + str(e) if s and e else max(s, '0'))


s = input()
s = s.lstrip('0')
dot = s.find('.')

def make_dot(s):
	s = s.rstrip('0')
	if s == '.':
		return ''
	return s

def make_e(s):
	s = s[1:].lstrip('0')
	if s == '':
		return ''
	else:
		return 'E' + s
if dot != -1:
	s = s.rstrip('0')
if dot == -1:
	print(s[0] + make_dot('.' + s[1:]) + make_e('E' + str(len(s) - 1)))
elif dot == 0:
	new_dot = 0
	for i in range(1, len(s)):
		if s[i] != '0':
			new_dot = i
			break
	if new_dot == len(s) - 1:
		print(s[new_dot] + make_e('E' + str(-new_dot)))
	else:
		print(s[new_dot] + make_dot('.' + s[new_dot + 1:]) + make_e('E' + str(-new_dot)))
elif dot - 1 == 0:
	print(s[0] + make_dot('.' + s[1:dot] + s[dot + 1:]))
else:
	print(s[0] + make_dot('.' + s[1:dot] + s[dot + 1:]) + make_e('E' + str(dot - 1)))


s = input()
if '.' not in s:
	s += '.'
s = s.strip('0')
a = s.split('.')
if len(a) != 1 and a[1] == '':
	del a[-1]
if a[0] == '':
	a[0] = '0'
if len(a) == 1 and len(a[0]) == 1:
	print(a[0])
elif len(a[0]) == 1 and a[0] == '0':
	ans = ''
	st = 0
	cnt = 1
	for i in range(len(a[1])):
		if st == 0 and a[1][i] == '0':
			cnt += 1
			continue
		else:
			ans += a[1][i]
			if st == 0 and i != len(a[1]) - 1:
				ans += '.'
			st = 1
	ans += 'E-'
	ans += str(cnt)
	print(ans)
else:
	ans = ''
	st = 0
	cnt = 0
	for i in range(len(a[0])):
		if st == 0:
			ans += a[0][i]
			ans += '.'
			st = 1
		else:
			ans += a[0][i]
			cnt += 1
	if len(a) != 1:
		ans += a[1]
	ans = ans.strip('0')
	if ans[-1] == '.':
		ans = ans[:-1]
	if cnt != 0:
		ans += 'E'
		ans += str(cnt)
	print(ans)


def out(M, p):
	if p == 0:
		return M
	else:
		out = '{0}E{1}'.format(M, p)
		return out
res = 0
a = 0
inp = list(str(input()))
for it in '123456789':
	if (it in inp) == True:
		res += 1
if res == 0:
	res = -1
	print('0')
else:
	res = 0
while res == 0:
	res -= 1
	i = 0
	k = 0
	while inp[k] == '0':
		k += 1
	inp = inp[k:]
	if inp[0] == '.':
		inp.insert(0, '0')
	if inp[len(inp) - 1] == '.':
		inp.remove(inp[len(inp) - 1])
	if ('.' in inp) == True:
		while True:
			if inp[i] != '.':
				i += 1
			else:
				break
		inp.reverse()
		k = 0
		while inp[k] == '0':
			k += 1
		inp = inp[k:]
		if inp[0] == '.':
			inp.remove('.')
		inp.reverse()
		res -= 1
		if ('.' in inp) == False:
			i = len(inp)
			inp.insert(1, '.')
			inp.reverse()
			k = 0
			while inp[k] == '0':
				k += 1
			inp = inp[k:]
			while inp[0] == '.':
				inp.remove('.')
			inp.reverse()
			inp = ''.join(inp)
			a -= 1
			print(out(inp, i - 1))
		if ('.' in inp) == True and len(inp[:i]) == 1:
			i = 0
			if inp[0] == '0':
				inp.remove('.')
				k = 0
				while inp[i] == '0':
					i += 1
				inp = inp[i:]
				inp.insert(1, '.')
			if inp[len(inp) - 1] == '.':
				inp.remove('.')
			a = -1
			print(out(''.join(inp), -i))
		if ('.' in inp) == True and len(inp[:i]) > 1 and (a == 0):
			inp.remove('.')
			inp.insert(1, '.')
			inp = ''.join(inp)
			print(out(inp, i - 1))
	else:
		i = len(inp)
		inp.insert(1, '.')
		inp.reverse()
		k = 0
		while inp[k] == '0':
			k += 1
		inp = inp[k:]
		while inp[0] == '.':
			inp.remove('.')
		inp.reverse()
		inp = ''.join(inp)
		print(out(inp, i - 1))


import sys

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline().strip('\n')
s = input()
if '.' not in s:
	s += '.'
(p, q) = s.strip('0').split('.')
if not p:
	t = q.strip('0')
	e = len(t) - len(q) - 1
	left = t[0]
	right = t[1:]
else:
	e = len(p) - 1
	left = p[0]
	right = (p[1:] + q).rstrip('0')
if left:
	print(left, end='')
else:
	print(0, end='')
if right:
	print('.', right, sep='', end='')
if e:
	print('E%d' % e, end='')


from sys import stdin
s = stdin.readline().strip().lstrip('0')

def toExp(s):
	if len(s) <= 0:
		print(0)
		return
	l = s.split('.')
	if len(l) == 1:
		num = l[0]
		e = len(num[1:])
		if len(num) <= 0:
			print(0)
		if len(num) == 1:
			print(num)
		elif len(num[1:].strip('0')) == 0:
			print(num[0] + 'E' + str(e))
		else:
			print(num[0] + '.' + num[1:].rstrip('0') + 'E' + str(e))
	else:
		(num1, num2) = (l[0], l[1].rstrip('0'))
		num = num2.lstrip('0')
		if len(num1) == 0:
			e = len(num2) - len(num) + 1
			if len(num) == 0:
				print(0)
			elif len(num) == 1:
				print(num + 'E-' + str(e))
			else:
				print(num[0] + '.' + num[1:].rstrip('0') + 'E-' + str(e))
		elif len(num) == 0:
			num = l[0]
			e = len(num[1:])
			if len(num) <= 0:
				print(0)
			if len(num) == 1:
				print(num)
			elif len(num[1:].strip('0')) == 0:
				print(num[0] + 'E' + str(e))
			else:
				print(num[0] + '.' + num[1:].rstrip('0') + 'E' + str(e))
		else:
			e = len(num1) - 1
			if e > 0:
				print(num1[0] + '.' + num1[1:] + num2 + 'E' + str(e))
			else:
				print(num1 + '.' + num2)
toExp(s)


val = ('0' + input() + '.').split('.')
n = len(val[0])
val = ''.join(val)
l = 0
r = len(val)
while l < r and val[l] == '0':
	l += 1
while l < r and val[r - 1] == '0':
	r -= 1
if l >= r:
	print(0)
else:
	exp = n - l - 1
	val = val[l] + '.' + val[l + 1:r] if r - l > 1 else val[l:r]
	print(val if exp == 0 else val + 'E' + str(exp))


def f(s):
	for i in range(len(s)):
		if s[i] != '0':
			return s[i:]
	return '0'

def g(s):
	for i in range(len(s) - 1, -1, -1):
		if s[i] != '0':
			return s[0:i + 1]
	return '0'
P = lambda x: print(x, end='')
s = input()
if s.find('.') < 0:
	s += '.'
t = s.find('.')
a = s[:t]
b = s[t + 1:]
if a == '':
	a = '0'
else:
	a = f(a)
if a != '0':
	P(a[0])
	b = a[1:] + b
	if b == '':
		b = '0'
	else:
		b = g(b)
	if b != '0':
		P('.' + b)
	a = len(a) - 1
	if a != 0:
		P('E')
		P(a)
elif set(b) | set('0') > set('0'):
	i = 0
	while i < len(b) and b[i] == '0':
		i += 1
	a = -i - 1
	if b == '':
		b = '0'
	else:
		b = f(g(b))
	P(b[0])
	if b[1:]:
		P('.' + b[1:])
	P('E')
	P(a)
else:
	P(0)


x = input()
if '.' not in x:
	x += '.'
(a, b) = x.split('.')
e = -len(b)
x = a + b
(l, r) = (0, len(x) - 1)
while x[l] == '0' and l < r:
	l += 1
while x[r] == '0' and l < r:
	r -= 1
	e += 1
(a, b) = (x[l], x[l + 1:r + 1])
e += len(b)
if len(b) > 0:
	a += '.' + b
if e != 0:
	a += 'E' + str(e)
print(a)


number = input().lstrip('0')
if '.' in number:
	number = number.rstrip('0')
if number == '.' or number == '':
	answer = '0'
else:
	if number[0] == '.':
		mantissa = number[1:].lstrip('0')
		exponent = -len(number) + len(mantissa)
	elif '.' in number:
		exponent = number.index('.') - 1
		mantissa = ''.join(number.split('.'))
	else:
		exponent = len(number) - 1
		mantissa = number
	mantissa = mantissa[0] + '.' + mantissa[1:]
	mantissa = mantissa.rstrip('0')
	if mantissa[-1] == '.':
		mantissa = mantissa[:-1]
	answer = mantissa
	if exponent != 0:
		answer += 'E{0}'.format(exponent)
print(answer)


def count_leading_zeroes(inp, leading=True):
	tot = 0
	search_str = inp if leading else inp[::-1]
	for char in search_str:
		if char == '0':
			tot += 1
		else:
			return tot
	return tot
raw = input()
(left, dot, right) = raw.partition('.')
left = left.lstrip('0')
right = right.rstrip('0')
(l, r) = (len(left), len(right))
if l == 0 and r == 0:
	print(0)
else:
	if l == 0:
		B = count_leading_zeroes(right)
		A1 = right[B]
		A2 = right[B + 1:]
		B = -B - 1
	elif r == 0:
		A1 = left[0]
		A2 = left[1:]
		B = len(A2)
	else:
		A1 = left[0]
		A2 = left[1:] + right
		B = len(left[1:])
	A2 = A2.rstrip('0')
	final_str = A1
	if not (A2 == '' or A2 == 0):
		final_str += '.' + A2
	if not (B == '' or B == 0):
		final_str += 'E{B}'.format(B=B)
	print(final_str)


from sys import stdin
s = stdin.readline().strip()
if s.count('0') + s.count('.') == len(s):
	print(0)
elif '.' in s:
	decimal = s.index('.')
	omitR = len(s)
	omitL = 0
	for x in range(len(s) - 1, -1, -1):
		if s[x] == '0' or s[x] == '.':
			omitR = x
		else:
			break
	for x in range(len(s)):
		if s[x] == '0' or s[x] == '.':
			omitL = x + 1
		else:
			break
	outS = [s[omitL]]
	E = decimal - omitL - 1
	if E < 0:
		E += 1
	if omitR - omitL >= 2:
		outS.append('.')
		outS.append(''.join([x for x in s[omitL + 1:omitR] if x != '.']))
	if E != 0:
		outS.append('E')
		outS.append(str(E))
	print(''.join(outS))
else:
	omitR = len(s)
	omitL = 0
	for x in range(len(s) - 1, -1, -1):
		if s[x] == '0' or s[x] == '.':
			omitR = x
		else:
			break
	for x in range(len(s)):
		if s[x] == '0' or s[x] == '.':
			omitL = x + 1
		else:
			break
	outS = [s[omitL]]
	E = len(s) - omitL - 1
	if omitR - omitL >= 2:
		outS.append('.')
		outS.append(s[omitL + 1:omitR])
	if E != 0:
		outS.append('E')
		outS.append(str(E))
	print(''.join(outS))


s = input()
(n, a) = ('', '')
if '.' in s:
	(n, a) = s.split('.')
else:
	n = s
n = n.lstrip('0')
a = a.rstrip('0')
if n == '':
	n = '0'
if n == '0':
	for i in range(len(a)):
		if a[i] != '0':
			f = a[:i + 1]
			l = a[i + 1:]
			print((f.lstrip('0') + '.' + l.rstrip('0')).rstrip('.') + 'E-' + str(i + 1))
			exit()
nn = len(n)
p = n[:1] + '.' + n[1:] + a
p = p.rstrip('0')
p = p.rstrip('.')
if nn == 1:
	t = ''
else:
	t = 'E' + str(nn - 1)
print(p + t)


x = input()
n = len(x)
t = x
(i, j) = (0, n - 1)
while t[i] == '0':
	i += 1
b = -1
for k in range(i, n):
	if t[k] == '.':
		b = 1
if b == 1:
	while t[j] == '0':
		j -= 1
temp = t[i:j + 1]
n = len(temp)
index = n
for i in range(n):
	if temp[i] == '.':
		index = i
		break
exp = ''
if index == 1:
	exp = temp.strip('.').rstrip('0')
elif index == 0:
	i = index + 1
	while ord(temp[i]) <= ord('0'):
		i += 1
	t = temp[i + 1:].replace('.', '').rstrip('0')
	x = '.' + t
	if t == '':
		x = ''
	exp = temp[i] + x + 'E' + str(index - i)
else:
	t = temp[1:].replace('.', '').rstrip('0')
	x = '.' + t
	if t == '':
		x = ''
	exp = temp[0] + x + 'E' + str(index - 1)
print(exp)


def trim(s):
	n = len(s)
	while n > 0 and s[-1] == '0':
		s.pop()
		n -= 1
	if n:
		return '.' + ''.join(s)
	else:
		return ''
txt = list(input().strip())
i = 0
n = len(txt)
while i < n and txt[i] == '0':
	i += 1
txt = txt[i:]
if '.' not in txt:
	txt.append('.')
floatingPointIndex = txt.index('.')
if floatingPointIndex == 0:
	shift = 1
	n = len(txt)
	while shift < n and txt[shift] == '0':
		shift += 1
	if shift == n:
		print(0)
	else:
		E = 'E-' + str(shift)
		print(txt[shift] + trim(txt[shift + 1:]) + E)
else:
	E = ''
	if floatingPointIndex > 1:
		E = 'E' + str(floatingPointIndex - 1)
	print(txt[0] + trim(txt[1:floatingPointIndex] + txt[floatingPointIndex + 1:]) + E)


s = input()
if '.' not in s:
	s += '.'
(left, right) = s.strip('0').split('.')
if not left:
	t = right.strip('0')
	e = len(t) - len(right) - 1
	l = t[0]
	r = t[1:]
else:
	e = len(left) - 1
	l = left[0]
	r = (left[1:] + right).rstrip('0')
if l:
	print(l, end='')
else:
	print(0, end='')
if r:
	print('.' + r, end='')
if e:
	print('E%d' % e)


import sys
s = input()
if '.' not in s:
	s += '.0'
if s[0] == '.':
	s = '0' + s
if s[-1] == '.':
	s = s + '0'
i = 0
while s[i] == '0':
	i += 1
if s[i] == '.':
	i -= 1
s = s[i:]
i = len(s) - 1
while s[i] == '0':
	i -= 1
if s[i] == '.':
	i += 1
s = s[:i + 1]
i = s.index('.')
if i == 1 and s[0] == '0':
	e = 1
	i = 2
	while s[i] == '0':
		i += 1
		e += 1
	res = s[i] + '.' + s[i + 1:]
	if res[-1] == '.':
		res = res[:-1]
	res += 'E' + str(-e)
	print(res)
	sys.exit(0)
if i == 1:
	i = len(s) - 1
	while s[i] == '0':
		i -= 1
	s = s[:i + 1]
	if s[-1] == '.':
		s = s[:-1]
	print(s)
	sys.exit(0)
e = i - 1
s = s.replace('.', '')
s = s[0] + '.' + s[1:]
i = len(s) - 1
while s[i] == '0':
	i -= 1
s = s[:i + 1]
if s[-1] == '.':
	s = s[:-1]
res = s + 'E' + str(e)
print(res)


def main():
	s = input()
	print(solver(s))

def solver(s):
	s = s[firstNonLeadingZero(s):]
	dotIndex = s.find('.')
	result = None
	if dotIndex == -1:
		s += '.'
		dotIndex = len(s) - 1
	s = s[:firstTrailingZero(s)]
	if dotIndex == 0:
		firstIndex = firstNonZeroDigit(s)
		if firstIndex == -1:
			return '0'
		elif firstIndex == len(s) - 1:
			result = '{}E{}'.format(s[firstIndex], -firstIndex)
		else:
			result = '{}.{}E{}'.format(s[firstIndex], s[firstIndex + 1:], -firstIndex)
	elif dotIndex == 1:
		if len(s) == 2:
			return s[0]
		else:
			return s
	else:
		digits = s[:dotIndex] + s[dotIndex + 1:]
		digits = digits[:firstTrailingZero(digits)]
		if digits[1:] == '0' * (len(digits) - 1):
			result = '{}E{}'.format(digits[0], dotIndex - 1)
		else:
			result = '{}.{}E{}'.format(digits[0], digits[1:], dotIndex - 1)
	return result

def firstNonZeroDigit(s):
	for i in range(len(s)):
		if s[i] not in ['.', '0']:
			return i
	return -1

def firstTrailingZero(s):
	index = len(s) - 1
	while s[index] == '0':
		index -= 1
	return index + 1

def firstNonLeadingZero(s):
	index = 0
	while s[index] == '0':
		index += 1
	return index
main()


import re

def get_expo(n):
	result = ''
	if n[len(n) - 1] == '.':
		li = len(n) - 2
		zeros = 0
		fi = 0
		while True:
			if n[fi] == '0':
				fi += 1
			else:
				break
		while True:
			if n[li] == '0':
				li -= 1
				zeros += 1
			else:
				break
		n = n[fi:li + 1]
		zeros += len(n) - 1
		if len(n) == 1 and zeros == 0:
			result = n[0]
		elif len(n) == 1 and zeros > 0:
			result = n[0] + 'E' + str(zeros)
		else:
			result = n[0] + '.' + n[1:] + 'E' + str(zeros)
		return result
	elif not re.search('\\.', n):
		li = len(n) - 1
		fi = 0
		zeros = 0
		while True:
			if n[fi] == '0':
				fi += 1
			else:
				break
		while True:
			if n[li] == '0':
				li -= 1
				zeros += 1
			else:
				break
		n = n[fi:li + 1]
		zeros += len(n) - 1
		if len(n) == 1 and zeros == 0:
			result = n[0]
		elif len(n) == 1 and zeros > 0:
			result = n[0] + 'E' + str(zeros)
		else:
			result = n[0] + '.' + n[1:] + 'E' + str(zeros)
		return result
	elif n[0] == '.':
		li = len(n) - 1
		fi = 1
		zeros = 1
		while True:
			if n[fi] == '0':
				fi += 1
				zeros += 1
			else:
				break
		while True:
			if n[li] == '0':
				li -= 1
			else:
				break
		n = n[fi:li + 1]
		if len(n) == 1:
			result = n[0] + 'E-' + str(zeros)
		else:
			result = n[0] + '.' + n[1:] + 'E-' + str(zeros)
		return result
	else:
		li = len(n) - 1
		fi = 0
		zeros = 0
		while True:
			if n[fi] == '0':
				fi += 1
			else:
				break
		while True:
			if n[li] == '0':
				li -= 1
			else:
				break
		n = n[fi:li + 1]
		if n[0] == '.':
			zeros = 1
			i = 1
			while True:
				if n[i] == '0':
					zeros += 1
					i += 1
				else:
					break
			n = n[i:]
			if len(n) == 1:
				result = n[0] + 'E-' + str(zeros)
			else:
				result = n[0] + '.' + n[1:] + 'E-' + str(zeros)
			return result
		elif n[len(n) - 1] == '.':
			if len(n) == 2:
				return n[0]
			else:
				li = len(n) - 2
				zeros = 0
				while True:
					if n[li] == '0':
						li -= 1
						zeros += 1
					else:
						break
				n = n[:li + 1]
				zeros += len(n) - 1
				if len(n) == 1:
					result = n[0] + 'E' + str(zeros)
				else:
					result = n[0] + '.' + n[1:] + 'E' + str(zeros)
				return result
		elif str(n).index('.') > 1:
			index = str(n).index('.')
			result = n[0] + '.' + n[1:index] + n[index + 1:] + 'E' + str(len(n[1:index]))
			return result
		else:
			return n
print(get_expo(str(input())))


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 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)
s = input()
if '.' not in s:
	s = list(s)
	s = s[::-1]
	while len(s) > 0 and s[-1] == '0':
		s.pop()
	s = s[::-1]
	c = len(s)
	if len(s) == 0:
		print(0)
	elif len(s) == 1:
		print(''.join(s))
	else:
		while len(s) > 0 and s[-1] == '0':
			s.pop()
		if len(s) == 1:
			print(s[0] + 'E' + str(c - 1))
		else:
			ans = ''
			ans += s[0] + '.'
			for i in range(1, len(s)):
				ans += s[i]
			print(ans + 'E' + str(c - 1))
else:
	(before, after) = s.split('.')
	before = list(before)
	after = list(after)
	while len(after) > 0 and after[-1] == '0':
		after.pop()
	before = before[::-1]
	while len(before) > 0 and before[-1] == '0':
		before.pop()
	before = before[::-1]
	if len(before) == 0 and len(after) == 0:
		print(0)
	elif len(before) == 0:
		ans = ''
		c = 0
		after = after[::-1]
		while len(after) > 0 and after[-1] == '0':
			after.pop()
			c += 1
		after = after[::-1]
		ans += after[0]
		if len(after) == 1:
			print(ans + 'E' + '-' + str(abs(c + 1)))
		else:
			ans += '.'
			for i in range(1, len(after)):
				ans += after[i]
			print(ans + 'E' + '-' + str(abs(c + 1)))
	elif len(after) == 0:
		ans = ''
		c = len(before)
		while len(before) > 0 and before[-1] == '0':
			before.pop()
		if len(before) == 1:
			if c - 1 == 0:
				print(before[0])
			else:
				print(before[0] + 'E' + str(c - 1))
		else:
			ans = ''
			ans += before[0] + '.'
			for i in range(1, len(before)):
				ans += before[i]
			print(ans + 'E' + str(c - 1))
	else:
		c = len(before)
		ans = ''
		if len(before) == 1:
			ans += before[0]
			ans += '.'
			for i in range(0, len(after)):
				ans += after[i]
			print(ans)
		else:
			ans += before[0]
			ans += '.'
			for i in range(1, len(before)):
				ans += before[i]
			for i in range(0, len(after)):
				ans += after[i]
			print(ans + 'E' + str(c - 1))


num = input()
ns = num.split('.')
pre = ns[0]
if len(ns) == 1:
	post = ''
else:
	post = ns[1]
i = 0
while i < len(pre) and pre[i] == '0':
	i += 1
pre = pre[i:]
i = len(post)
while i > 0 and post[i - 1] == '0':
	i -= 1
post = post[:i]
Eval = 0
if len(pre) == 0:
	i = 0
	while i < len(post) and post[i] == '0':
		Eval -= 1
		i += 1
	post = post[i:]
	if len(post) == 0:
		pre = '0'
		Eval = 0
	else:
		pre = post[0]
		post = post[1:]
		Eval -= 1
else:
	i = len(pre) - 1
	Eval += i
	post = pre[1:] + post
	pre = pre[:1]
i = len(post)
while i > 0 and post[i - 1] == '0':
	i -= 1
post = post[:i]
finstr = pre
if len(post) != 0:
	finstr += '.' + post
if Eval != 0:
	finstr += 'E' + str(Eval)
print(finstr)


import sys
s = sys.stdin.buffer.readline().decode('utf-8').rstrip()
if '.' not in s:
	s += '.'
(i, f) = s.split('.')
for j in range(len(i)):
	if i[j] != '0':
		i = i[j:]
		break
else:
	i = ''
for j in range(len(f) - 1, -1, -1):
	if f[j] != '0':
		f = f[:j + 1]
		break
else:
	f = ''
if len(i) == 0:
	fn = len(f)
	e = 0
	for fi in range(fn):
		e -= 1
		if f[fi] != '0':
			fs = '.' + f[fi + 1:] if fi < fn - 1 else ''
			sys.stdout.buffer.write(f'{f[fi]}{fs}E{e}'.encode('utf-8'))
			break
	else:
		print(0)
else:
	e = len(i) - 1
	f = i[1:] + f
	i = i[0]
	for j in range(len(f) - 1, -1, -1):
		if f[j] != '0':
			f = f[:j + 1]
			break
	else:
		f = ''
	es = f'E{e}' if e else ''
	fs = '.' + f if f else ''
	sys.stdout.buffer.write(f'{i}{fs}{es}'.encode('utf-8'))


x = input()
if '.' not in x:
	x += '.'
(a, b) = x.strip('0').split('.')
if len(a):
	e = len(a) - 1
	b = (a[1:] + b).rstrip('0')
	a = a[0]
else:
	e = -len(b)
	b = b.lstrip('0')
	a = b[0]
	b = b[1:]
	e += len(b)
print('%s%s%s' % (a, '.' + b if b != '' else '', 'E' + str(e) if e != 0 else ''))


x = input()
pointindex = x.find('.')
if pointindex == -1:
	y = x.lstrip('0')
	print(y[0], end='')
	e = len(y) - 1
	z = y[1:].rstrip('0')
	if z != '':
		print('.' + z, end='')
	if e:
		print('E' + str(e))
elif x[:pointindex].lstrip('0') == '':
	z = x[pointindex + 1:].rstrip('0')
	for i in range(len(z)):
		if z[i] == '0':
			continue
		else:
			print(z[i], end='')
			e = -(i + 1)
			y = z[i + 1:].rstrip('0')
			if y != '':
				print('.' + y + 'E' + str(e))
			else:
				print('E' + str(e))
			break
else:
	y = x[:pointindex].lstrip('0')
	print(y[0], end='')
	e = len(y) - 1
	z = (y[1:] + x[pointindex + 1:]).rstrip('0')
	if z != '':
		print('.' + z, end='')
	if e:
		print('E' + str(e))


num = input()
before_decimal = ''
after_decimal = ''
if '.' in num:
	(before_decimal, after_decimal) = num.split('.')
else:
	before_decimal = num
b = list(before_decimal)
a = list(after_decimal)
while len(a) > 0 and a[-1] == '0':
	a.pop()
b.reverse()
while len(b) > 0 and b[-1] == '0':
	b.pop()
b.reverse()
if len(a) == 0 and len(b) == 0:
	print(0)
elif len(b) == 0:
	pow = 0
	idx = 0
	while idx < len(a):
		if a[idx] != '0':
			break
		else:
			pow += 1
			idx += 1
	if len(a) - idx != 1:
		print(a[idx], '.', ''.join(a[idx + 1:len(a)]), sep='', end='')
	else:
		print(a[idx], sep='', end='')
	print(f'E-{pow + 1}')
else:
	start = b[0]
	pow = len(b) - 1
	b = b[1:len(b)]
	b.extend(a)
	while len(b) > 0 and b[-1] == '0':
		b.pop()
	if len(b) == 0:
		print(start, sep='', end='')
	else:
		print(start, '.', ''.join(b), sep='', end='')
	if pow > 0:
		print(f'E{pow}')


s = input()
if not '.' in s:
	s = s + '.'
(a, b) = s.strip('0').split('.')
if not a:
	newb = b.strip('0')
	(poc, l, r) = (len(newb) - len(b) - 1, newb[0], newb[1:])
else:
	(poc, l, r) = (len(a) - 1, a[0], (a[1:] + b).rstrip('0'))
if l:
	print(l, end='')
else:
	print(0, end='')
if r:
	print('.' + r, end='')
if poc:
	print('E%d' % poc, end='')


import sys
from bisect import bisect_right as rb
from collections import deque
from queue import PriorityQueue
input_ = lambda : sys.stdin.readline().strip('\r\n')
ii = lambda : int(input_())
il = lambda : list(map(int, input_().split()))
ilf = lambda : list(map(float, input_().split()))
ip = lambda : input_()
fi = lambda : float(input_())
ap = lambda ab, bc, cd: ab[bc].append(cd)
li = lambda : list(input_())
pr = lambda x: print(x)
prinT = lambda x: print(x)
f = lambda : sys.stdout.flush()
inv = lambda x: pow(x, mod - 2, mod)
mod = 10 ** 9 + 7

def f(q):
	i = 0
	while i < len(q) and q[i] == '0':
		i += 1
	return q[i:]

def g(q):
	i = len(q) - 1
	while i >= 0 and q[i] == '0':
		i -= 1
	return q[:i + 1]
s = ip()
(a, b) = (s + '.').split('.')[:2]
a = f(a)
b = g(b)
l = len(a) - 1
if not b:
	a = g(a)
if not a:
	l = len(b) + 1
	b = f(b)
	l = len(b) - l
ans = a + b
if len(ans) > 1:
	ans = ans[0] + '.' + ans[1:]
if ans and l:
	print(ans + 'E' + str(l))
else:
	print(ans)


x = input()

def dn(x):
	n = 0
	for i in x[::-1]:
		if i == '0':
			n -= 1
		elif i == '.':
			n -= 1
			pass
		elif n == 0:
			return x
		else:
			return x[:n]
if '.' not in x:
	x += '.'
for (n, i) in enumerate(x):
	if i != '0':
		x = x[n:]
		break
d = x.find('.') - 1
if d < 0:
	for (n, i) in enumerate(x[1:]):
		if i != '0':
			d -= n
			break
if x == '.':
	print(0)
elif d == 0:
	if len(x) == 2:
		print(x[0])
	else:
		print(dn(x))
elif d > 0:
	exp = 'E' + str(d)
	print(dn(x[0] + '.' + x[1:d + 1] + x[d + 2:]) + exp)
else:
	exp = 'E' + str(d)
	x = x[-d:]
	x = x[0] + '.' + x[1:]
	print(dn(x) + exp)


import re
a = input()
if not '.' in a:
	a += '.'
(a, b) = a.strip('0').split('.')
st = 0
if len(a) > 1:
	st = len(a) - 1
	b = (a[1:] + b).rstrip('0')
	a = a[0]
elif len(a) == 0:
	r = b.strip('0')
	st = -(len(b) - len(r) + 1)
	a = r[0]
	b = r[1:]
if a:
	print(a, end='')
if b:
	print('.' + b, end='')
if st:
	print('E' + str(st))


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

def strip(seq, elem):
	n = len(seq)
	first = n
	last = 0
	for i in range(n):
		if seq[i] != elem:
			first = i
			break
	for j in range(n - 1, first - 1, -1):
		if seq[j] != elem:
			last = j
			break
	return seq[first:last + 1]

def rstrip(seq, elem):
	n = len(seq)
	last = None
	for j in range(n - 1, -1, -1):
		if seq[j] != elem:
			last = j
			break
	return seq[:last + 1]

def solve(num):
	n = len(num)
	if n == 1:
		return (['0'], 0)
	period_idx = num.index('.')
	if period_idx == 0:
		first = None
		for i in range(1, n):
			if num[i] != '0':
				exp = -i
				return ([num[i], '.'] + num[i + 1:], exp)
	else:
		exp = period_idx - 1
		del num[period_idx]
		num = rstrip(num, '0')
		if len(num) == 1:
			return (num, exp)
		return ([num[0], '.'] + num[1:], exp)
num = list(input())
if '.' not in num:
	num += '.'
num = strip(num, '0')
(mant, exp) = solve(num)
if mant[-1] == '.':
	mant.pop()
print(''.join(mant) + ('' if exp == 0 else 'E' + str(exp)))


import unittest
from random import randint, shuffle
from sys import maxsize

class StressTest(unittest.TestCase):
	known_values = (('16', '1.6E1'), ('01.23400', '1.234'), ('.100', '1E-1'), ('1', '1'), ('.458900', '4.589E-1'), ('0.0012', '1.2E-3'), ('100.', '1E2'), ('1.00045', '1.00045'))

	def test_known_cases(self):
		for (a, expected) in self.known_values:
			self.assertEqual(expected, solution(a))

	def test_all_cases(self):
		while True:
			break

def cleanZeros(a):
	p = 0
	q = len(a) - 1
	while p < len(a) and a[p] == '0':
		p += 1
	while q >= 0 and a[q] == '0':
		q -= 1
	return a[p:q + 1]

def popZeros(a):
	q = len(a) - 1
	while q >= 0 and a[q] == '0':
		q -= 1
	return a[:q + 1]

def solution(a):
	if '.' not in a:
		a = a + '.'
	a = cleanZeros(a)
	if a[0] != '.':
		dotIndex = a.index('.')
		exp = str(dotIndex - 1)
		a = ''.join(a.split('.'))
		afterDot = popZeros(a[1:])
		dot = '.' if afterDot else ''
		end = 'E' + exp if exp != '0' else ''
		return a[0] + dot + afterDot + end
	else:
		p = 1
		while p < len(a) and a[p] == '0':
			p += 1
		a = a[p:]
		afterDot = popZeros(a[1:])
		dot = '.' if afterDot else ''
		end = 'E-' + str(p) if p >= 1 else ''
		return a[0] + dot + afterDot + end
print(solution(input()))


s = input()
idx = 0
for i in range(len(s)):
	if s[i] != '0':
		break
	idx += 1
s = s[idx:len(s)]
if '.' in s:
	cnt = 0
	for i in range(len(s)):
		if s[i] == '.':
			break
		cnt += 1
	(s1, s2) = s.split('.')
	e = ''
	if len(s2) == 0 or len(s1) >= 1:
		s = s1[0] + '.' + s1[1:len(s1)] + s2
		if len(s1) > 1:
			e = 'E' + str(len(s1) - 1)
		else:
			e = ''
	else:
		cnt = 1
		idx = 0
		for i in range(len(s2)):
			if s2[i] != '0':
				idx = i + 1
				break
			cnt += 1
		e = 'E-' + str(cnt)
		s = s2[idx - 1] + '.' + s2[idx:len(s2)]
	idx = len(s)
	for i in range(len(s) - 1, -1, -1):
		if s[i] != '0':
			break
		idx -= 1
	s = s[:idx]
	if s[len(s) - 1] == '.':
		s = s[:len(s) - 1]
	print(s + e)
elif len(s) == 1:
	print(s)
else:
	e = 'E' + str(len(s) - 1)
	s = s[0] + '.' + s[1:len(s)]
	idx = len(s)
	for i in range(len(s) - 1, -1, -1):
		if s[i] != '0':
			break
		idx -= 1
	s = s[:idx]
	if s[len(s) - 1] == '.':
		s = s[:len(s) - 1]
	print(s + e)


import sys
input = lambda : sys.stdin.readline().strip()
s = input()
a = 0
while a < len(s) and (s[a] == '.' or s[a] == '0'):
	a += 1
r = len(s) if '.' not in s else s.index('.')
if '.' in s:
	s = s[:r] + s[r + 1:]
e = r - a
if e > 0:
	e -= 1
j = len(s) - 1
while s[j] == '0' and j >= 0:
	j -= 1
s = s[:j + 1]
j = 0
while s[j] == '0' and j < len(s):
	j += 1
s = s[j:]
if len(s) > 1:
	s = s[0] + '.' + s[1:]
if e == 0:
	print(s)
else:
	print(s, 'E', e, sep='')