public class Solution {
  public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        String s=in.next();
        double row=Math.floor(Math.pow(s.length(),0.5));
        double col=Math.ceil(Math.pow(s.length(),0.5));
        String ans ="";
        for(int i=0;i<col;i++){
        	int j=0;
        	while(i+j<s.length()){
        		ans=ans+s.substring(i+j,i+j+1);
            	j=(int) (j+col);}
        	ans=ans+" ";}
        System.out.println(ans);}}

static void message(String string){
        int row = (int)Math.floor(Math.sqrt(string.length()));
        int column = (int)Math.ceil(Math.sqrt(string.length()));
        if(row * column < string.length()) row = column;
        for(int i = 0; i < column; i++){
            for(int j = i; j < string.length(); j = j + column ){
                System.out.print(string.charAt(j));
            }
            System.out.print(" ");
        }
    }

string s = Console.ReadLine().Trim();
var rowLength = (int)Math.Sqrt(s.Length)+1;
if(Math.Sqrt(s.Length)-(int)Math.Sqrt(s.Length) == 0)
    rowLength = (int)Math.Sqrt(s.Length);

for(int index = 0; index < rowLength;index++){
    var verticalStrip = string.Empty;
    var k = index;   
    
    while( k < s.Length){
        verticalStrip += s[k];
        k += rowLength;
    }
    Console.Write(verticalStrip+ " ");
}

s = list(input().strip())
L =  len(s)
row = math.floor(L**(1/2))
col = math.ceil(L**(1/2))

for i in range(col):
    x = 0     
    while True:
        try:
            print(s[i+x],end='')
            x+= col
        except:
            break        
    print(' ',end='')

int main(){
    char* s = (char *)malloc(10240 * sizeof(char));
    scanf("%s",s);
    int len = strlen(s);
    int columns = ceil(sqrt(len));
    for(int i = 0; i < columns; i++) {
        for(int j = i; j < len; j += columns) {
            printf("%c", s[j]);
        }
        printf(" ");
    }
    return 0;
}

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;

int main() {
    int r,c;
    string s;
    cin>>s;
    int l=s.length();
    r=floor(sqrt(l));
    c=ceil(sqrt(l));
    if((r*c)<l)
        r++;
    for(int i=0;i<c;i++)
    {
        for(int j=i;j<l;j+=c)
        {
            cout<<s[j];
        }
        cout<<" ";
    }
    return 0;
}

package main
import (
    "fmt"
    "math"
)

func main() {
    var text string
    fmt.Scan(&text)
    
    l := len(text)
    m := math.Sqrt(float64(l))
    lower := int(math.Floor(m))
    upper := int(math.Ceil(m))
    
    // upper * upper must be >= l, so it safe to do following. Or just simply do one lower += 1
    for lower * upper < l {
        lower += 1
    }
    
    index := 0
    for i := 0; i < upper; i++ {
        for j := 0; j < lower; j++ {
            index = i + j * upper
            if index >= l {
                break
            }
            fmt.Printf("%c", text[index])
        }
        fmt.Printf(" ")
    }
}

int n=str.length();
  int col=ceil(sqrt(n));
  for(int i=0;i<col;i++)
  {
    for(int j=0;i+j<n;j+=col)
    {
      cout<<str[i+j];
    }
    cout<<" ";
  }

#!/bin/python3

import sys
s = input().strip()
rows = int(len(s) ** 0.5)
if rows < len(s) ** 0.5:
    columns = rows + 1
else:
    columns = rows
    
for i in range(columns):
    print(s[i::columns], end = ' ')

void encryption(string s) {
int n = s.length();
    int x = floor(sqrt(n));
    int y = ceil(sqrt(n));
    int k=0;
    if((x*y)<n)
        x++;
    for(int i=0; i<y; i++){
        for(int j=0; j<x; j++){
            k=i+(j*y);
            if(s[k]!='\0')
            cout<<s[k];
        }
        cout<<" ";
    }

}

def sqrt(l); Math.sqrt l end

def encryption(s)
  # strip off any whitespaces
  s.gsub! /\s+/, ''

  # length of the string without whitespaces
  len = s.length

  # let us set the (rows, cols) based on floor & ceil of the string length
  rows, cols = sqrt(len).floor, sqrt(len).ceil

  # if the product of rows and cols is less than string length, set both to same
  rows = cols = sqrt(len).ceil if rows * cols < len

  # each index of this array will hold chars (c..row), where for each c,
  # we get all the values until row
  encrypted = []
  (0...rows).each do |i|
    encrypted << s[((i % rows) * cols)..((i % rows) * cols) + cols - 1].chars
  end

  # we use the first entry and zip it with the rest of entries,
  # and join them to make a complete string
  encrypted[0].zip(*encrypted[1..-1]).map do |cipher|
    cipher.compact.join + ' '
  end.join
