Polycarp is very careful. He even types numeric sequences carefully, unlike his classmates. If he sees a sequence without a space after the comma, with two spaces in a row, or when something else does not look neat, he rushes to correct it. For example, number sequence written like "1,2 ,3,..., 10" will be corrected to "1, 2, 3, ..., 10".

In this task you are given a string s, which is composed by a concatination of terms, each of which may be: 

  * a positive integer of an arbitrary length (leading zeroes are not allowed), 
  * a "comma" symbol (","), 
  * a "space" symbol (" "), 
  * "three dots" ("...", that is, exactly three points written one after another, also known as suspension points). 



Polycarp wants to add and remove spaces in the string s to ensure the following: 

  * each comma is followed by exactly one space (if the comma is the last character in the string, this rule does not apply to it), 
  * each "three dots" term is preceded by exactly one space (if the dots are at the beginning of the string, this rule does not apply to the term), 
  * if two consecutive numbers were separated by spaces only (one or more), then exactly one of them should be left, 
  * there should not be other spaces. 



Automate Polycarp's work and write a program that will process the given string s.

Input

The input data contains a single string s. Its length is from 1 to 255 characters. The string s does not begin and end with a space. Its content matches the description given above.

Output

Print the string s after it is processed. Your program's output should be exactly the same as the expected answer. It is permissible to end output line with a line-break character, and without it.

Examples

Input

1,2 ,3,...,     10


Output

1, 2, 3, ..., 10


Input

1,,,4...5......6


Output

1, , , 4 ...5 ... ...6


Input

...,1,2,3,...


Output

..., 1, 2, 3, ...
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.ListIterator;

/**
 * Created by sergejboldin on 16.09.14.
 */
public class C81B {
    final static private int stateExit       = 0;
    final static private int stateNumber     = 1;
    final static private int stateComma      = 2;
    final static private int stateThreePoint = 3;
    final static private int stateGap        = 4;
    private static int state;

    private static int getState(char ch) {

        if ("0123456789".indexOf(ch) >= 0) {
            return stateNumber;
        }
        if (".".indexOf(ch) == 0) {
            return stateThreePoint;
        }
        if (",".indexOf(ch) == 0) {
            return stateComma;
        }
        if (" ".indexOf(ch) == 0) {
            return stateGap;
        }

        return -1;
    }


    private static class Tape {
        private char[] chars;
        private int position;

        public Tape(char[] chars) {
            this.chars = chars;
            this.position = -1;
            if (chars.length > 0) {
                this.position = 0;
            }
        }

        public boolean isNextChar() {
            if ((this.position + 1) < chars.length)  {
                return true;
            }
            return false;
        }

        public char getNextChar() {
            if ((this.position + 1) < chars.length) {
                this.position += 1;
            }
            return chars[this.position];
        }

        public char getChar() {
            return chars[this.position];
        }
    }

    private static class Item {
        public String value;
        public int type;

        public Item(String value, int type) {
            this.value = value;
            this.type = type;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        Tape tape = new Tape(reader.readLine().toCharArray());
        reader.close();

        ArrayList<Item> list = new ArrayList<Item>();

        String item = "";
        char ch;

        ch = tape.getChar();
        state = getState(ch);

        boolean isContinued = true;
        while (isContinued) {

            switch (state) {
                case stateExit:
                    isContinued = false;
                    break;

                case stateNumber:
                    item = "" + ch;
                    while (true) {
                        if (tape.isNextChar()) {
                            ch = tape.getNextChar();
                            state = getState(ch);
                            if (state == stateNumber) {
                                item += ch;
                            } else {
                                list.add(new Item(item, stateNumber));
                                break;
                            }
                        } else {
                            state = stateExit;
                            list.add(new Item(item, stateNumber));
                            break;
                        }
                    }

                    break;

                case stateComma:
                    item = "" + ch;
                    list.add(new Item(item, stateComma));

                    if (tape.isNextChar()) {
                        ch = tape.getNextChar();
                        state = getState(ch);
                    } else {
                        state = stateExit;
                    }
                    break;

                case stateThreePoint:
                    item = "" + ch;
                    item += tape.getNextChar();
                    item += tape.getNextChar();
                    list.add(new Item(item, stateThreePoint));

                    if (tape.isNextChar()) {
                        ch = tape.getNextChar();
                        state = getState(ch);
                    } else {
                        state = stateExit;
                    }
                    break;

                case stateGap:
                    while (true) {
                        if (tape.isNextChar()) {
                            ch = tape.getNextChar();
                            state = getState(ch);
                            if (state == stateGap) {
                                continue;
                            } else {
                                break;
                            }
                        } else {
                            state = stateExit;
                            break;
                        }
                    }
                    break;
            }
        }

        ListIterator<Item> iter = list.listIterator();
        boolean previous;
        boolean next;
        Item it;
        Item prevItem = null;
        String answer = "";
        while (iter.hasNext()) {
            previous = iter.hasPrevious();
            it = iter.next();
            next = iter.hasNext();

            switch (it.type) {
                case stateNumber:
                    if (prevItem != null && prevItem.type == stateNumber) {
                        answer += " ";
                    }
                    answer += it.value;
                    break;

                case stateComma:
                    answer += it.value;
                    if (next) {
                        answer += " ";
                    }
                    break;

                case stateThreePoint:
                    if (previous && prevItem.type != stateComma) {
                        answer += " ";
                    }
                    answer += it.value;
                    break;
            }
            prevItem = it;
        }
        System.out.println(answer);
    }
}
