#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*/ memset(char *, char, int);
int /*<<< orphan*/ printf(char *, ...);
int scanf(char *, char *);
int strlen(char *);
int main() {
  int i, len, k, j, c;
  char n, a[10000], b[10000];
  while (scanf("%d", &n) == 1) {
    getchar();
    scanf("%s", a);
    if (n == 0 && a[0] == '0' && a[1] == '\0')
      break;
    len = strlen(a);
    k = 0;
    for (i = 0; i < len; i++) {
      if (a[i] == n + '0') {
        a[i] = ' ';
      }
    }
    c = 0;
    for (i = 0; i < len; i++) {
      if (a[i] >= '0' && a[i] <= '9') {
        c = c * 10 + (a[i] - '0');
        if (c > 0)
          break;
      }
    }
    j = 0;
    for (i = 0; i < len; i++) {
      if (a[i] >= '0' && a[i] <= '9') {
        b[j] = a[i];
        j++;
      }
    }
    i = 0;
    while (i <= j) {
      if (b[i] == '0') {
        b[i] = ' ';
      } else
        break;
      i++;
    }
    if (c == 0) {
      printf("%d", c);
    } else {
      for (i = 0; i <= j; i++) {
        if (b[i] >= '0' && b[i] <= '9') {
          printf("%c", b[i]);
        }
      }
    }
    printf("\n");
    memset(a, ' ', 10000);
    memset(b, ' ', 10000);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e40,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe97(%rip),%rdi
lea    -0x19(%rbp),%rsi
call   1070 <scanf@plt>
cmp    $0x1,%eax
jne    143d <main+0x2ed>
mov    $0x0,%al
call   1060 <getchar@plt>
lea    -0x2730(%rbp),%rsi
lea    0xe73(%rip),%rdi
call   1070 <scanf@plt>
movsbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    11c7 <main+0x77>
movsbl -0x2730(%rbp),%eax
cmp    $0x30,%eax
jne    11c7 <main+0x77>
movsbl -0x272f(%rbp),%eax
cmp    $0x0,%eax
jne    11c7 <main+0x77>
jmp    143d <main+0x2ed>
lea    -0x2730(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    122a <main+0xda>
movslq -0x8(%rbp),%rax
movsbl -0x2730(%rbp,%rax,1),%eax
ff
movsbl -0x19(%rbp),%ecx
add    $0x30,%ecx
cmp    %ecx,%eax
jne    1217 <main+0xc7>
movslq -0x8(%rbp),%rax
movb   $0x20,-0x2730(%rbp,%rax,1)
20
jmp    121c <main+0xcc>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11e4 <main+0x94>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ad <main+0x15d>
movslq -0x8(%rbp),%rax
movsbl -0x2730(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
jl     129a <main+0x14a>
movslq -0x8(%rbp),%rax
movsbl -0x2730(%rbp,%rax,1),%eax
ff
cmp    $0x39,%eax
jg     129a <main+0x14a>
imul   $0xa,-0x18(%rbp),%eax
movslq -0x8(%rbp),%rcx
movsbl -0x2730(%rbp,%rcx,1),%ecx
ff
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    1295 <main+0x145>
jmp    12ad <main+0x15d>
jmp    129a <main+0x14a>
jmp    129f <main+0x14f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1238 <main+0xe8>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1323 <main+0x1d3>
movslq -0x8(%rbp),%rax
movsbl -0x2730(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
jl     1310 <main+0x1c0>
movslq -0x8(%rbp),%rax
movsbl -0x2730(%rbp,%rax,1),%eax
ff
cmp    $0x39,%eax
jg     1310 <main+0x1c0>
movslq -0x8(%rbp),%rax
mov    -0x2730(%rbp,%rax,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x4e40(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1315 <main+0x1c5>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12bb <main+0x16b>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     136f <main+0x21f>
movslq -0x8(%rbp),%rax
movsbl -0x4e40(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
jne    135c <main+0x20c>
movslq -0x8(%rbp),%rax
movb   $0x20,-0x4e40(%rbp,%rax,1)
20
jmp    1361 <main+0x211>
jmp    136f <main+0x21f>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    132a <main+0x1da>
cmpl   $0x0,-0x18(%rbp)
jne    138f <main+0x23f>
mov    -0x18(%rbp),%esi
lea    0xc7d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13fe <main+0x2ae>
movl   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     13f9 <main+0x2a9>
movslq -0x8(%rbp),%rax
movsbl -0x4e40(%rbp,%rax,1),%eax
ff
cmp    $0x30,%eax
jl     13e6 <main+0x296>
movslq -0x8(%rbp),%rax
movsbl -0x4e40(%rbp,%rax,1),%eax
ff
cmp    $0x39,%eax
jg     13e6 <main+0x296>
movslq -0x8(%rbp),%rax
movsbl -0x4e40(%rbp,%rax,1),%esi
ff
lea    0xc27(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13eb <main+0x29b>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1396 <main+0x246>
jmp    13fe <main+0x2ae>
lea    0xc04(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x2730(%rbp),%rdi
mov    $0x20,%esi
mov    $0x2710,%edx
call   1050 <memset@plt>
lea    -0x4e40(%rbp),%rdi
mov    $0x20,%esi
mov    $0x2710,%edx
call   1050 <memset@plt>
jmp    1162 <main+0x12>
xor    %eax,%eax
add    $0x4e40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e38,%rsp
lea    0xe88(%rip),%rdi
lea    0xf(%rsp),%rsi
call   1080 <scanf@plt>
cmp    $0x1,%eax
jne    1494 <main+0x334>
lea    0xe71(%rip),%r14
lea    0x10(%rsp),%r13
lea    0xe62(%rip),%r15
jmp    11f5 <main+0x95>
mov    %r15,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r13,%rdi
mov    $0x20,%esi
mov    $0x2710,%edx
call   1060 <memset@plt>
lea    0x2720(%rsp),%rdi
mov    $0x20,%esi
mov    $0x2710,%edx
call   1060 <memset@plt>
mov    %r15,%rdi
lea    0xf(%rsp),%rsi
call   1080 <scanf@plt>
cmp    $0x1,%eax
jne    1494 <main+0x334>
xor    %eax,%eax
call   1070 <getchar@plt>
mov    %r14,%rdi
mov    %r13,%rsi
call   1080 <scanf@plt>
cmpb   $0x0,0xf(%rsp)
jne    1220 <main+0xc0>
cmpb   $0x30,0x10(%rsp)
jne    1220 <main+0xc0>
cmpb   $0x0,0x11(%rsp)
je     1494 <main+0x334>
mov    %r13,%rdi
call   1040 <strlen@plt>
xor    %ebp,%ebp
test   %eax,%eax
jle    1380 <main+0x220>
movsbl 0xf(%rsp),%edx
add    $0x30,%edx
mov    %eax,%ecx
cmp    $0x8,%eax
jae    1250 <main+0xf0>
xor    %esi,%esi
jmp    1369 <main+0x209>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%esi
and    $0xfffffff8,%esi
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %edi,%edi
jmp    127d <main+0x11d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x8,%rdi
cmp    %rdi,%rsi
je     1330 <main+0x1d0>
movq   0x10(%rsp,%rdi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm2
psrad  $0x18,%xmm2
pcmpeqd %xmm0,%xmm2
movd   %xmm2,%ebx
test   $0x1,%bl
je     12a2 <main+0x142>
movb   $0x20,0x10(%rsp,%rdi,1)
movdqa %xmm2,%xmm3
psrlq  $0x10,%xmm3
movd   %xmm3,%ebx
shr    $0x10,%ebx
test   $0x1,%bl
je     12bc <main+0x15c>
movb   $0x20,0x11(%rsp,%rdi,1)
pextrw $0x4,%xmm2,%ebx
test   $0x1,%bl
je     12cb <main+0x16b>
movb   $0x20,0x12(%rsp,%rdi,1)
pextrw $0x6,%xmm2,%ebx
test   $0x1,%bl
je     12da <main+0x17a>
movb   $0x20,0x13(%rsp,%rdi,1)
punpckhwd %xmm1,%xmm1
psrad  $0x18,%xmm1
pcmpeqd %xmm0,%xmm1
pextrw $0x0,%xmm1,%ebx
test   $0x1,%bl
je     12f6 <main+0x196>
movb   $0x20,0x14(%rsp,%rdi,1)
pextrw $0x2,%xmm1,%ebx
test   $0x1,%bl
je     1305 <main+0x1a5>
movb   $0x20,0x15(%rsp,%rdi,1)
pextrw $0x4,%xmm1,%ebx
test   $0x1,%bl
je     1314 <main+0x1b4>
movb   $0x20,0x16(%rsp,%rdi,1)
pextrw $0x7,%xmm1,%ebx
test   $0x1,%bl
je     1270 <main+0x110>
movb   $0x20,0x17(%rsp,%rdi,1)
jmp    1270 <main+0x110>
nopl   0x0(%rax)
cmp    %rcx,%rsi
jne    1369 <main+0x209>
test   %eax,%eax
jle    1380 <main+0x220>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl 0x10(%rsp,%rsi,1),%edx
lea    -0x31(%rdx),%edi
cmp    $0x8,%dil
jbe    1384 <main+0x224>
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1340 <main+0x1e0>
xor    %edx,%edx
test   %eax,%eax
jg     138b <main+0x22b>
jmp    13c0 <main+0x260>
nop
add    $0x1,%rsi
cmp    %rsi,%rcx
je     1335 <main+0x1d5>
movsbl 0x10(%rsp,%rsi,1),%edi
cmp    %edi,%edx
jne    1360 <main+0x200>
movb   $0x20,0x10(%rsp,%rsi,1)
jmp    1360 <main+0x200>
nopl   0x0(%rax)
xor    %edx,%edx
jmp    13c0 <main+0x260>
add    $0xffffffd0,%edx
test   %eax,%eax
jle    13c0 <main+0x260>
cmp    $0x1,%eax
jne    1434 <main+0x2d4>
xor    %eax,%eax
xor    %ebp,%ebp
test   $0x1,%cl
je     13b6 <main+0x256>
mov    0x10(%rsp,%rax,1),%al
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     13b6 <main+0x256>
movslq %ebp,%rbp
mov    %al,0x2720(%rsp,%rbp,1)
add    $0x1,%ebp
test   %ebp,%ebp
js     1485 <main+0x325>
xchg   %ax,%ax
lea    0x1(%rbp),%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
cmpb   $0x30,0x2720(%rsp,%rcx,1)
30
jne    13eb <main+0x28b>
movb   $0x20,0x2720(%rsp,%rcx,1)
20
add    $0x1,%rcx
cmp    %rcx,%rax
jne    13d0 <main+0x270>
xor    %eax,%eax
test   %edx,%edx
je     11a0 <main+0x40>
test   %al,%al
jne    11ac <main+0x4c>
add    $0x1,%ebp
xor    %r12d,%r12d
jmp    141d <main+0x2bd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
cmp    %r12,%rbp
je     11ac <main+0x4c>
movzbl 0x2720(%rsp,%r12,1),%edi
lea    -0x30(%rdi),%eax
cmp    $0x9,%al
ja     1410 <main+0x2b0>
call   1030 <putchar@plt>
jmp    1410 <main+0x2b0>
mov    %ecx,%esi
and    $0xfffffffe,%esi
xor    %eax,%eax
xor    %ebp,%ebp
jmp    144d <main+0x2ed>
nop
add    $0x2,%rax
cmp    %rax,%rsi
je     1398 <main+0x238>
movzbl 0x10(%rsp,%rax,1),%edi
lea    -0x30(%rdi),%ebx
cmp    $0x9,%bl
ja     1468 <main+0x308>
movslq %ebp,%rbp
mov    %dil,0x2720(%rsp,%rbp,1)
add    $0x1,%ebp
movzbl 0x11(%rsp,%rax,1),%edi
lea    -0x30(%rdi),%ebx
cmp    $0x9,%bl
ja     1440 <main+0x2e0>
movslq %ebp,%rbp
mov    %dil,0x2720(%rsp,%rbp,1)
add    $0x1,%ebp
jmp    1440 <main+0x2e0>
mov    $0x1,%al
test   %edx,%edx
jne    13f5 <main+0x295>
jmp    11a0 <main+0x40>
xor    %eax,%eax
add    $0x4e38,%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 = [3 x i8] c"%c\00"
@.str.3 = [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 i8
%8 = alloca [10000 x i8]
%9 = alloca [10000 x i8]
store i32 0, i32* %1
br label %10
10: ; preds = %183, %0
%11 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %7)
%12 = icmp eq i32 %11, 1
br i1 %12, label %13, label %189
13: ; preds = %10
%14 = call i32 (...) @getchar()
%15 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 0
%16 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %15)
%17 = load i8, i8* %7
%18 = sext i8 %17 to i32
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %31
20: ; preds = %13
%21 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 0
%22 = load i8, i8* %21
%23 = sext i8 %22 to i32
%24 = icmp eq i32 %23, 48
br i1 %24, label %25, label %31
25: ; preds = %20
%26 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 1
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 0
br i1 %29, label %30, label %31
30: ; preds = %25
br label %189
31: ; preds = %25, %20, %13
%32 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 0
%33 = call i32 @strlen(i8* %32)
store i32 %33, i32* %3
store i32 0, i32* %4
store i32 0, i32* %2
br label %34
34: ; preds = %53, %31
%35 = load i32, i32* %2
%36 = load i32, i32* %3
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %56
38: ; preds = %34
%39 = load i32, i32* %2
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %40
%42 = load i8, i8* %41
%43 = sext i8 %42 to i32
%44 = load i8, i8* %7
%45 = sext i8 %44 to i32
%46 = add nsw i32 %45, 48
%47 = icmp eq i32 %43, %46
br i1 %47, label %48, label %52
48: ; preds = %38
%49 = load i32, i32* %2
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %50
store i8 32, i8* %51
br label %52
52: ; preds = %48, %38
br label %53
53: ; preds = %52
%54 = load i32, i32* %2
%55 = add nsw i32 %54, 1
store i32 %55, i32* %2
br label %34
56: ; preds = %34
store i32 0, i32* %6
store i32 0, i32* %2
br label %57
57: ; preds = %90, %56
%58 = load i32, i32* %2
%59 = load i32, i32* %3
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %93
61: ; preds = %57
%62 = load i32, i32* %2
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = icmp sge i32 %66, 48
br i1 %67, label %68, label %89
68: ; preds = %61
%69 = load i32, i32* %2
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %70
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = icmp sle i32 %73, 57
br i1 %74, label %75, label %89
75: ; preds = %68
%76 = load i32, i32* %6
%77 = mul nsw i32 %76, 10
%78 = load i32, i32* %2
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %79
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = sub nsw i32 %82, 48
%84 = add nsw i32 %77, %83
store i32 %84, i32* %6
%85 = load i32, i32* %6
%86 = icmp sgt i32 %85, 0
br i1 %86, label %87, label %88
87: ; preds = %75
br label %93
88: ; preds = %75
br label %89
89: ; preds = %88, %68, %61
br label %90
90: ; preds = %89
%91 = load i32, i32* %2
%92 = add nsw i32 %91, 1
store i32 %92, i32* %2
br label %57
93: ; preds = %87, %57
store i32 0, i32* %5
store i32 0, i32* %2
br label %94
94: ; preds = %123, %93
%95 = load i32, i32* %2
%96 = load i32, i32* %3
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %126
98: ; preds = %94
%99 = load i32, i32* %2
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %100
%102 = load i8, i8* %101
%103 = sext i8 %102 to i32
%104 = icmp sge i32 %103, 48
br i1 %104, label %105, label %122
105: ; preds = %98
%106 = load i32, i32* %2
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %107
%109 = load i8, i8* %108
%110 = sext i8 %109 to i32
%111 = icmp sle i32 %110, 57
br i1 %111, label %112, label %122
112: ; preds = %105
%113 = load i32, i32* %2
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 %114
%116 = load i8, i8* %115
%117 = load i32, i32* %5
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %118
store i8 %116, i8* %119
%120 = load i32, i32* %5
%121 = add nsw i32 %120, 1
store i32 %121, i32* %5
br label %122
122: ; preds = %112, %105, %98
br label %123
123: ; preds = %122
%124 = load i32, i32* %2
%125 = add nsw i32 %124, 1
store i32 %125, i32* %2
br label %94
126: ; preds = %94
store i32 0, i32* %2
br label %127
127: ; preds = %143, %126
%128 = load i32, i32* %2
%129 = load i32, i32* %5
%130 = icmp sle i32 %128, %129
br i1 %130, label %131, label %146
131: ; preds = %127
%132 = load i32, i32* %2
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %133
%135 = load i8, i8* %134
%136 = sext i8 %135 to i32
%137 = icmp eq i32 %136, 48
br i1 %137, label %138, label %142
138: ; preds = %131
%139 = load i32, i32* %2
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %140
store i8 32, i8* %141
br label %143
142: ; preds = %131
br label %146
143: ; preds = %138
%144 = load i32, i32* %2
%145 = add nsw i32 %144, 1
store i32 %145, i32* %2
br label %127
146: ; preds = %142, %127
%147 = load i32, i32* %6
%148 = icmp eq i32 %147, 0
br i1 %148, label %149, label %152
149: ; preds = %146
%150 = load i32, i32* %6
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32 %150)
br label %183
152: ; preds = %146
store i32 0, i32* %2
br label %153
153: ; preds = %179, %152
%154 = load i32, i32* %2
%155 = load i32, i32* %5
%156 = icmp sle i32 %154, %155
br i1 %156, label %157, label %182
157: ; preds = %153
%158 = load i32, i32* %2
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = sext i8 %161 to i32
%163 = icmp sge i32 %162, 48
br i1 %163, label %164, label %178
164: ; preds = %157
%165 = load i32, i32* %2
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %166
%168 = load i8, i8* %167
%169 = sext i8 %168 to i32
%170 = icmp sle i32 %169, 57
br i1 %170, label %171, label %178
171: ; preds = %164
%172 = load i32, i32* %2
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 %173
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i32 %176)
br label %178
178: ; preds = %171, %164, %157
br label %179
179: ; preds = %178
%180 = load i32, i32* %2
%181 = add nsw i32 %180, 1
store i32 %181, i32* %2
br label %153
182: ; preds = %153
br label %183
183: ; preds = %182, %149
%184 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%185 = getelementptr inbounds [10000 x i8], [10000 x i8]* %8, i64 0, i64 0
%186 = call i32 @memset(i8* %185, i8 signext 32, i32 10000)
%187 = getelementptr inbounds [10000 x i8], [10000 x i8]* %9, i64 0, i64 0
%188 = call i32 @memset(i8* %187, i8 signext 32, i32 10000)
br label %10
189: ; preds = %30, %10
ret i32 0
}

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