You are given a positive decimal number x.

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

Let x = a·10b, 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 106. 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
import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class CodeForces {
    static HashMap<Long, Long> cost;
    public static void main(String[] args) throws FileNotFoundException {
        InputReader inputReader = new InputReader(System.in);
        PrintWriter printWriter = new PrintWriter(System.out, true);

        String input = inputReader.readLine();
        int dotIndex = input.indexOf('.');
        StringBuilder wholePart, decimalPart;
        if (dotIndex < 0) {
            wholePart = new StringBuilder(input);
        } else {
            wholePart = new StringBuilder(input.substring(0, dotIndex));
        }
        if (dotIndex < 0) {
            decimalPart = new StringBuilder();
        } else {
            decimalPart = new StringBuilder(input.substring(dotIndex + 1, input.length()));
        }

        int index = wholePart.length();
        int next;
        for (int i = 1; i < 10; i++) {
            next = wholePart.indexOf(String.valueOf(i));
            if (next != -1 && next < index) {
                index = next;
            }
        }
        next = wholePart.indexOf("0");
        if (next != -1 && index > next) wholePart.delete(0, index);
        index = 0;
        for (int i = 1; i < 10; i++) {
            next = decimalPart.lastIndexOf(String.valueOf(i));
            if (next != -1 && next > index) {
                index = next;
            }
        }
        next = decimalPart.lastIndexOf("0");
        if (next != -1 && index < next) decimalPart.delete(index + 1, decimalPart.length());
        while (wholePart.length() > 0 && wholePart.charAt(0) == '0') {
            wholePart.delete(0, 1);
        }
        while (decimalPart.length() > 0 && decimalPart.charAt(decimalPart.length() - 1) == '0') {
            decimalPart.delete(0, 1);
        }


        if (decimalPart.length() <= 0 && wholePart.length() > 0) {
            index = wholePart.length() - 1;
            int E = wholePart.length() - 1;
            while (index >= 0 && wholePart.charAt(index) == '0') {
                index--;
            }
            if (index < wholePart.length() - 1) {
                wholePart.delete(index + 1, wholePart.length());
            }
            if (wholePart.length() > 1) {
                wholePart.insert(1, '.');
            }
            if (E > 0) {
                wholePart.append("E").append(E);
            }
            printWriter.print(wholePart);
        } else if (decimalPart.length() > 0 && wholePart.length() > 0) {
            index = 0;
            int E = wholePart.length() - 1;
            wholePart.insert(1, '.').append(decimalPart);
            if (E > 0) {
                wholePart.append("E").append(E);
            }
            printWriter.print(wholePart);
        } else if (decimalPart.length() > 0) {
            index = 0;
            while (decimalPart.charAt(index) == '0') {
                index++;
            }
            decimalPart.delete(0, index);
            if (decimalPart.length() > 1) {
                decimalPart.insert(1, '.');
            }
            printWriter.print(decimalPart.append('E').append(-(index + 1)));
        } else {
            printWriter.print("0");
        }


        printWriter.close();
    }

    private static long getLCA(long u, long v) {
        List<Long> a = new ArrayList<>();
        List<Long> b = new ArrayList<>();
        while (u > 0) {
            a.add(u);
            u >>>= 1;
        }
        while (v > 0) {
            b.add(v);
            v >>>= 1;
        }
        Collections.reverse(a);
        Collections.reverse(b);
        long res = -1;
        for (int i = 0; i < a.size() && i < b.size(); i++) {
            if (a.get(i).equals(b.get(i))) {
                res = a.get(i);
            }
        }
        return res;
    }

    private static void addCost(long u, int w) {
        if (cost.containsKey(u)) {
            cost.replace(u, cost.get(u) + w);
        } else {
            cost.put(u, (long) w);
        }
    }

    private static void shuffleArray(int[] a) {
        Random r = new Random();
        int tmp;
        for (int i = 1; i < a.length; i++) {
            tmp = r.nextInt(i + 1);
            int val = a[tmp];
            a[tmp] = a[i];
            a[i] = val;
        }
    }

    private static class InputReader {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
        }

        public int[] nextIntArray(int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; ++i) {
                array[i] = nextInt();
            }
            return array;
        }

        public long[] nextLongArray(int size) {
            long[] array = new long[size];
            for (int i = 0; i < size; ++i) {
                array[i] = nextLong();
            }
            return array;
        }

        public double[] nextDoubleArray(int size) {
            double[] array = new double[size];
            for (int i = 0; i < size; ++i) {
                array[i] = nextDouble();
            }
            return array;
        }

        public String[] nextStringArray(int size) {
            String[] array = new String[size];
            for (int i = 0; i < size; ++i) {
                array[i] = next();
            }
            return array;
        }

        public boolean[][] nextBooleanTable(int rows, int columns, char trueCharacter) {
            boolean[][] table = new boolean[rows][columns];
            for (int i = 0; i < rows; ++i) {
                String row = next();
                assert row.length() == columns;
                for (int j = 0; j < columns; ++j) {
                    table[i][j] = (row.charAt(j) == trueCharacter);
                }
            }
            return table;
        }

        public char[][] nextCharTable(int rows, int columns) {
            char[][] table = new char[rows][];
            for (int i = 0; i < rows; ++i) {
                table[i] = next().toCharArray();
                assert table[i].length == columns;
            }
            return table;
        }

        public int[][] nextIntTable(int rows, int columns) {
            int[][] table = new int[rows][columns];
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    table[i][j] = nextInt();
                }
            }
            return table;
        }

        public long[][] nextLongTable(int rows, int columns) {
            long[][] table = new long[rows][columns];
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    table[i][j] = nextLong();
                }
            }
            return table;
        }

        public double[][] nextDoubleTable(int rows, int columns) {
            double[][] table = new double[rows][columns];
            for (int i = 0; i < rows; i++) {
                for (int j = 0; j < columns; j++) {
                    table[i][j] = nextDouble();
                }
            }
            return table;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public BigInteger nextBigInteger() {
            return new BigInteger(next());
        }

        public boolean hasNext() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String line = readLine();
                if (line == null) {
                    return false;
                }
                tokenizer = new StringTokenizer(line);
            }
            return true;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(readLine());
            }
            return tokenizer.nextToken();
        }

        public String readLine() {
            String line;
            try {
                line = reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return line;
        }
    }
}