end

import math

def encryption(s):
    s = s.replace(" ", "")
    sr = len(s) ** 0.5  # which is square root
    col = int(sr) if math.ceil(sr) == int(sr) else int(sr)+1

    word = ''
    for i in range(col):
        p = i
        while p < len(s):
            word = word + s[p]
            p += col
        word = word + ' '

    return word

for(int i = 0; i < w; i++) {
     for(int j = 0; j < h; j++) {
           if(j  w + i < z.length()) o += z.charAt(j * w + i);
					 else break;
     }
     o += ' ';
}

int main(){
    string s;
    cin >> s;
    
    // Remove spaces from string
    for (auto it = s.begin(); it != s.end();){
        if (*it == ' ') s.erase(it);
        else ++it;
    }
    
    // Caculate grid sizes
    int floor = sqrt(s.size());
    int ceiling = sqrt(s.size()) + 1;
    
    if (floor * ceiling < s.size())
        (floor < ceiling)? floor += 1 : ceiling += 1;
    
    // Create grid
    vector<string> encrypted(ceiling);
    for (int i = 0; i < floor; ++i) {
        for (int j = 0; j < ceiling; ++j) {
            encrypted[j] += s[j + i * ceiling];
        }
    }
    // Ugly output method to remove trailing spaces
    for (int i = 0; i < encrypted.size(); ++i) {
        std::cout << encrypted[i];
        if (i < encrypted.size()-1) std::cout << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

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

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String message = in.nextLine();

        String ciphertext = encrypt(message);
        System.out.println(ciphertext);
    }

    private static char[][] buildGrid(String message, int rows, int columns) {
        char[][] grid = new char[rows][columns];
        char[] chars = message.toCharArray();
        int row;
        int column;
        for (int i = 0; i < chars.length; i++) {
            row = i / columns;
            column = i % columns;
            grid[row][column] = chars[i];
        }

        return grid;
    }

    private static String encrypt(String message) {
        int length = message.length();
        double lengthSqrt = Math.sqrt(length);
        int rows = (int) Math.floor(lengthSqrt);
        int columns = (int) Math.ceil(lengthSqrt);
        rows = (rows * columns < length) ? columns : rows;

        char[][] grid = buildGrid(message, rows, columns);
        
        StringJoiner sj = new StringJoiner(" ");
        StringBuilder sb = new StringBuilder();
        int charsTotal = 0;
        for (int column = 0; column < columns; column++) {
            sb.setLength(0);
            for (int row = 0; row < rows; row++) {
                if (charsTotal <= length) {
                    sb.append(grid[row][column]);
                    charsTotal++;
                }
            }
            sj.add(sb.toString());
        }

        return sj.toString();
    }
}

import math
s = input()
w = int(math.ceil(len(s.strip())**.5))
print(" ".join([s[i::w] for i in range(w)]))

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.next();
        int[] gridSize = findMinimumArea(s.length());
        char[][] grid = new char[gridSize[0]][gridSize[1]];
        
        int cursor = 0;
        for(int row = 0; row < gridSize[0]; row++) {
            for(int col = 0; col < gridSize[1]; col++) {
                if(cursor >= s.length()) {
                    break;
                } else {
                    grid[row][col] = s.charAt(cursor);
                    cursor++;
                }
            }
        }
        
        String ans = "";
        for(int col = 0; col < gridSize[1]; col++) {
            for(int row = 0; row < gridSize[0]; row++) {
                ans += grid[row][col];
            }
            ans += " ";
        }
        
        System.out.println(ans.trim());
        
    }
    
    // [rows, cols]
    private static int[] findMinimumArea(int n) {
        int min = (int)Math.round(Math.floor(Math.sqrt(n)));
        int max = (int)Math.ceil(Math.sqrt(n));
        for(int row = min; row <= max; row++) {
            for(int col = row; col <= max; col++) {
                if(row * col >= n) {
                    return new int[]{row,col};
                }
            }
        }
        throw new Error("shouldn't get here : " + n);
    }
}