int main() {
  int col, len, row, i, j, k;
  char clave[200], ans[200];
  char **matrix;
  while (1) {
    scanf("%d", &col);
    if (!col)
      return 0;
    scanf("%s", clave);
    len = strlen(clave);
    ans[len] = '\0';
    row = len / col;
    matrix = (char **)malloc(sizeof(char *) * row);
    for (i = 0; i < row; i++)
      matrix[i] = (char *)malloc(sizeof(char) * col);
    k = 0;
    for (i = 0; i < row; i++) {
      if (i % 2 == 0) {
        for (j = 0; j < col; j++) {
          matrix[i][j] = clave[k++];
        }
      } else {
        for (j = col - 1; j >= 0; j--) {
          matrix[i][j] = clave[k++];
        }
      }
    }
    k = 0;
    for (i = 0; i < col; i++) {
      for (j = 0; j < row; j++) {
        ans[k++] = matrix[j][i];
      }
    }
    for (i = 0; i < row; i++)
      free(matrix[i]);
    free(matrix);
    printf("%s\n", ans);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe97(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
cmpl   $0x0,-0x8(%rbp)
jne    1189 <main+0x39>
xor    %eax,%eax
add    $0x1d0,%rsp
pop    %rbp
ret
lea    -0xf0(%rbp),%rsi
lea    0xe6c(%rip),%rdi
mov    $0x0,%al
call   1070 <scanf@plt>
lea    -0xf0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xc(%rbp)
movslq -0xc(%rbp),%rax
movb   $0x0,-0x1c0(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,-0x10(%rbp)
movslq -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x1c8(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1217 <main+0xc7>
movslq -0x8(%rbp),%rdi
shl    $0x0,%rdi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x1c8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11de <main+0x8e>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12f8 <main+0x1a8>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1295 <main+0x145>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1290 <main+0x140>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
cltq
mov    -0xf0(%rbp,%rax,1),%dl
mov    -0x1c8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    124c <main+0xfc>
jmp    12e5 <main+0x195>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     12e0 <main+0x190>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
cltq
mov    -0xf0(%rbp,%rax,1),%dl
mov    -0x1c8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    129e <main+0x14e>
jmp    12e5 <main+0x195>
jmp    12ea <main+0x19a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1225 <main+0xd5>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1370 <main+0x220>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    135d <main+0x20d>
mov    -0x1c8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x1c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
cltq
mov    %cl,-0x1c0(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1319 <main+0x1c9>
jmp    1362 <main+0x212>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1306 <main+0x1b6>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13a5 <main+0x255>
mov    -0x1c8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1377 <main+0x227>
mov    -0x1c8(%rbp),%rdi
call   1030 <free@plt>
lea    -0x1c0(%rbp),%rsi
lea    0xc47(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1162 <main+0x12>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
lea    0xe98(%rip),%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
cmpl   $0x0,0x8(%rsp)
je     1528 <main+0x3d8>
lea    0xe3(%rsp),%r12
jmp    11c3 <main+0x73>
nopl   0x0(%rax)
mov    %rbp,%rdi
call   1030 <free@plt>
lea    0xe0(%rsp),%rdi
call   1040 <puts@plt>
lea    0xe54(%rip),%rdi
lea    0x8(%rsp),%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
cmpl   $0x0,0x8(%rsp)
je     1528 <main+0x3d8>
lea    0xe39(%rip),%rdi
lea    0x10(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <scanf@plt>
mov    %rbx,%rdi
call   1050 <strlen@plt>
cltq
movb   $0x0,0xe0(%rsp,%rax,1)
mov    0x8(%rsp),%r15d
cltd
idiv   %r15d
mov    %eax,%r14d
movslq %eax,%rbx
lea    0x0(,%rbx,8),%rdi
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    %ebx,%r13d
test   %ebx,%ebx
jle    1415 <main+0x2c5>
mov    %r12,%rbx
mov    %r15d,0xc(%rsp)
movslq %r15d,%r15
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r15,%rdi
call   1060 <malloc@plt>
mov    %rax,0x0(%rbp,%r12,8)
add    $0x1,%r12
cmp    %r12,%r13
jne    1230 <main+0xe0>
test   %r14d,%r14d
mov    %rbx,%r12
pxor   %xmm3,%xmm3
mov    0xc(%rsp),%r15d
jle    1415 <main+0x2c5>
xor    %r11d,%r11d
xor    %ecx,%ecx
jmp    127d <main+0x12d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
cmp    %r13,%r11
je     1410 <main+0x2c0>
mov    0x8(%rsp),%r8d
test   $0x1,%r11b
jne    12c0 <main+0x170>
test   %r8d,%r8d
jle    1270 <main+0x120>
mov    0x0(%rbp,%r11,8),%rdx
movslq %ecx,%rsi
lea    (%rsp,%rsi,1),%rdi
add    $0x10,%rdi
xor    %esi,%esi
nop
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,(%rdx,%rsi,1)
add    $0x1,%rsi
movslq 0x8(%rsp),%rbx
cmp    %rbx,%rsi
jl     12a0 <main+0x150>
add    %esi,%ecx
jmp    1270 <main+0x120>
nopl   0x0(%rax)
test   %r8d,%r8d
jle    1270 <main+0x120>
mov    0x0(%rbp,%r11,8),%rdx
movslq %ecx,%r10
cmp    $0x20,%r8d
jb     1320 <main+0x1d0>
lea    -0x1(%r8),%rbx
lea    -0x1(%r8),%ecx
cmp    %ebx,%ecx
jb     1320 <main+0x1d0>
mov    %rbx,%rcx
shr    $0x20,%rcx
jne    1320 <main+0x1d0>
lea    (%rsp,%r10,1),%rsi
add    $0x10,%rsi
lea    -0x1(%r8),%ecx
lea    (%rdx,%rcx,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rsi
jae    134e <main+0x1fe>
lea    (%r10,%r8,1),%rsi
add    %rsp,%rsi
add    $0x10,%rsi
sub    %r8,%rcx
add    %rdx,%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jae    134e <main+0x1fe>
nopl   0x0(%rax,%rax,1)
mov    %r10,%rcx
mov    %r8,%rsi
add    $0x1,%rsi
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rsi),%eax
movzbl 0x10(%rsp,%rcx,1),%ebx
add    $0x1,%rcx
mov    %bl,(%rdx,%rax,1)
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%rsi
ja     1330 <main+0x1e0>
jmp    1270 <main+0x120>
mov    %r8d,%r9d
and    $0xffffffe0,%r9d
lea    (%r9,%r10,1),%rcx
mov    %r8d,%esi
and    $0x1f,%esi
lea    0x20(%rsp),%rax
add    %rax,%r10
xor    %edi,%edi
nopl   0x0(%rax)
movdqu -0x10(%r10,%rdi,1),%xmm0
movdqu (%r10,%rdi,1),%xmm1
mov    %ebx,%eax
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 %xmm0,-0xf(%rdx,%rax,1)
movdqa %xmm1,%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm0,%xmm1
movdqu %xmm1,-0x1f(%rdx,%rax,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rbx
cmp    %rdi,%r9
jne    1370 <main+0x220>
cmp    %r8,%r9
je     1270 <main+0x120>
jmp    1326 <main+0x1d6>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rsp),%r15d
test   %r15d,%r15d
jle    1500 <main+0x3b0>
mov    %r15d,%r9d
lea    -0x1(%r13),%r8
mov    %r13d,%r15d
and    $0x3,%r15d
mov    %r13d,%r11d
and    $0xfffffffc,%r11d
xor    %edi,%edi
xor    %r10d,%r10d
jmp    144d <main+0x2fd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %r9,%rdi
je     1500 <main+0x3b0>
test   %r14d,%r14d
jle    1440 <main+0x2f0>
movslq %r10d,%r10
cmp    $0x3,%r8
jae    1470 <main+0x320>
xor    %ecx,%ecx
test   %r15,%r15
jne    14c8 <main+0x378>
jmp    1440 <main+0x2f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r12,%r10,1),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rcx,8),%rbx
movzbl (%rbx,%rdi,1),%ebx
mov    %bl,-0x3(%rax,%rcx,1)
mov    0x8(%rbp,%rcx,8),%rbx
movzbl (%rbx,%rdi,1),%ebx
mov    %bl,-0x2(%rax,%rcx,1)
mov    0x10(%rbp,%rcx,8),%rbx
movzbl (%rbx,%rdi,1),%ebx
mov    %bl,-0x1(%rax,%rcx,1)
mov    0x18(%rbp,%rcx,8),%rbx
movzbl (%rbx,%rdi,1),%ebx
mov    %bl,(%rax,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1480 <main+0x330>
add    %rcx,%r10
test   %r15,%r15
je     1440 <main+0x2f0>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
lea    (%rsp,%r10,1),%rbx
add    $0xe0,%rbx
xor    %ecx,%ecx
mov    (%rax,%rcx,8),%rsi
movzbl (%rsi,%rdi,1),%edx
mov    %dl,(%rbx,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    14e0 <main+0x390>
add    %rcx,%r10
jmp    1440 <main+0x2f0>
nopl   0x0(%rax)
test   %r14d,%r14d
jle    1190 <main+0x40>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1510 <main+0x3c0>
jmp    1190 <main+0x40>
xor    %eax,%eax
add    $0x1a8,%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"%s\00"
@.str.2 = [4 x i8] c"%s\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 [200 x i8]
%9 = alloca [200 x i8]
%10 = alloca i8**
store i32 0, i32* %1
br label %11
11: ; preds = %0, %154
%12 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%13 = load i32, i32* %2
%14 = icmp ne i32 %13, 0
br i1 %14, label %16, label %15
15: ; preds = %11
ret i32 0
16: ; preds = %11
%17 = getelementptr inbounds [200 x i8], [200 x i8]* %8, i64 0, i64 0
%18 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %17)
%19 = getelementptr inbounds [200 x i8], [200 x i8]* %8, i64 0, i64 0
%20 = call i64 @strlen(i8* %19)
%21 = trunc i64 %20 to i32
store i32 %21, i32* %3
%22 = load i32, i32* %3
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds [200 x i8], [200 x i8]* %9, i64 0, i64 %23
store i8 0, i8* %24
%25 = load i32, i32* %3
%26 = load i32, i32* %2
%27 = sdiv i32 %25, %26
store i32 %27, i32* %4
%28 = load i32, i32* %4
%29 = sext i32 %28 to i64
%30 = mul i64 8, %29
%31 = call i8* @malloc(i64 %30)
%32 = bitcast i8* %31 to i8**
store i8** %32, i8*** %10
store i32 0, i32* %5
br label %33
33: ; preds = %46, %16
%34 = load i32, i32* %5
%35 = load i32, i32* %4
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %49
37: ; preds = %33
%38 = load i32, i32* %2
%39 = sext i32 %38 to i64
%40 = mul i64 1, %39
%41 = call i8* @malloc(i64 %40)
%42 = load i8**, i8*** %10
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8*, i8** %42, i64 %44
store i8* %41, i8** %45
br label %46
46: ; preds = %37
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
br label %33
49: ; preds = %33
store i32 0, i32* %7
store i32 0, i32* %5
br label %50
50: ; preds = %106, %49
%51 = load i32, i32* %5
%52 = load i32, i32* %4
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %109
54: ; preds = %50
%55 = load i32, i32* %5
%56 = srem i32 %55, 2
%57 = icmp eq i32 %56, 0
br i1 %57, label %58, label %81
58: ; preds = %54
store i32 0, i32* %6
br label %59
59: ; preds = %77, %58
%60 = load i32, i32* %6
%61 = load i32, i32* %2
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %80
63: ; preds = %59
%64 = load i32, i32* %7
%65 = add nsw i32 %64, 1
store i32 %65, i32* %7
%66 = sext i32 %64 to i64
%67 = getelementptr inbounds [200 x i8], [200 x i8]* %8, i64 0, i64 %66
%68 = load i8, i8* %67
%69 = load i8**, i8*** %10
%70 = load i32, i32* %5
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8*, i8** %69, i64 %71
%73 = load i8*, i8** %72
%74 = load i32, i32* %6
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %73, i64 %75
store i8 %68, i8* %76
br label %77
77: ; preds = %63
%78 = load i32, i32* %6
%79 = add nsw i32 %78, 1
store i32 %79, i32* %6
br label %59
80: ; preds = %59
br label %105
81: ; preds = %54
%82 = load i32, i32* %2
%83 = sub nsw i32 %82, 1
store i32 %83, i32* %6
br label %84
84: ; preds = %101, %81
%85 = load i32, i32* %6
%86 = icmp sge i32 %85, 0
br i1 %86, label %87, label %104
87: ; preds = %84
%88 = load i32, i32* %7
%89 = add nsw i32 %88, 1
store i32 %89, i32* %7
%90 = sext i32 %88 to i64
%91 = getelementptr inbounds [200 x i8], [200 x i8]* %8, i64 0, i64 %90
%92 = load i8, i8* %91
%93 = load i8**, i8*** %10
%94 = load i32, i32* %5
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8*, i8** %93, i64 %95
%97 = load i8*, i8** %96
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
store i8 %92, i8* %100
br label %101
101: ; preds = %87
%102 = load i32, i32* %6
%103 = add nsw i32 %102, -1
store i32 %103, i32* %6
br label %84
104: ; preds = %84
br label %105
105: ; preds = %104, %80
br label %106
106: ; preds = %105
%107 = load i32, i32* %5
%108 = add nsw i32 %107, 1
store i32 %108, i32* %5
br label %50
109: ; preds = %50
store i32 0, i32* %7
store i32 0, i32* %5
br label %110
110: ; preds = %137, %109
%111 = load i32, i32* %5
%112 = load i32, i32* %2
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %140
114: ; preds = %110
store i32 0, i32* %6
br label %115
115: ; preds = %133, %114
%116 = load i32, i32* %6
%117 = load i32, i32* %4
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %136
119: ; preds = %115
%120 = load i8**, i8*** %10
%121 = load i32, i32* %6
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i8*, i8** %120, i64 %122
%124 = load i8*, i8** %123
%125 = load i32, i32* %5
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8, i8* %124, i64 %126
%128 = load i8, i8* %127
%129 = load i32, i32* %7
%130 = add nsw i32 %129, 1
store i32 %130, i32* %7
%131 = sext i32 %129 to i64
%132 = getelementptr inbounds [200 x i8], [200 x i8]* %9, i64 0, i64 %131
store i8 %128, i8* %132
br label %133
133: ; preds = %119
%134 = load i32, i32* %6
%135 = add nsw i32 %134, 1
store i32 %135, i32* %6
br label %115
136: ; preds = %115
br label %137
137: ; preds = %136
%138 = load i32, i32* %5
%139 = add nsw i32 %138, 1
store i32 %139, i32* %5
br label %110
140: ; preds = %110
store i32 0, i32* %5
br label %141
141: ; preds = %151, %140
%142 = load i32, i32* %5
%143 = load i32, i32* %4
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %154
145: ; preds = %141
%146 = load i8**, i8*** %10
%147 = load i32, i32* %5
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8*, i8** %146, i64 %148
%150 = load i8*, i8** %149
br label %151
151: ; preds = %145
%152 = load i32, i32* %5
%153 = add nsw i32 %152, 1
store i32 %153, i32* %5
br label %141
154: ; preds = %141
%155 = load i8**, i8*** %10
%156 = bitcast i8** %155 to i8*
%157 = getelementptr inbounds [200 x i8], [200 x i8]* %9, i64 0, i64 0
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i8* %157)
br label %11
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [200 x i8]
%3 = alloca [200 x i8]
%4 = bitcast i32* %1 to i8*
%5 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 0
%6 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%7 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%8 = load i32, i32* %1
%9 = icmp eq i32 %8, 0
br i1 %9, label %10, label %11
10: ; preds = %223, %0
ret i32 0
11: ; preds = %0, %223
%12 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %5)
%13 = call i64 @strlen(i8* %5)
%14 = trunc i64 %13 to i32
%15 = shl i64 %13, 32
%16 = ashr exact i64 %15, 32
%17 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %16
store i8 0, i8* %17
%18 = load i32, i32* %1
%19 = sdiv i32 %14, %18
%20 = sext i32 %19 to i64
%21 = shl nsw i64 %20, 3
%22 = call i8* @malloc(i64 %21)
%23 = bitcast i8* %22 to i8**
%24 = icmp sgt i32 %19, 0
br i1 %24, label %25, label %39
25: ; preds = %11
%26 = sext i32 %18 to i64
%27 = zext i32 %19 to i64
br label %31
28: ; preds = %31
br i1 %24, label %29, label %39
29: ; preds = %28
%30 = zext i32 %19 to i64
br label %50
31: ; preds = %25, %31
%32 = phi i64 [ 0, %25 ], [ %35, %31 ]
%33 = call i8* @malloc(i64 %26)
%34 = getelementptr inbounds i8*, i8** %23, i64 %32
store i8* %33, i8** %34
%35 = add nuw nsw i64 %32, 1
%36 = icmp eq i64 %35, %27
br i1 %36, label %28, label %31
37: ; preds = %147
%38 = load i32, i32* %1
br label %39
39: ; preds = %11, %37, %28
%40 = phi i32 [ %38, %37 ], [ %18, %28 ], [ %18, %11 ]
%41 = icmp sgt i32 %40, 0
br i1 %41, label %42, label %151
42: ; preds = %39
%43 = zext i32 %40 to i64
%44 = zext i32 %19 to i64
%45 = add nsw i64 %44, -1
%46 = and i64 %44, 3
%47 = icmp ult i64 %45, 3
%48 = and i64 %44, 4294967292
%49 = icmp eq i64 %46, 0
br label %154
50: ; preds = %29, %147
%51 = phi i64 [ 0, %29 ], [ %149, %147 ]
%52 = phi i32 [ 0, %29 ], [ %148, %147 ]
%53 = and i64 %51, 1
%54 = icmp eq i64 %53, 0
%55 = load i32, i32* %1
%56 = icmp sgt i32 %55, 0
br i1 %54, label %57, label %73
57: ; preds = %50
br i1 %56, label %58, label %147
58: ; preds = %57
%59 = getelementptr inbounds i8*, i8** %23, i64 %51
%60 = load i8*, i8** %59
%61 = sext i32 %52 to i64
br label %62
62: ; preds = %58, %62
%63 = phi i64 [ 0, %58 ], [ %69, %62 ]
%64 = phi i64 [ %61, %58 ], [ %65, %62 ]
%65 = add nsw i64 %64, 1
%66 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %64
%67 = load i8, i8* %66
%68 = getelementptr inbounds i8, i8* %60, i64 %63
store i8 %67, i8* %68
%69 = add nuw nsw i64 %63, 1
%70 = load i32, i32* %1
%71 = sext i32 %70 to i64
%72 = icmp slt i64 %69, %71
br i1 %72, label %62, label %142
73: ; preds = %50
br i1 %56, label %74, label %147
74: ; preds = %73
%75 = getelementptr inbounds i8*, i8** %23, i64 %51
%76 = load i8*, i8** %75
%77 = zext i32 %55 to i64
%78 = sext i32 %52 to i64
%79 = icmp ult i32 %55, 32
br i1 %79, label %129, label %80
80: ; preds = %74
%81 = add nsw i64 %77, -1
%82 = add i32 %55, -1
%83 = trunc i64 %81 to i32
%84 = icmp ult i32 %82, %83
%85 = icmp ugt i64 %81, 4294967295
%86 = or i1 %84, %85
br i1 %86, label %129, label %87
87: ; preds = %80
%88 = getelementptr [200 x i8], [200 x i8]* %2, i64 0, i64 %78
%89 = add nsw i64 %78, %77
%90 = getelementptr [200 x i8], [200 x i8]* %2, i64 0, i64 %89
%91 = getelementptr i8, i8* %76, i64 1
%92 = add i32 %55, -1
%93 = zext i32 %92 to i64
%94 = sub nsw i64 %93, %77
%95 = getelementptr i8, i8* %91, i64 %94
%96 = getelementptr i8, i8* %76, i64 1
%97 = getelementptr i8, i8* %96, i64 %93
%98 = icmp ult i8* %88, %97
%99 = icmp ult i8* %95, %90
%100 = and i1 %98, %99
br i1 %100, label %129, label %101
101: ; preds = %87
%102 = and i64 %77, 4294967264
%103 = add nsw i64 %102, %78
%104 = and i64 %77, 31
br label %105
105: ; preds = %105, %101
%106 = phi i64 [ 0, %101 ], [ %125, %105 ]
%107 = add i64 %106, %78
%108 = xor i64 %106, -1
%109 = add i64 %108, %77
%110 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %107
%111 = bitcast i8* %110 to <16 x i8>*
%112 = load <16 x i8>, <16 x i8>* %111
%113 = getelementptr inbounds i8, i8* %110, i64 16
%114 = bitcast i8* %113 to <16 x i8>*
%115 = load <16 x i8>, <16 x i8>* %114
%116 = and i64 %109, 4294967295
%117 = getelementptr inbounds i8, i8* %76, i64 %116
%118 = shufflevector <16 x i8> %112, <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>
%119 = getelementptr inbounds i8, i8* %117, i64 -15
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %118, <16 x i8>* %120
%121 = shufflevector <16 x i8> %115, <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>
%122 = getelementptr inbounds i8, i8* %117, i64 -16
%123 = getelementptr inbounds i8, i8* %122, i64 -15
%124 = bitcast i8* %123 to <16 x i8>*
store <16 x i8> %121, <16 x i8>* %124
%125 = add nuw i64 %106, 32
%126 = icmp eq i64 %125, %102
br i1 %126, label %127, label %105
127: ; preds = %105
%128 = icmp eq i64 %102, %77
br i1 %128, label %144, label %129
129: ; preds = %87, %80, %74, %127
%130 = phi i64 [ %78, %87 ], [ %78, %80 ], [ %78, %74 ], [ %103, %127 ]
%131 = phi i64 [ %77, %87 ], [ %77, %80 ], [ %77, %74 ], [ %104, %127 ]
br label %132
132: ; preds = %129, %132
%133 = phi i64 [ %136, %132 ], [ %130, %129 ]
%134 = phi i64 [ %135, %132 ], [ %131, %129 ]
%135 = add nsw i64 %134, -1
%136 = add nsw i64 %133, 1
%137 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %133
%138 = load i8, i8* %137
%139 = and i64 %135, 4294967295
%140 = getelementptr inbounds i8, i8* %76, i64 %139
store i8 %138, i8* %140
%141 = icmp ugt i64 %134, 1
br i1 %141, label %132, label %144
142: ; preds = %62
%143 = trunc i64 %65 to i32
br label %147
144: ; preds = %132, %127
%145 = phi i64 [ %103, %127 ], [ %136, %132 ]
%146 = trunc i64 %145 to i32
br label %147
147: ; preds = %144, %142, %73, %57
%148 = phi i32 [ %52, %57 ], [ %52, %73 ], [ %143, %142 ], [ %146, %144 ]
%149 = add nuw nsw i64 %51, 1
%150 = icmp eq i64 %149, %30
br i1 %150, label %37, label %50
151: ; preds = %213, %39
br i1 %24, label %152, label %223
152: ; preds = %151
%153 = zext i32 %19 to i64
br label %217
154: ; preds = %42, %213
%155 = phi i64 [ 0, %42 ], [ %215, %213 ]
%156 = phi i32 [ 0, %42 ], [ %214, %213 ]
br i1 %24, label %157, label %213
157: ; preds = %154
%158 = sext i32 %156 to i64
br i1 %47, label %193, label %159
159: ; preds = %157, %159
%160 = phi i64 [ %190, %159 ], [ 0, %157 ]
%161 = phi i64 [ %188, %159 ], [ %158, %157 ]
%162 = phi i64 [ %191, %159 ], [ 0, %157 ]
%163 = getelementptr inbounds i8*, i8** %23, i64 %160
%164 = load i8*, i8** %163
%165 = getelementptr inbounds i8, i8* %164, i64 %155
%166 = load i8, i8* %165
%167 = add nsw i64 %161, 1
%168 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %161
store i8 %166, i8* %168
%169 = or i64 %160, 1
%170 = getelementptr inbounds i8*, i8** %23, i64 %169
%171 = load i8*, i8** %170
%172 = getelementptr inbounds i8, i8* %171, i64 %155
%173 = load i8, i8* %172
%174 = add nsw i64 %161, 2
%175 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %167
store i8 %173, i8* %175
%176 = or i64 %160, 2
%177 = getelementptr inbounds i8*, i8** %23, i64 %176
%178 = load i8*, i8** %177
%179 = getelementptr inbounds i8, i8* %178, i64 %155
%180 = load i8, i8* %179
%181 = add nsw i64 %161, 3
%182 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %174
store i8 %180, i8* %182
%183 = or i64 %160, 3
%184 = getelementptr inbounds i8*, i8** %23, i64 %183
%185 = load i8*, i8** %184
%186 = getelementptr inbounds i8, i8* %185, i64 %155
%187 = load i8, i8* %186
%188 = add nsw i64 %161, 4
%189 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %181
store i8 %187, i8* %189
%190 = add nuw nsw i64 %160, 4
%191 = add i64 %162, 4
%192 = icmp eq i64 %191, %48
br i1 %192, label %193, label %159
193: ; preds = %159, %157
%194 = phi i64 [ undef, %157 ], [ %188, %159 ]
%195 = phi i64 [ 0, %157 ], [ %190, %159 ]
%196 = phi i64 [ %158, %157 ], [ %188, %159 ]
br i1 %49, label %210, label %197
197: ; preds = %193, %197
%198 = phi i64 [ %207, %197 ], [ %195, %193 ]
%199 = phi i64 [ %205, %197 ], [ %196, %193 ]
%200 = phi i64 [ %208, %197 ], [ 0, %193 ]
%201 = getelementptr inbounds i8*, i8** %23, i64 %198
%202 = load i8*, i8** %201
%203 = getelementptr inbounds i8, i8* %202, i64 %155
%204 = load i8, i8* %203
%205 = add nsw i64 %199, 1
%206 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %199
store i8 %204, i8* %206
%207 = add nuw nsw i64 %198, 1
%208 = add i64 %200, 1
%209 = icmp eq i64 %208, %46
br i1 %209, label %210, label %197
210: ; preds = %197, %193
%211 = phi i64 [ %194, %193 ], [ %205, %197 ]
%212 = trunc i64 %211 to i32
br label %213
213: ; preds = %210, %154
%214 = phi i32 [ %156, %154 ], [ %212, %210 ]
%215 = add nuw nsw i64 %155, 1
%216 = icmp eq i64 %215, %43
br i1 %216, label %151, label %154
217: ; preds = %152, %217
%218 = phi i64 [ 0, %152 ], [ %221, %217 ]
%219 = getelementptr inbounds i8*, i8** %23, i64 %218
%220 = load i8*, i8** %219
%221 = add nuw nsw i64 %218, 1
%222 = icmp eq i64 %221, %153
br i1 %222, label %223, label %217
223: ; preds = %217, %151
%224 = call i32 @puts(i8* %6)
%225 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%226 = load i32, i32* %1
%227 = icmp eq i32 %226, 0
br i1 %227, label %10, label %11
}