#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*/ printf(char *, char *);
int main() {
  int mid;
  for (mid = 0; mid < 50; mid++) {
    int mid_tmp = mid;
    char mid_char[10];
    int j = 0;
    while (1) {
      mid_char[j] = '0' + mid_tmp % 10;
      j++;
      mid_tmp = mid_tmp / 10;
      if (mid_tmp == 0)
        break;
    }
    mid_char[j] = '\0';
    int k;
    char mid_char_reverse[10];
    for (k = j - 1; k >= 0; k--) {
      mid_char_reverse[j - 1 - k] = mid_char[k];
    }
    printf("%s\n", mid_char_reverse);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x32,-0x8(%rbp)
jge    11df <main+0xcf>
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x16(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    117b <main+0x6b>
jmp    1180 <main+0x70>
jmp    113d <main+0x2d>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0x16(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     11c1 <main+0xb1>
movslq -0x20(%rbp),%rax
mov    -0x16(%rbp,%rax,1),%cl
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
sub    -0x20(%rbp),%eax
cltq
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1192 <main+0x82>
lea    -0x2a(%rbp),%rsi
lea    0xe34(%rip),%rdi
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1126 <main+0x16>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x18,%rsp
xor    %r12d,%r12d
lea    0xedb(%rip),%r14
lea    0xe(%rsp),%r15
pxor   %xmm3,%xmm3
jmp    114d <main+0x3d>
mov    %r14,%rdi
mov    %r15,%rsi
call   1030 <printf@plt>
add    $0x1,%r12d
cmp    $0x32,%r12d
pxor   %xmm3,%xmm3
je     1378 <main+0x268>
xor    %edx,%edx
mov    %r12d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rax
movslq %ecx,%rsi
imul   $0x66666667,%rsi,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
lea    (%rcx,%rcx,1),%edx
lea    (%rdx,%rdx,4),%edx
mov    %esi,%edi
sub    %edx,%edi
add    $0x30,%dil
mov    %dil,0x4(%rsp,%rax,1)
lea    0x1(%rax),%rdx
add    $0x9,%esi
cmp    $0x12,%esi
ja     1160 <main+0x50>
mov    %edx,%edx
movslq %eax,%rcx
test   %rcx,%rcx
mov    $0x0,%esi
cmovs  %rcx,%rsi
movb   $0x0,0x4(%rsp,%rdx,1)
neg    %rsi
lea    (%rcx,%rsi,1),%r8
add    $0x1,%r8
cmp    $0x8,%r8
jae    1200 <main+0xf0>
mov    %rcx,%rdx
neg    %rdx
add    %rsp,%rdx
add    $0xe,%rdx
cltq
add    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%edx
movzbl 0x4(%rsp,%rdx,1),%edx
mov    %dl,(%rax)
lea    -0x1(%rcx),%rdx
add    $0x1,%rax
test   %rcx,%rcx
mov    %rdx,%rcx
jg     11e0 <main+0xd0>
jmp    1130 <main+0x20>
xchg   %ax,%ax
test   %rcx,%rcx
mov    $0x0,%esi
cmovs  %rcx,%rsi
mov    %rcx,%rdx
sub    %rsi,%rdx
cmp    %eax,%edx
ja     11c0 <main+0xb0>
shr    $0x20,%rdx
jne    11c0 <main+0xb0>
cmp    $0x20,%r8
jae    1229 <main+0x119>
xor    %edx,%edx
jmp    12fa <main+0x1ea>
mov    %r8,%rdx
and    $0xffffffffffffffe0,%rdx
movslq %eax,%rsi
test   %rsi,%rsi
mov    $0x0,%edi
cmovs  %rsi,%rdi
neg    %rdi
lea    (%rsi,%rdi,1),%r9
add    $0x1,%r9
and    $0xffffffffffffffe0,%r9
mov    %rax,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %esi,%edi
movdqu -0x1b(%rsp,%rdi,1),%xmm0
movdqu -0xb(%rsp,%rdi,1),%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,0xe(%rsp,%rbx,1)
movdqu %xmm0,0x1e(%rsp,%rbx,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rsi
cmp    %rbx,%r9
jne    1260 <main+0x150>
cmp    %rdx,%r8
je     1130 <main+0x20>
test   $0x18,%r8b
je     1370 <main+0x260>
pxor   %xmm3,%xmm3
movslq %eax,%rsi
test   %rsi,%rsi
mov    $0x0,%edi
cmovs  %rsi,%rdi
neg    %rdi
lea    (%rsi,%rdi,1),%r8
add    $0x1,%r8
mov    %r8,%rdi
and    $0xfffffffffffffff8,%rdi
sub    %rdi,%rcx
mov    %rax,%rbx
sub    %rdx,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%esi
movq   -0x3(%rsp,%rsi,1),%xmm0
punpcklbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movq   %xmm0,0xe(%rsp,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbx
cmp    %rdx,%rdi
jne    1330 <main+0x220>
cmp    %rdi,%r8
je     1130 <main+0x20>
jmp    11c0 <main+0xb0>
sub    %rdx,%rcx
jmp    11c0 <main+0xb0>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%s\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [10 x i8]
%5 = alloca i32
%6 = alloca i32
%7 = alloca [10 x i8]
store i32 0, i32* %1
store i32 0, i32* %2
br label %8
8: ; preds = %55, %0
%9 = load i32, i32* %2
%10 = icmp slt i32 %9, 50
br i1 %10, label %11, label %58
11: ; preds = %8
%12 = load i32, i32* %2
store i32 %12, i32* %3
store i32 0, i32* %5
br label %13
13: ; preds = %11, %28
%14 = load i32, i32* %3
%15 = srem i32 %14, 10
%16 = add nsw i32 48, %15
%17 = trunc i32 %16 to i8
%18 = load i32, i32* %5
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %19
store i8 %17, i8* %20
%21 = load i32, i32* %5
%22 = add nsw i32 %21, 1
store i32 %22, i32* %5
%23 = load i32, i32* %3
%24 = sdiv i32 %23, 10
store i32 %24, i32* %3
%25 = load i32, i32* %3
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %28
27: ; preds = %13
br label %29
28: ; preds = %13
br label %13
29: ; preds = %27
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %31
store i8 0, i8* %32
%33 = load i32, i32* %5
%34 = sub nsw i32 %33, 1
store i32 %34, i32* %6
br label %35
35: ; preds = %49, %29
%36 = load i32, i32* %6
%37 = icmp sge i32 %36, 0
br i1 %37, label %38, label %52
38: ; preds = %35
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [10 x i8], [10 x i8]* %4, i64 0, i64 %40
%42 = load i8, i8* %41
%43 = load i32, i32* %5
%44 = sub nsw i32 %43, 1
%45 = load i32, i32* %6
%46 = sub nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds [10 x i8], [10 x i8]* %7, i64 0, i64 %47
store i8 %42, i8* %48
br label %49
49: ; preds = %38
%50 = load i32, i32* %6
%51 = add nsw i32 %50, -1
store i32 %51, i32* %6
br label %35
52: ; preds = %35
%53 = getelementptr inbounds [10 x i8], [10 x i8]* %7, i64 0, i64 0
%54 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* %53)
br label %55
55: ; preds = %52
%56 = load i32, i32* %2
%57 = add nsw i32 %56, 1
store i32 %57, i32* %2
br label %8
58: ; preds = %8
ret i32 0
}

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