#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ gets(char *);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ scanf(char *, int *);
int strlen(char *);
int main() {
  int n, i, j, len, m, limit;
  char a[1000], b[1000][1000];
  while (scanf("%d", &n) && n) {
    getchar();
    gets(a);
    len = strlen(a);
    m = len - 1;
    limit = len / n;
    for (i = n - 1; i >= 0; i--) {
      for (j = 0; j < limit; j++) {
        b[i][j] = a[m];
        m--;
      }
    }
    for (i = 0; i < n; i++) {
      for (j = 0; j < limit; j++) {
        printf("%c", b[i][j]);
      }
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf4660,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe97(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1070 <scanf@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0xf4651(%rbp)
je     1194 <main+0x44>
cmpl   $0x0,-0x8(%rbp)
setne  %al
mov    %al,-0xf4651(%rbp)
mov    -0xf4651(%rbp),%al
test   $0x1,%al
jne    11a7 <main+0x57>
jmp    12d8 <main+0x188>
mov    $0x0,%al
call   1050 <getchar@plt>
lea    -0x410(%rbp),%rdi
call   1060 <gets@plt>
lea    -0x410(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jl     1253 <main+0x103>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1240 <main+0xf0>
movslq -0x18(%rbp),%rax
mov    -0x410(%rbp,%rax,1),%dl
movslq -0xc(%rbp),%rcx
lea    -0xf4650(%rbp),%rax
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11f6 <main+0xa6>
jmp    1245 <main+0xf5>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    11e5 <main+0x95>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12c5 <main+0x175>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12b2 <main+0x162>
movslq -0xc(%rbp),%rcx
lea    -0xf4650(%rbp),%rax
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0xd66(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    126d <main+0x11d>
jmp    12b7 <main+0x167>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    125a <main+0x10a>
lea    0xd3a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1162 <main+0x12>
xor    %eax,%eax
add    $0xf4660,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf4648,%rsp
lea    0xe98(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1070 <scanf@plt>
test   %rax,%rax
je     139b <main+0x24b>
cmpl   $0x0,0xc(%rsp)
je     139b <main+0x24b>
lea    0x1(%rsp),%r14
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1050 <getchar@plt>
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <gets@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %eax,%r9d
mov    0xc(%rsp),%r8d
cltd
idiv   %r8d
test   %r8d,%r8d
jle    1370 <main+0x220>
mov    %eax,%r13d
add    $0xffffffff,%r9d
mov    %eax,%r12d
mov    %r12d,%eax
and    $0xffffffe0,%eax
imul   $0x3e8,%r8,%r11
lea    0x28(%rsp),%rcx
lea    (%rcx,%r11,1),%rdi
lea    0x18(%rsp),%rcx
add    %rcx,%r11
mov    %r8,%r10
pxor   %xmm3,%xmm3
jmp    121f <main+0xcf>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%r10),%rcx
add    $0xfffffffffffffc18,%rdi
add    $0xfffffffffffffc18,%r11
cmp    $0x1,%r10
mov    %rcx,%r10
jle    1310 <main+0x1c0>
test   %r13d,%r13d
jle    1200 <main+0xb0>
movslq %r9d,%r9
cmp    $0x20,%r13d
jae    1240 <main+0xf0>
xor    %ecx,%ecx
jmp    12d9 <main+0x189>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r14,%r9,1),%rbx
sub    %rax,%r9
xor    %ebp,%ebp
nopl   0x0(%rax)
movdqu -0x10(%rbx),%xmm0
movdqu (%rbx),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm1,-0x10(%rdi,%rbp,1)
movdqu %xmm0,(%rdi,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffe0,%rbx
cmp    %rbp,%rax
jne    1250 <main+0x100>
mov    %rax,%rcx
cmp    %r12,%rax
je     1200 <main+0xb0>
lea    (%r11,%rcx,1),%rbp
mov    %r12,%rbx
sub    %rcx,%rbx
lea    (%rsp,%r9,1),%rcx
add    $0x10,%rcx
xor    %esi,%esi
nopl   (%rax)
movzbl (%rcx),%edx
mov    %dl,0x0(%rbp,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rbx
jne    12f0 <main+0x1a0>
sub    %rsi,%r9
jmp    1200 <main+0xb0>
nopl   0x0(%rax)
test   %r8d,%r8d
jle    1370 <main+0x220>
lea    0x400(%rsp),%rbx
xor    %r15d,%r15d
jmp    1343 <main+0x1f3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15
movslq %r8d,%rax
add    $0x3e8,%rbx
cmp    %rax,%r15
jge    1370 <main+0x220>
test   %r13d,%r13d
jle    1330 <main+0x1e0>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsbl (%rbx,%rbp,1),%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1350 <main+0x200>
mov    0xc(%rsp),%r8d
jmp    1330 <main+0x1e0>
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc7f(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1070 <scanf@plt>
test   %rax,%rax
je     139b <main+0x24b>
cmpl   $0x0,0xc(%rsp)
jne    1190 <main+0x40>
xor    %eax,%eax
add    $0xf4648,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%c\00"
@.str.2 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca [1000 x i8]
%9 = alloca [1000 x [1000 x i8]]
store i32 0, i32* %1
br label %10
10: ; preds = %86, %0
%11 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%12 = icmp ne i64 %11, 0
br i1 %12, label %13, label %16
13: ; preds = %10
%14 = load i32, i32* %2
%15 = icmp ne i32 %14, 0
br label %16
16: ; preds = %13, %10
%17 = phi i1 [ false, %10 ], [ %15, %13 ]
br i1 %17, label %18, label %88
18: ; preds = %16
%19 = call i32 (...) @getchar()
%20 = getelementptr inbounds [1000 x i8], [1000 x i8]* %8, i64 0, i64 0
%21 = call i32 @gets(i8* %20)
%22 = getelementptr inbounds [1000 x i8], [1000 x i8]* %8, i64 0, i64 0
%23 = call i32 @strlen(i8* %22)
store i32 %23, i32* %5
%24 = load i32, i32* %5
%25 = sub nsw i32 %24, 1
store i32 %25, i32* %6
%26 = load i32, i32* %5
%27 = load i32, i32* %2
%28 = sdiv i32 %26, %27
store i32 %28, i32* %7
%29 = load i32, i32* %2
%30 = sub nsw i32 %29, 1
store i32 %30, i32* %3
br label %31
31: ; preds = %56, %18
%32 = load i32, i32* %3
%33 = icmp sge i32 %32, 0
br i1 %33, label %34, label %59
34: ; preds = %31
store i32 0, i32* %4
br label %35
35: ; preds = %52, %34
%36 = load i32, i32* %4
%37 = load i32, i32* %7
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %55
39: ; preds = %35
%40 = load i32, i32* %6
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [1000 x i8], [1000 x i8]* %8, i64 0, i64 %41
%43 = load i8, i8* %42
%44 = load i32, i32* %3
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %9, i64 0, i64 %45
%47 = load i32, i32* %4
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [1000 x i8], [1000 x i8]* %46, i64 0, i64 %48
store i8 %43, i8* %49
%50 = load i32, i32* %6
%51 = add nsw i32 %50, -1
store i32 %51, i32* %6
br label %52
52: ; preds = %39
%53 = load i32, i32* %4
%54 = add nsw i32 %53, 1
store i32 %54, i32* %4
br label %35
55: ; preds = %35
br label %56
56: ; preds = %55
%57 = load i32, i32* %3
%58 = add nsw i32 %57, -1
store i32 %58, i32* %3
br label %31
59: ; preds = %31
store i32 0, i32* %3
br label %60
60: ; preds = %83, %59
%61 = load i32, i32* %3
%62 = load i32, i32* %2
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %86
64: ; preds = %60
store i32 0, i32* %4
br label %65
65: ; preds = %79, %64
%66 = load i32, i32* %4
%67 = load i32, i32* %7
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %82
69: ; preds = %65
%70 = load i32, i32* %3
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %9, i64 0, i64 %71
%73 = load i32, i32* %4
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [1000 x i8], [1000 x i8]* %72, i64 0, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32 %77)
br label %79
79: ; preds = %69
%80 = load i32, i32* %4
%81 = add nsw i32 %80, 1
store i32 %81, i32* %4
br label %65
82: ; preds = %65
br label %83
83: ; preds = %82
%84 = load i32, i32* %3
%85 = add nsw i32 %84, 1
store i32 %85, i32* %3
br label %60
86: ; preds = %60
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %10
88: ; preds = %16
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [1000 x i8]
%3 = alloca [1000 x [1000 x i8]]
%4 = bitcast i32* %1 to i8*
%5 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 0, i64 0
%7 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%8 = icmp ne i64 %7, 0
%9 = load i32, i32* %1
%10 = icmp ne i32 %9, 0
%11 = select i1 %8, i1 %10, i1 false
br i1 %11, label %12, label %101
12: ; preds = %0, %94
%13 = call i32 (...) @getchar()
%14 = call i32 @gets(i8* %5)
%15 = call i32 @strlen(i8* %5)
%16 = load i32, i32* %1
%17 = sdiv i32 %15, %16
%18 = icmp sgt i32 %16, 0
br i1 %18, label %19, label %94
19: ; preds = %12
%20 = add nsw i32 %15, -1
%21 = icmp sgt i32 %17, 0
%22 = zext i32 %16 to i64
%23 = zext i32 %17 to i64
%24 = icmp ult i32 %17, 32
%25 = and i64 %23, 4294967264
%26 = icmp eq i64 %25, %23
br label %37
27: ; preds = %67, %63
%28 = phi i64 [ %44, %63 ], [ %73, %67 ]
%29 = trunc i64 %28 to i32
br label %30
30: ; preds = %27, %37
%31 = phi i32 [ %39, %37 ], [ %29, %27 ]
%32 = icmp sgt i64 %38, 1
br i1 %32, label %37, label %33
33: ; preds = %30
br i1 %18, label %34, label %94
34: ; preds = %33
%35 = icmp sgt i32 %17, 0
%36 = zext i32 %17 to i64
br label %76
37: ; preds = %19, %30
%38 = phi i64 [ %22, %19 ], [ %40, %30 ]
%39 = phi i32 [ %20, %19 ], [ %31, %30 ]
%40 = add nsw i64 %38, -1
br i1 %21, label %41, label %30
41: ; preds = %37
%42 = sext i32 %39 to i64
br i1 %24, label %64, label %43
43: ; preds = %41
%44 = sub nsw i64 %42, %25
br label %45
45: ; preds = %45, %43
%46 = phi i64 [ 0, %43 ], [ %61, %45 ]
%47 = sub i64 %42, %46
%48 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %47
%49 = getelementptr inbounds i8, i8* %48, i64 -15
%50 = bitcast i8* %49 to <16 x i8>*
%51 = load <16 x i8>, <16 x i8>* %50
%52 = shufflevector <16 x i8> %51, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%53 = getelementptr inbounds i8, i8* %48, i64 -31
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = shufflevector <16 x i8> %55, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%57 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %40, i64 %46
%58 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %58
%59 = getelementptr inbounds i8, i8* %57, i64 16
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %60
%61 = add nuw i64 %46, 32
%62 = icmp eq i64 %61, %25
br i1 %62, label %63, label %45
63: ; preds = %45
br i1 %26, label %27, label %64
64: ; preds = %41, %63
%65 = phi i64 [ 0, %41 ], [ %25, %63 ]
%66 = phi i64 [ %42, %41 ], [ %44, %63 ]
br label %67
67: ; preds = %64, %67
%68 = phi i64 [ %74, %67 ], [ %65, %64 ]
%69 = phi i64 [ %73, %67 ], [ %66, %64 ]
%70 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %69
%71 = load i8, i8* %70
%72 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %40, i64 %68
store i8 %71, i8* %72
%73 = add nsw i64 %69, -1
%74 = add nuw nsw i64 %68, 1
%75 = icmp eq i64 %74, %23
br i1 %75, label %27, label %67
76: ; preds = %34, %89
%77 = phi i32 [ %16, %34 ], [ %90, %89 ]
%78 = phi i64 [ 0, %34 ], [ %91, %89 ]
br i1 %35, label %79, label %89
79: ; preds = %76, %79
%80 = phi i64 [ %85, %79 ], [ 0, %76 ]
%81 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %78, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = call i32 @putchar(i32 %83)
%85 = add nuw nsw i64 %80, 1
%86 = icmp eq i64 %85, %36
br i1 %86, label %87, label %79
87: ; preds = %79
%88 = load i32, i32* %1
br label %89
89: ; preds = %87, %76
%90 = phi i32 [ %88, %87 ], [ %77, %76 ]
%91 = add nuw nsw i64 %78, 1
%92 = sext i32 %90 to i64
%93 = icmp slt i64 %91, %92
br i1 %93, label %76, label %94
94: ; preds = %89, %12, %33
%95 = call i32 @putchar(i32 10)
%96 = call i64 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%97 = icmp ne i64 %96, 0
%98 = load i32, i32* %1
%99 = icmp ne i32 %98, 0
%100 = select i1 %97, i1 %99, i1 false
br i1 %100, label %12, label %101
101: ; preds = %94, %0
ret i32 0
}