#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*/ putchar(char);
int /*<<< orphan*/ scanf(char *, ...);
short strlen(char *);
int main() {
  char i;
  char s[201];
  short n, len, j, q, k;
  char a[1000][1000];
  while (1) {
    scanf("%hd", &n);
    if (!n) {
      break;
    }
    scanf("%s", s);
    i = 0;
    len = strlen(s);
    for (q = k = 0; q < len / n; ++q) {
      if (i == 0) {
        for (j = 0; j < n; ++j, ++k) {
          a[q][j] = s[k];
        }
        i = 1;
      } else {
        for (j = n - 1; j >= 0; --j, ++k) {
          a[q][j] = s[k];
        }
        i = 0;
      }
    }
    for (i = 0; i < n; ++i) {
      for (j = 0; j < len / n; ++j) {
        putchar(a[j][i]);
      }
    }
    putchar('\n');
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf4330,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb7(%rip),%rdi
lea    -0xd2(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
cmpw   $0x0,-0xd2(%rbp)
jne    116a <main+0x3a>
jmp    13b1 <main+0x281>
lea    -0xd0(%rbp),%rsi
lea    0xe8c(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
movb   $0x0,-0x5(%rbp)
lea    -0xd0(%rbp),%rdi
call   1040 <strlen@plt>
mov    %ax,-0xd4(%rbp)
movw   $0x0,-0xda(%rbp)
movw   $0x0,-0xd8(%rbp)
movswl -0xd8(%rbp),%eax
mov    %eax,-0xf4324(%rbp)
movswl -0xd4(%rbp),%eax
movswl -0xd2(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf4324(%rbp),%eax
cmp    %ecx,%eax
jge    1304 <main+0x1d4>
movsbl -0x5(%rbp),%eax
cmp    $0x0,%eax
jne    1267 <main+0x137>
movw   $0x0,-0xd6(%rbp)
movswl -0xd6(%rbp),%eax
movswl -0xd2(%rbp),%ecx
cmp    %ecx,%eax
jge    125e <main+0x12e>
movswq -0xda(%rbp),%rax
ff
mov    -0xd0(%rbp,%rax,1),%dl
movswq -0xd8(%rbp),%rcx
ff
lea    -0xf4320(%rbp),%rax
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
movswq -0xd6(%rbp),%rcx
ff
mov    %dl,(%rax,%rcx,1)
mov    -0xd6(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xd6(%rbp)
mov    -0xda(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xda(%rbp)
jmp    11ec <main+0xbc>
movb   $0x1,-0x5(%rbp)
jmp    12e8 <main+0x1b8>
movswl -0xd2(%rbp),%eax
sub    $0x1,%eax
mov    %ax,-0xd6(%rbp)
movswl -0xd6(%rbp),%eax
cmp    $0x0,%eax
jl     12e4 <main+0x1b4>
movswq -0xda(%rbp),%rax
ff
mov    -0xd0(%rbp,%rax,1),%dl
movswq -0xd8(%rbp),%rcx
ff
lea    -0xf4320(%rbp),%rax
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
movswq -0xd6(%rbp),%rcx
ff
mov    %dl,(%rax,%rcx,1)
mov    -0xd6(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0xd6(%rbp)
mov    -0xda(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xda(%rbp)
jmp    1278 <main+0x148>
movb   $0x0,-0x5(%rbp)
jmp    12ed <main+0x1bd>
mov    -0xd8(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xd8(%rbp)
jmp    11a8 <main+0x78>
movb   $0x0,-0x5(%rbp)
movsbl -0x5(%rbp),%eax
movswl -0xd2(%rbp),%ecx
cmp    %ecx,%eax
jge    13a2 <main+0x272>
movw   $0x0,-0xd6(%rbp)
movswl -0xd6(%rbp),%eax
mov    %eax,-0xf4328(%rbp)
movswl -0xd4(%rbp),%eax
movswl -0xd2(%rbp),%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xf4328(%rbp),%eax
cmp    %ecx,%eax
jge    1390 <main+0x260>
movswq -0xd6(%rbp),%rcx
ff
lea    -0xf4320(%rbp),%rax
imul   $0x3e8,%rcx,%rcx
add    %rcx,%rax
movsbq -0x5(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
mov    -0xd6(%rbp),%ax
add    $0x1,%ax
mov    %ax,-0xd6(%rbp)
jmp    1324 <main+0x1f4>
jmp    1395 <main+0x265>
mov    -0x5(%rbp),%al
add    $0x1,%al
mov    %al,-0x5(%rbp)
jmp    1308 <main+0x1d8>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1142 <main+0x12>
xor    %eax,%eax
add    $0xf4330,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf4378,%rsp
jmp    115a <main+0x2a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xe9f(%rip),%rdi
lea    0x2(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
cmpw   $0x0,0x2(%rsp)
je     16a5 <main+0x575>
lea    0xe84(%rip),%rdi
lea    0x60(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
movswl %ax,%r12d
movswl 0x2(%rsp),%ecx
mov    %r12d,%eax
cltd
idiv   %ecx
test   %eax,%eax
pxor   %xmm3,%xmm3
jle    1630 <main+0x500>
mov    %eax,%ebp
movzwl %cx,%r15d
lea    -0x1(%rcx),%r8d
lea    -0x1(%r15),%r10
movzwl %r8w,%eax
add    $0x1,%eax
mov    %r15d,%edx
and    $0xffffffe0,%edx
mov    %rdx,0x28(%rsp)
add    $0xffffffffffffffe0,%rdx
mov    %rdx,0x48(%rsp)
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %eax,%edi
and    $0xffffffe0,%edi
mov    %r8d,%ebx
mov    %rdi,%rsi
mov    %rdi,0x20(%rsp)
sub    %edi,%ebx
mov    %ebx,0x18(%rsp)
mov    %eax,0xc(%rsp)
mov    %eax,%esi
and    $0xfffffff8,%esi
mov    %r8d,%eax
sub    %esi,%eax
mov    %eax,0x1c(%rsp)
mov    %rdx,%rax
mov    %rdx,0x40(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x38(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x58(%rsp)
mov    %rsi,%rax
mov    %rsi,0x30(%rsp)
neg    %esi
mov    %rsi,0x50(%rsp)
xor    %r11d,%r11d
xor    %r13d,%r13d
xor    %r14d,%r14d
mov    %ebp,0x4(%rsp)
mov    %r10,0x10(%rsp)
jmp    126d <main+0x13d>
xor    %r14d,%r14d
mov    0x8(%rsp),%eax
mov    %eax,%r11d
mov    0x4(%rsp),%ebp
mov    0x10(%rsp),%r10
add    $0x1,%r13d
movswl %r13w,%eax
cmp    %eax,%ebp
jle    1630 <main+0x500>
movswq %r13w,%rdx
imul   $0x3e8,%rdx,%r9
test   %r14d,%r14d
jne    1330 <main+0x200>
mov    $0x1,%r14d
test   %cx,%cx
jle    125d <main+0x12d>
cmp    $0x20,%cx
jb     14c0 <main+0x390>
lea    (%r11,%r10,1),%eax
cmp    %r11w,%ax
jl     14c0 <main+0x390>
cmp    $0xffff,%r10
ja     14c0 <main+0x390>
cmpq   $0x0,0x48(%rsp)
je     153c <main+0x40c>
lea    0x160(%rsp),%rax
lea    (%rax,%r9,1),%rsi
mov    0x38(%rsp),%rdi
mov    %r11d,%edx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movswq %dx,%rax
movups 0x60(%rsp,%rax,1),%xmm0
movups 0x70(%rsp,%rax,1),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,1)
movups %xmm1,-0x20(%rsi,%rbx,1)
lea    0x20(%rdx),%eax
movswq %ax,%rax
movdqu 0x60(%rsp,%rax,1),%xmm0
movdqu 0x70(%rsp,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rbx,1)
movdqu %xmm1,(%rsi,%rbx,1)
add    $0x40,%rbx
add    $0x40,%edx
add    $0xfffffffffffffffe,%rdi
jne    12e0 <main+0x1b0>
jmp    153e <main+0x40e>
nopl   0x0(%rax,%rax,1)
xor    %r14d,%r14d
test   %r8w,%r8w
js     125d <main+0x12d>
lea    (%rcx,%r11,1),%eax
mov    %eax,0x8(%rsp)
mov    %r8d,%esi
mov    %r11d,%r10d
cmp    $0x7,%r8w
jb     15a0 <main+0x470>
lea    (%r11,%r8,1),%edx
mov    %r8d,%esi
mov    %r11d,%r10d
cmp    %r11w,%dx
jl     15a0 <main+0x470>
xor    %edx,%edx
cmp    $0x1f,%r8w
jb     143d <main+0x30d>
mov    %r8d,%esi
mov    %r11d,%ebx
mov    0x20(%rsp),%r10
mov    %r10d,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movswq %bx,%rdx
movdqu 0x60(%rsp,%rdx,1),%xmm0
movdqu 0x70(%rsp,%rdx,1),%xmm1
movzwl %si,%edx
lea    (%rsp,%r9,1),%rbp
add    $0x130,%rbp
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,%rbp,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,%rbp,1)
add    $0x20,%ebx
add    $0xffffffe0,%esi
add    $0xffffffe0,%edi
jne    1390 <main+0x260>
mov    0xc(%rsp),%eax
cmp    %r10d,%eax
je     124a <main+0x11a>
mov    %r10d,%edx
test   $0x18,%al
je     158f <main+0x45f>
mov    0x30(%rsp),%rax
lea    (%r11,%rax,1),%r10d
mov    0x50(%rsp),%rax
lea    (%rax,%rdx,1),%esi
lea    (%r11,%rdx,1),%edi
mov    %r8d,%ebx
sub    %edx,%ebx
nopw   0x0(%rax,%rax,1)
movswq %di,%rdx
movq   0x60(%rsp,%rdx,1),%xmm0
movzwl %bx,%edx
lea    (%rsp,%r9,1),%rbp
add    $0x130,%rbp
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,-0x7(%rdx,%rbp,1)
add    $0x8,%edi
add    $0xfffffff8,%ebx
add    $0x8,%esi
jne    1460 <main+0x330>
mov    0x1c(%rsp),%eax
mov    %eax,%esi
mov    0x30(%rsp),%rax
cmp    %eax,0xc(%rsp)
je     124a <main+0x11a>
jmp    15a0 <main+0x470>
nopw   0x0(%rax,%rax,1)
xor    %ebx,%ebx
mov    %r11d,%esi
test   $0x1,%r15b
jne    14d0 <main+0x3a0>
mov    %rbx,%rdi
jmp    14f4 <main+0x3c4>
movswq %si,%rax
mov    0x60(%rsp,%rax,1),%al
lea    (%rsp,%r9,1),%rdx
add    $0x130,%rdx
mov    %al,(%rbx,%rdx,1)
mov    %rbx,%rdi
or     $0x1,%rdi
lea    0x1(%rsi),%r11d
mov    %r11d,%esi
not    %rbx
cmp    0x58(%rsp),%rbx
je     125d <main+0x12d>
lea    0x131(%rsp),%rax
add    %rax,%r9
nopl   (%rax)
movswq %si,%rax
movzbl 0x60(%rsp,%rax,1),%eax
mov    %al,-0x1(%r9,%rdi,1)
lea    0x1(%rsi),%eax
movswq %ax,%rax
movzbl 0x60(%rsp,%rax,1),%eax
mov    %al,(%r9,%rdi,1)
add    $0x2,%rdi
add    $0x2,%esi
cmp    %rdi,%r15
jne    1510 <main+0x3e0>
jmp    1587 <main+0x457>
xor    %ebx,%ebx
mov    0x28(%rsp),%rax
lea    (%r11,%rax,1),%esi
testb  $0x1,0x40(%rsp)
je     157b <main+0x44b>
add    %ebx,%r11d
movswq %r11w,%rax
movdqu 0x60(%rsp,%rax,1),%xmm0
movdqu 0x70(%rsp,%rax,1),%xmm1
lea    (%rsp,%r9,1),%rax
add    $0x130,%rax
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm1,0x10(%rbx,%rax,1)
mov    0x28(%rsp),%rax
mov    %rax,%rbx
cmp    %r15,%rax
jne    14c5 <main+0x395>
mov    %esi,%r11d
jmp    125d <main+0x12d>
mov    0x20(%rsp),%rax
lea    (%r11,%rax,1),%r10d
mov    0x18(%rsp),%eax
mov    %eax,%esi
xchg   %ax,%ax
lea    (%rcx,%r11,1),%ebx
mov    %ebx,%edx
sub    %r10d,%edx
add    %r8d,%r11d
test   $0x1,%dl
jne    15bf <main+0x48f>
mov    %r10d,%edi
cmp    %r10w,%r11w
jne    15f0 <main+0x4c0>
jmp    124d <main+0x11d>
movswq %r10w,%rdx
mov    0x60(%rsp,%rdx,1),%dl
movzwl %si,%edi
lea    (%rsp,%r9,1),%rbp
add    $0x130,%rbp
mov    %dl,(%rdi,%rbp,1)
lea    0x1(%r10),%edi
add    $0xffffffff,%esi
cmp    %r10w,%r11w
je     124d <main+0x11d>
nopl   0x0(%rax)
movswq %di,%rdx
movzbl 0x60(%rsp,%rdx,1),%edx
movzwl %si,%ebp
lea    (%rsp,%r9,1),%rax
add    $0x130,%rax
mov    %dl,0x0(%rbp,%rax,1)
lea    0x1(%rdi),%edx
lea    -0x1(%rsi),%ebp
movswq %dx,%rdx
movzbl 0x60(%rsp,%rdx,1),%edx
movzwl %bp,%ebp
mov    %dl,0x0(%rbp,%rax,1)
add    $0x2,%edi
add    $0xfffffffe,%esi
cmp    %di,%bx
jne    15f0 <main+0x4c0>
jmp    124d <main+0x11d>
test   %cx,%cx
jle    1150 <main+0x20>
xor    %r14d,%r14d
jmp    1651 <main+0x521>
xchg   %ax,%ax
add    $0x1,%r14b
movsbl %r14b,%eax
cmp    %ax,%cx
jle    1150 <main+0x20>
movswl %cx,%esi
mov    %r12d,%eax
cltd
idiv   %esi
test   %eax,%eax
jle    1640 <main+0x510>
movsbq %r14b,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movswq %bx,%rax
imul   $0x3e8,%rax,%rax
add    %rsp,%rax
add    $0x130,%rax
movsbl 0x0(%rbp,%rax,1),%edi
call   1030 <putchar@plt>
add    $0x1,%ebx
movswl %bx,%esi
movswl 0x2(%rsp),%ecx
mov    %r12d,%eax
cltd
idiv   %ecx
cmp    %esi,%eax
jg     1670 <main+0x540>
jmp    1640 <main+0x510>
xor    %eax,%eax
add    $0xf4378,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%hd\00"
@.str.1 = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i8
%3 = alloca [201 x i8]
%4 = alloca i16
%5 = alloca i16
%6 = alloca i16
%7 = alloca i16
%8 = alloca i16
%9 = alloca [1000 x [1000 x i8]]
store i32 0, i32* %1
br label %10
10: ; preds = %0, %120
%11 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %4)
%12 = load i16, i16* %4
%13 = icmp ne i16 %12, 0
br i1 %13, label %15, label %14
14: ; preds = %10
br label %122
15: ; preds = %10
%16 = getelementptr inbounds [201 x i8], [201 x i8]* %3, i64 0, i64 0
%17 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %16)
store i8 0, i8* %2
%18 = getelementptr inbounds [201 x i8], [201 x i8]* %3, i64 0, i64 0
%19 = call signext i16 @strlen(i8* %18)
store i16 %19, i16* %5
store i16 0, i16* %8
store i16 0, i16* %7
br label %20
20: ; preds = %84, %15
%21 = load i16, i16* %7
%22 = sext i16 %21 to i32
%23 = load i16, i16* %5
%24 = sext i16 %23 to i32
%25 = load i16, i16* %4
%26 = sext i16 %25 to i32
%27 = sdiv i32 %24, %26
%28 = icmp slt i32 %22, %27
br i1 %28, label %29, label %87
29: ; preds = %20
%30 = load i8, i8* %2
%31 = sext i8 %30 to i32
%32 = icmp eq i32 %31, 0
br i1 %32, label %33, label %57
33: ; preds = %29
store i16 0, i16* %6
br label %34
34: ; preds = %51, %33
%35 = load i16, i16* %6
%36 = sext i16 %35 to i32
%37 = load i16, i16* %4
%38 = sext i16 %37 to i32
%39 = icmp slt i32 %36, %38
br i1 %39, label %40, label %56
40: ; preds = %34
%41 = load i16, i16* %8
%42 = sext i16 %41 to i64
%43 = getelementptr inbounds [201 x i8], [201 x i8]* %3, i64 0, i64 %42
%44 = load i8, i8* %43
%45 = load i16, i16* %7
%46 = sext i16 %45 to i64
%47 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %9, i64 0, i64 %46
%48 = load i16, i16* %6
%49 = sext i16 %48 to i64
%50 = getelementptr inbounds [1000 x i8], [1000 x i8]* %47, i64 0, i64 %49
store i8 %44, i8* %50
br label %51
51: ; preds = %40
%52 = load i16, i16* %6
%53 = add i16 %52, 1
store i16 %53, i16* %6
%54 = load i16, i16* %8
%55 = add i16 %54, 1
store i16 %55, i16* %8
br label %34
56: ; preds = %34
store i8 1, i8* %2
br label %83
57: ; preds = %29
%58 = load i16, i16* %4
%59 = sext i16 %58 to i32
%60 = sub nsw i32 %59, 1
%61 = trunc i32 %60 to i16
store i16 %61, i16* %6
br label %62
62: ; preds = %77, %57
%63 = load i16, i16* %6
%64 = sext i16 %63 to i32
%65 = icmp sge i32 %64, 0
br i1 %65, label %66, label %82
66: ; preds = %62
%67 = load i16, i16* %8
%68 = sext i16 %67 to i64
%69 = getelementptr inbounds [201 x i8], [201 x i8]* %3, i64 0, i64 %68
%70 = load i8, i8* %69
%71 = load i16, i16* %7
%72 = sext i16 %71 to i64
%73 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %9, i64 0, i64 %72
%74 = load i16, i16* %6
%75 = sext i16 %74 to i64
%76 = getelementptr inbounds [1000 x i8], [1000 x i8]* %73, i64 0, i64 %75
store i8 %70, i8* %76
br label %77
77: ; preds = %66
%78 = load i16, i16* %6
%79 = add i16 %78, -1
store i16 %79, i16* %6
%80 = load i16, i16* %8
%81 = add i16 %80, 1
store i16 %81, i16* %8
br label %62
82: ; preds = %62
store i8 0, i8* %2
br label %83
83: ; preds = %82, %56
br label %84
84: ; preds = %83
%85 = load i16, i16* %7
%86 = add i16 %85, 1
store i16 %86, i16* %7
br label %20
87: ; preds = %20
store i8 0, i8* %2
br label %88
88: ; preds = %117, %87
%89 = load i8, i8* %2
%90 = sext i8 %89 to i32
%91 = load i16, i16* %4
%92 = sext i16 %91 to i32
%93 = icmp slt i32 %90, %92
br i1 %93, label %94, label %120
94: ; preds = %88
store i16 0, i16* %6
br label %95
95: ; preds = %113, %94
%96 = load i16, i16* %6
%97 = sext i16 %96 to i32
%98 = load i16, i16* %5
%99 = sext i16 %98 to i32
%100 = load i16, i16* %4
%101 = sext i16 %100 to i32
%102 = sdiv i32 %99, %101
%103 = icmp slt i32 %97, %102
br i1 %103, label %104, label %116
104: ; preds = %95
%105 = load i16, i16* %6
%106 = sext i16 %105 to i64
%107 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %9, i64 0, i64 %106
%108 = load i8, i8* %2
%109 = sext i8 %108 to i64
%110 = getelementptr inbounds [1000 x i8], [1000 x i8]* %107, i64 0, i64 %109
%111 = load i8, i8* %110
%112 = call i32 @putchar(i8 signext %111)
br label %113
113: ; preds = %104
%114 = load i16, i16* %6
%115 = add i16 %114, 1
store i16 %115, i16* %6
br label %95
116: ; preds = %95
br label %117
117: ; preds = %116
%118 = load i8, i8* %2
%119 = add i8 %118, 1
store i8 %119, i8* %2
br label %88
120: ; preds = %88
%121 = call i32 @putchar(i8 signext 10)
br label %10
122: ; preds = %14
ret i32 0
}

LLVM IR (-O2):
@.str = [4 x i8] c"%hd\00"
@.str.1 = [3 x i8] c"%s\00"
define i32 @main() {
%1 = alloca [201 x i8]
%2 = alloca i16
%3 = alloca [1000 x [1000 x i8]]
%4 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 0
%5 = bitcast i16* %2 to i8*
%6 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 0, i64 0
%7 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %2)
%8 = load i16, i16* %2
%9 = icmp eq i16 %8, 0
br i1 %9, label %287, label %10
10: ; preds = %0, %282
%11 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %4)
%12 = call signext i16 @strlen(i8* %4)
%13 = sext i16 %12 to i32
%14 = load i16, i16* %2
%15 = sext i16 %14 to i32
%16 = sdiv i32 %13, %15
%17 = icmp sgt i32 %16, 0
br i1 %17, label %18, label %60
18: ; preds = %10
%19 = add i16 %14, -1
%20 = icmp sgt i16 %19, -1
%21 = icmp sgt i16 %14, 0
%22 = zext i16 %14 to i64
%23 = add nsw i64 %22, -1
%24 = zext i16 %19 to i32
%25 = add nuw nsw i32 %24, 1
%26 = zext i16 %19 to i32
%27 = add nuw nsw i32 %26, 1
%28 = add i16 %14, -1
%29 = and i64 %22, 65504
%30 = add nsw i64 %29, -32
%31 = lshr exact i64 %30, 5
%32 = add nuw nsw i64 %31, 1
%33 = icmp ult i16 %19, 7
%34 = icmp ult i16 %19, 31
%35 = and i32 %25, 131040
%36 = icmp eq i32 %25, %35
%37 = trunc i32 %35 to i16
%38 = trunc i32 %35 to i16
%39 = sub i16 %19, %38
%40 = and i32 %25, 24
%41 = icmp eq i32 %40, 0
%42 = and i32 %27, 131064
%43 = trunc i32 %42 to i16
%44 = sub i16 %19, %43
%45 = trunc i32 %42 to i16
%46 = icmp eq i32 %27, %42
%47 = icmp ult i16 %14, 32
%48 = trunc i64 %23 to i16
%49 = icmp ugt i64 %23, 65535
%50 = and i64 %22, 65504
%51 = trunc i64 %50 to i16
%52 = and i64 %32, 1
%53 = icmp eq i64 %30, 0
%54 = and i64 %32, 1152921504606846974
%55 = icmp eq i64 %52, 0
%56 = icmp eq i64 %50, %22
%57 = and i64 %22, 1
%58 = icmp eq i64 %57, 0
%59 = sub nsw i64 0, %22
br label %62
60: ; preds = %251, %10
%61 = icmp sgt i16 %14, 0
br i1 %61, label %257, label %282
62: ; preds = %18, %251
%63 = phi i16 [ 0, %18 ], [ %253, %251 ]
%64 = phi i16 [ 0, %18 ], [ %254, %251 ]
%65 = phi i32 [ 0, %18 ], [ %252, %251 ]
%66 = icmp eq i32 %65, 0
br i1 %66, label %142, label %67
67: ; preds = %62
br i1 %20, label %68, label %251
68: ; preds = %67
%69 = sext i16 %64 to i64
%70 = add i16 %14, %63
%71 = add i16 %63, %19
%72 = icmp slt i16 %71, %63
%73 = select i1 %33, i1 true, i1 %72
br i1 %73, label %122, label %74
74: ; preds = %68
br i1 %34, label %101, label %75
75: ; preds = %74, %75
%76 = phi i32 [ %96, %75 ], [ 0, %74 ]
%77 = trunc i32 %76 to i16
%78 = sub i16 %19, %77
%79 = trunc i32 %76 to i16
%80 = add i16 %63, %79
%81 = sext i16 %80 to i64
%82 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %82, i64 16
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = zext i16 %78 to i64
%89 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %69, i64 %88
%90 = shufflevector <16 x i8> %84, <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>
%91 = getelementptr inbounds i8, i8* %89, i64 -15
%92 = bitcast i8* %91 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %92
%93 = shufflevector <16 x i8> %87, <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>
%94 = getelementptr inbounds i8, i8* %89, i64 -31
%95 = bitcast i8* %94 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %95
%96 = add nuw i32 %76, 32
%97 = icmp eq i32 %96, %35
br i1 %97, label %98, label %75
98: ; preds = %75
br i1 %36, label %251, label %99
99: ; preds = %98
%100 = add i16 %63, %37
br i1 %41, label %122, label %101
101: ; preds = %74, %99
%102 = phi i32 [ %35, %99 ], [ 0, %74 ]
%103 = add i16 %63, %45
br label %104
104: ; preds = %104, %101
%105 = phi i32 [ %102, %101 ], [ %119, %104 ]
%106 = trunc i32 %105 to i16
%107 = sub i16 %19, %106
%108 = trunc i32 %105 to i16
%109 = add i16 %63, %108
%110 = sext i16 %109 to i64
%111 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %110
%112 = bitcast i8* %111 to <8 x i8>*
%113 = load <8 x i8>, <8 x i8>* %112
%114 = zext i16 %107 to i64
%115 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %69, i64 %114
%116 = shufflevector <8 x i8> %113, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%117 = getelementptr inbounds i8, i8* %115, i64 -7
%118 = bitcast i8* %117 to <8 x i8>*
store <8 x i8> %116, <8 x i8>* %118
%119 = add nuw i32 %105, 8
%120 = icmp eq i32 %119, %42
br i1 %120, label %121, label %104
121: ; preds = %104
br i1 %46, label %251, label %122
122: ; preds = %68, %99, %121
%123 = phi i16 [ %19, %68 ], [ %39, %99 ], [ %44, %121 ]
%124 = phi i16 [ %63, %68 ], [ %100, %99 ], [ %103, %121 ]
%125 = add i16 %14, %63
%126 = sub i16 %125, %124
%127 = add i16 %28, %63
%128 = and i16 %126, 1
%129 = icmp eq i16 %128, 0
br i1 %129, label %138, label %130
130: ; preds = %122
%131 = sext i16 %124 to i64
%132 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %131
%133 = load i8, i8* %132
%134 = zext i16 %123 to i64
%135 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %69, i64 %134
store i8 %133, i8* %135
%136 = add i16 %124, 1
%137 = add i16 %123, -1
br label %138
138: ; preds = %130, %122
%139 = phi i16 [ %123, %122 ], [ %137, %130 ]
%140 = phi i16 [ %124, %122 ], [ %136, %130 ]
%141 = icmp eq i16 %127, %124
br i1 %141, label %251, label %233
142: ; preds = %62
br i1 %21, label %143, label %251
143: ; preds = %142
%144 = sext i16 %64 to i64
br i1 %47, label %201, label %145
145: ; preds = %143
%146 = add i16 %63, %48
%147 = icmp slt i16 %146, %63
%148 = or i1 %147, %49
br i1 %148, label %201, label %149
149: ; preds = %145
%150 = add i16 %63, %51
br i1 %53, label %184, label %151
151: ; preds = %149, %151
%152 = phi i64 [ %181, %151 ], [ 0, %149 ]
%153 = phi i64 [ %182, %151 ], [ 0, %149 ]
%154 = trunc i64 %152 to i16
%155 = add i16 %63, %154
%156 = sext i16 %155 to i64
%157 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %156
%158 = bitcast i8* %157 to <16 x i8>*
%159 = load <16 x i8>, <16 x i8>* %158
%160 = getelementptr inbounds i8, i8* %157, i64 16
%161 = bitcast i8* %160 to <16 x i8>*
%162 = load <16 x i8>, <16 x i8>* %161
%163 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %152
%164 = bitcast i8* %163 to <16 x i8>*
store <16 x i8> %159, <16 x i8>* %164
%165 = getelementptr inbounds i8, i8* %163, i64 16
%166 = bitcast i8* %165 to <16 x i8>*
store <16 x i8> %162, <16 x i8>* %166
%167 = or i64 %152, 32
%168 = trunc i64 %167 to i16
%169 = add i16 %63, %168
%170 = sext i16 %169 to i64
%171 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %170
%172 = bitcast i8* %171 to <16 x i8>*
%173 = load <16 x i8>, <16 x i8>* %172
%174 = getelementptr inbounds i8, i8* %171, i64 16
%175 = bitcast i8* %174 to <16 x i8>*
%176 = load <16 x i8>, <16 x i8>* %175
%177 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %167
%178 = bitcast i8* %177 to <16 x i8>*
store <16 x i8> %173, <16 x i8>* %178
%179 = getelementptr inbounds i8, i8* %177, i64 16
%180 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %180
%181 = add nuw i64 %152, 64
%182 = add i64 %153, 2
%183 = icmp eq i64 %182, %54
br i1 %183, label %184, label %151
184: ; preds = %151, %149
%185 = phi i64 [ 0, %149 ], [ %181, %151 ]
br i1 %55, label %200, label %186
186: ; preds = %184
%187 = trunc i64 %185 to i16
%188 = add i16 %63, %187
%189 = sext i16 %188 to i64
%190 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %189
%191 = bitcast i8* %190 to <16 x i8>*
%192 = load <16 x i8>, <16 x i8>* %191
%193 = getelementptr inbounds i8, i8* %190, i64 16
%194 = bitcast i8* %193 to <16 x i8>*
%195 = load <16 x i8>, <16 x i8>* %194
%196 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %185
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %192, <16 x i8>* %197
%198 = getelementptr inbounds i8, i8* %196, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %199
br label %200
200: ; preds = %184, %186
br i1 %56, label %251, label %201
201: ; preds = %145, %143, %200
%202 = phi i64 [ 0, %145 ], [ 0, %143 ], [ %50, %200 ]
%203 = phi i16 [ %63, %145 ], [ %63, %143 ], [ %150, %200 ]
%204 = xor i64 %202, -1
br i1 %58, label %212, label %205
205: ; preds = %201
%206 = sext i16 %203 to i64
%207 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %206
%208 = load i8, i8* %207
%209 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %202
store i8 %208, i8* %209
%210 = or i64 %202, 1
%211 = add i16 %203, 1
br label %212
212: ; preds = %205, %201
%213 = phi i16 [ undef, %201 ], [ %211, %205 ]
%214 = phi i64 [ %202, %201 ], [ %210, %205 ]
%215 = phi i16 [ %203, %201 ], [ %211, %205 ]
%216 = icmp eq i64 %204, %59
br i1 %216, label %251, label %217
217: ; preds = %212, %217
%218 = phi i64 [ %230, %217 ], [ %214, %212 ]
%219 = phi i16 [ %231, %217 ], [ %215, %212 ]
%220 = sext i16 %219 to i64
%221 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %220
%222 = load i8, i8* %221
%223 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %218
store i8 %222, i8* %223
%224 = add nuw nsw i64 %218, 1
%225 = add i16 %219, 1
%226 = sext i16 %225 to i64
%227 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %226
%228 = load i8, i8* %227
%229 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %144, i64 %224
store i8 %228, i8* %229
%230 = add nuw nsw i64 %218, 2
%231 = add i16 %219, 2
%232 = icmp eq i64 %230, %22
br i1 %232, label %251, label %217
233: ; preds = %138, %233
%234 = phi i16 [ %249, %233 ], [ %139, %138 ]
%235 = phi i16 [ %248, %233 ], [ %140, %138 ]
%236 = sext i16 %235 to i64
%237 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %236
%238 = load i8, i8* %237
%239 = zext i16 %234 to i64
%240 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %69, i64 %239
store i8 %238, i8* %240
%241 = add i16 %235, 1
%242 = add i16 %234, -1
%243 = sext i16 %241 to i64
%244 = getelementptr inbounds [201 x i8], [201 x i8]* %1, i64 0, i64 %243
%245 = load i8, i8* %244
%246 = zext i16 %242 to i64
%247 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %69, i64 %246
store i8 %245, i8* %247
%248 = add i16 %235, 2
%249 = add i16 %234, -2
%250 = icmp eq i16 %248, %70
br i1 %250, label %251, label %233
251: ; preds = %138, %233, %212, %217, %98, %121, %200, %67, %142
%252 = phi i32 [ 1, %142 ], [ 0, %67 ], [ 1, %200 ], [ 0, %121 ], [ 0, %98 ], [ 1, %217 ], [ 1, %212 ], [ 0, %233 ], [ 0, %138 ]
%253 = phi i16 [ %63, %142 ], [ %63, %67 ], [ %150, %200 ], [ %70, %121 ], [ %70, %98 ], [ %213, %212 ], [ %231, %217 ], [ %70, %233 ], [ %70, %138 ]
%254 = add i16 %64, 1
%255 = sext i16 %254 to i32
%256 = icmp sgt i32 %16, %255
br i1 %256, label %62, label %60
257: ; preds = %60, %277
%258 = phi i16 [ %278, %277 ], [ %14, %60 ]
%259 = phi i8 [ %279, %277 ], [ 0, %60 ]
%260 = sext i16 %258 to i32
%261 = sdiv i32 %13, %260
%262 = icmp sgt i32 %261, 0
br i1 %262, label %263, label %277
263: ; preds = %257
%264 = sext i8 %259 to i64
br label %265
265: ; preds = %263, %265
%266 = phi i16 [ 0, %263 ], [ %271, %265 ]
%267 = sext i16 %266 to i64
%268 = getelementptr inbounds [1000 x [1000 x i8]], [1000 x [1000 x i8]]* %3, i64 0, i64 %267, i64 %264
%269 = load i8, i8* %268
%270 = call i32 @putchar(i8 signext %269)
%271 = add i16 %266, 1
%272 = sext i16 %271 to i32
%273 = load i16, i16* %2
%274 = sext i16 %273 to i32
%275 = sdiv i32 %13, %274
%276 = icmp sgt i32 %275, %272
br i1 %276, label %265, label %277
277: ; preds = %265, %257
%278 = phi i16 [ %258, %257 ], [ %273, %265 ]
%279 = add i8 %259, 1
%280 = sext i8 %279 to i16
%281 = icmp sgt i16 %278, %280
br i1 %281, label %257, label %282
282: ; preds = %277, %60
%283 = call i32 @putchar(i8 signext 10)
%284 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i16* %2)
%285 = load i16, i16* %2
%286 = icmp eq i16 %285, 0
br i1 %286, label %287, label %10
287: ; preds = %282, %0
ret i32 0
}