Problem: At many competitions that have a word «cup» in its official name the winner is presented with an actual cup. This time the organizers of one unusual programming competition have decided to please the winner even more and to add a nameplate to the cup with the handle of the winner.

The nameplate is to be rectangular and the text on it will be printed as a table of several rows and columns. Having some measurements done, the organizers have found out that the number a of rows cannot be greater than 5 while the number b of columns cannot exceed 20. Every cell of the table will contain either an asterisk («*») or a letter of user's handle.

Furthermore, the organizers want the rows of the table to be uniform, which means that the number of asterisks used in different rows should differ by at most one (i.e. you can't have two asterisks in the first row and none in the second). The main goal, however, is to obtain the winner's handle precisely when reading the table from top to bottom and from left to right in every row (skipping asterisks).

The organizers want for the nameplate to have as few rows as possible and among all valid tables with the minimum number of rows they want to choose the one that has the minimum number of columns.

The winner is not yet determined so your task is to write a program that, given a certain handle, generates the necessary table.

Input

The only line contains one string s (1 ≤ |s| ≤ 100), comprised of uppercase and lowercase Latin letters, — the handle of the winner.

Output

In the first line output the minimum number a of rows in the table and the minimum number b of columns in an optimal table with rows.

The following a lines should contain b characters each — any valid table.

Examples

Input


tourist


Output


1 7
tourist


Input


MyNameIsLifeIAmForeverByYourSideMyNameIsLife


Output


3 15
MyNameIsLifeIAm
ForeverByYourSi
deMyNameIsL*ife

Solution (in JAVA):

Solution:
//package com.company;

import java.io.*;
import java.util.*;

public class Main {

    FastScanner in;
    PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt();
        if(n == 1){
            out.print(0);
        } else {
            int[] a = new int[n];
            int[] prev1 = new int[n];
            int[] prev12 = new int[n];
            int[] prev2 = new int[n];
            int[] ans1 = new int[n];
            int[] ans2 = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt() - 1;
                prev1[i] = -1;
                prev2[i] = -1;
                ans1[i] = Integer.MAX_VALUE / 2;
                ans2[i] = Integer.MAX_VALUE / 2;
            }
            ArrayDeque<Integer> q = new ArrayDeque<>();
            for (int i = 1; i < Math.min(7, n); i++) {
                if (ans1[i] > 1) {
                    ans1[i] = 1;
                    prev1[i] = 0;
                    q.add(i);
                    prev12[i] = 2;
                }
            }
            while (!q.isEmpty()) {
                int cur = q.poll();
                if (a[cur] == cur) {
                    for (int i = 1; cur + i < Math.min(cur + 7, n); i++) {
                        if (ans1[cur + i] > Math.min(ans1[cur], ans2[cur]) + 1) {
                            ans1[cur + i] = Math.min(ans1[cur], ans2[cur]) + 1;
                            prev1[cur + i] = cur;
                            q.add(cur + i);
                            if (ans1[cur] < ans2[cur]) {
                                prev12[cur + i] = 1;
                            } else {
                                prev12[cur + i] = 2;
                            }
                        }
                    }
                } else {
                    if (ans2[a[cur]] > ans1[cur]) {
                        ans2[a[cur]] = ans1[cur];
                        prev2[a[cur]] = cur;
                        q.add(a[cur]);
                    }
                    for (int i = 1; cur + i < Math.min(cur + 7, n); i++) {
                        if (ans1[cur + i] > ans2[cur] + 1) {
                            ans1[cur + i] = ans2[cur] + 1;
                            prev1[cur + i] = cur;
                            q.add(cur + i);
                            prev12[cur + i] = 2;
                        }
                    }
                }
            }
            out.println(Math.min(ans1[n - 1], ans2[n - 1]));
            int tp = 0;
            if (ans1[n - 1] < ans2[n - 1]) {
                tp = 1;
            } else {
                tp = 2;
            }
            int cur = n - 1;
            ArrayList<Integer> arr = new ArrayList<>();
            while (cur != 0) {
                if (tp == 1) {
                    arr.add(cur - prev1[cur]);
                    if (prev12[cur] == 2) {
                        tp = 2;
                    }
                    cur = prev1[cur];
                } else {
                    tp = 1;
                    cur = prev2[cur];
                }
            }
            for (int i = arr.size() - 1; i >= 0; i--) {
                out.print(arr.get(i) + " ");
            }
        }
    }
    int n;
    int[][] g;
    int[] col;
    ArrayList<Integer> ans;
    void dfs(int v, int c){
        for(int i = 0; i < n; i++){
            if(g[v][i] == 1 && col[i] == 0){
                col[i] = c;
                dfs(i, c);
            }
        }
    }

    private void solve2() throws IOException {
        n = in.nextInt();
        g = new int[n][n];
        col = new int[n];
        for(int i = 0; i < n; i++){
            int k = in.nextInt();
            for(int j = 0; j < k; j++){
                g[i][in.nextInt() - 1] = 1;
            }
        }
        int c = 0;
        for(int i = 0; i < n; i++){
            if(col[i] == 0){
                c++;
                col[i] = c;
                dfs(i, c);
            }
        }
        if(c > 2){
            out.print(-1);
        } else if(c == 2){
            int sz1 = 0, sz2 = 0;
            for(int i = 0; i < n; i++){
                if(col[i] == 1){
                    sz1++;
                } else {
                    sz2++;
                }
            }
            out.println(Math.min(sz1, sz2));
            if(sz1 < sz2){
                for(int i = 0; i < n; i++){
                    if(col[i] == 1){
                        out.print((i + 1) + " ");
                    }
                }
            } else {
                for(int i = 0; i < n; i++){
                    if(col[i] == 2){
                        out.print((i + 1) + " ");
                    }
                }
            }

        } else {
            boolean flag = true;
            for(int i = 0; i < n; i++){
                for(int j = 0; j < n; j++){
                    if(i!=j){
                        if(g[i][j] == 0){
                            flag = false;
                        }
                    }
                }
            }
            if(flag){
                out.print(0);
            } else {
                out.print(-1);
            }
        }

    }

    private void solveA() throws IOException {
        int n = in.nextInt(), k = in.nextInt();
        TreeMap<Integer, Long> a = new TreeMap<>();
        for(int i = 0; i < n; i++){
            int cur = in.nextInt();
            a.put(cur, a.getOrDefault(cur, (long)0) + 1);
        }
        long bl = 0;
        long ans = 0;
        for(int i : a.keySet()){
            long cur = a.get(i);
            long am = cur % k == 0 ? cur/k : cur/k + 1;
            if(am > bl){
                bl =  am;
            }
        }
        for(int i : a.keySet()){
            long cur = a.get(i);
            long am = cur % k == 0 ? cur/k : cur/k + 1;
            if(am < bl){
                ans += cur % k == 0 ? (bl - am)*k : (k - cur%k) + (bl - am)*k;
            } else {
                ans +=cur % k != 0 ? k - cur%k : 0;
            }
        }
        out.print(ans);
    }

    private void solveB() throws IOException {
        String s = in.next();
        int n = s.length();
        int str = 300;
        int zv = 0;
        int stlb = 0;
        for(int i = 1; i <= Math.min(n, 5); i++){
            stlb = n % i != 0 ? n/i + 1 : n/i;
            if(stlb <= 20){
                if(str > i) {
                    str = i;
                    zv = n % i != 0 ? i - n%i : 0;
                }
                break;
            }
        }
        int cnt = 0;
        out.println(str + " " + stlb);
        for(int i = 0; i < str; i++){
            for(int j = 0; j < stlb; j++) {
                if (j == stlb - 1 && zv != 0) {
                    zv--;
                    out.print('*');
                } else {
                    out.print(s.charAt(cnt));
                    cnt++;
                }
            }
            out.println();


        }
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s){
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while(st == null || !st.hasMoreTokens()){
                st = new StringTokenizer(br.readLine());
            }
            return st.nextToken();
        }
        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next().replace(',', '.'));
        }

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); //new FileInputStream(".in");
        out = new PrintWriter(System.out);
        solveB();
        out.flush();
        out.close();
    }






    public static void main(String[] args) throws IOException {
        new Main().run();

    }

}