#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 EOF;
int getchar();
int getlittleline(char line[]) {
  int lastchar, idx;
  char readline[1000000];
  for (idx = 0;
       idx < 1000000 - 1 && (lastchar = getchar()) != EOF && lastchar != '\n';
       idx++)
    readline[idx] = lastchar;
  if (idx == 0) {
    return 0;
  }
  if (lastchar == '\n') {
    idx--;
  }
  int len = idx;
  for (; idx >= 0; idx--)
    line[len - idx] = readline[idx];
  if (len > 0) {
    if (lastchar == '\n') {
      line[++len] = '\n';
    }
    line[++len] = '\0';
  }
  return len;
}


x86 assembly (clang, -O0):
<getlittleline>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf4270,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0xf423f,-0x18(%rbp)
mov    %al,-0xf4265(%rbp)
jge    116b <getlittleline+0x5b>
mov    $0x0,%al
call   1030 <getchar@plt>
mov    %eax,%ecx
mov    %ecx,-0x14(%rbp)
xor    %eax,%eax
mov    0x2e98(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0xf4265(%rbp)
je     116b <getlittleline+0x5b>
cmpl   $0xa,-0x14(%rbp)
setne  %al
mov    %al,-0xf4265(%rbp)
mov    -0xf4265(%rbp),%al
test   $0x1,%al
jne    117e <getlittleline+0x6e>
jmp    119c <getlittleline+0x8c>
mov    -0x14(%rbp),%eax
mov    %al,%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0xf4260(%rbp,%rax,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1126 <getlittleline+0x16>
cmpl   $0x0,-0x18(%rbp)
jne    11b2 <getlittleline+0xa2>
movl   $0x0,-0x4(%rbp)
jmp    1258 <getlittleline+0x148>
cmpl   $0xa,-0x14(%rbp)
jne    11c5 <getlittleline+0xb5>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0xf4264(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     1204 <getlittleline+0xf4>
movslq -0x18(%rbp),%rax
mov    -0xf4260(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0xf4264(%rbp),%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11ce <getlittleline+0xbe>
cmpl   $0x0,-0xf4264(%rbp)
jle    124f <getlittleline+0x13f>
cmpl   $0xa,-0x14(%rbp)
jne    1235 <getlittleline+0x125>
mov    -0x10(%rbp),%rax
mov    -0xf4264(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0xf4264(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0xf4264(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0xf4264(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0xf4264(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf4270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getlittleline>:
push   %r15
push   %r14
push   %rbx
sub    $0xf4240,%rsp
mov    %rdi,%r14
mov    0x2ec2(%rip),%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1030 <getchar@plt>
cmp    $0xa,%eax
je     1158 <getlittleline+0x48>
cmp    (%r15),%eax
je     1158 <getlittleline+0x48>
mov    %al,(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    $0xf423f,%rbx
jne    1130 <getlittleline+0x20>
mov    $0xf423f,%ebx
jmp    115c <getlittleline+0x4c>
test   %ebx,%ebx
je     119b <getlittleline+0x8b>
xor    %ecx,%ecx
cmp    $0xa,%eax
sete   %cl
mov    %ebx,%r10d
sub    %ecx,%r10d
js     1358 <getlittleline+0x248>
mov    %r10d,%r9d
mov    %r9,%r11
cmp    $0x7,%r10d
jb     12b2 <getlittleline+0x1a2>
lea    0x1(%r9),%r8
movabs $0x1ffffffe0,%r15
cmp    $0x1f,%r10d
jae    11a3 <getlittleline+0x93>
xor    %esi,%esi
jmp    1257 <getlittleline+0x147>
xor    %r10d,%r10d
jmp    1358 <getlittleline+0x248>
mov    %r8,%rsi
and    %r15,%rsi
xor    %edx,%edx
pxor   %xmm0,%xmm0
mov    %r9,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%edi
movdqu -0x1f(%rsp,%rdi,1),%xmm1
movdqu -0xf(%rsp,%rdi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%r14,%rdx,1)
movdqu %xmm1,0x10(%r14,%rdx,1)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rcx
cmp    %rdx,%rsi
jne    11c0 <getlittleline+0xb0>
cmp    %rsi,%r8
je     1334 <getlittleline+0x224>
test   $0x18,%r8b
je     12ac <getlittleline+0x19c>
add    $0x18,%r15
and    %r8,%r15
mov    %r9,%r11
sub    %r15,%r11
mov    %r9,%rcx
sub    %rsi,%rcx
pxor   %xmm0,%xmm0
xchg   %ax,%ax
mov    %ecx,%edx
movq   -0x7(%rsp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r14,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rcx
cmp    %rsi,%r15
jne    1270 <getlittleline+0x160>
cmp    %r15,%r8
jne    12b2 <getlittleline+0x1a2>
jmp    1334 <getlittleline+0x224>
mov    %r9,%r11
sub    %rsi,%r11
lea    0x1(%r11),%r8d
mov    %r11,%rsi
and    $0x3,%r8
je     12e6 <getlittleline+0x1d6>
mov    %r9,%rdi
sub    %r11,%rdi
add    %r14,%rdi
xor    %edx,%edx
mov    %r11,%rsi
nopl   (%rax)
mov    %esi,%ecx
movzbl (%rsp,%rcx,1),%ecx
mov    %cl,(%rdi,%rdx,1)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rdx
cmp    %rdx,%r8
jne    12d0 <getlittleline+0x1c0>
cmp    $0x3,%r11
jb     1334 <getlittleline+0x224>
mov    %r9,%rcx
sub    %rsi,%rcx
add    $0xfffffffffffffffd,%rsi
add    %r14,%rcx
add    $0x3,%rcx
nopl   (%rax)
lea    0x3(%rsi),%edx
movzbl (%rsp,%rdx,1),%edx
mov    %dl,-0x3(%rcx)
lea    0x2(%rsi),%edx
movzbl (%rsp,%rdx,1),%edx
mov    %dl,-0x2(%rcx)
lea    0x1(%rsi),%edx
movzbl (%rsp,%rdx,1),%edx
mov    %dl,-0x1(%rcx)
mov    %esi,%edx
movzbl (%rsp,%rdx,1),%edx
mov    %dl,(%rcx)
add    $0xfffffffffffffffc,%rsi
add    $0x4,%rcx
cmp    $0xfffffffffffffffc,%rsi
jne    1300 <getlittleline+0x1f0>
test   %r10d,%r10d
jle    1358 <getlittleline+0x248>
cmp    $0xa,%eax
jne    134b <getlittleline+0x23b>
movb   $0xa,0x1(%r14,%r9,1)
add    $0x1,%r9
mov    %r9d,%ebx
mov    %ebx,%r10d
movb   $0x0,0x1(%r14,%r10,1)
add    $0x1,%r10
mov    %r10d,%eax
add    $0xf4240,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
@EOF = global i32 0
define i32 @getlittleline(i8* nocapture writeonly %0) {
%2 = alloca [1000000 x i8]
%3 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 0
br label %4
4: ; preds = %1, %11
%5 = phi i64 [ 0, %1 ], [ %14, %11 ]
%6 = tail call i32 (...) @getchar()
%7 = load i32, i32* @EOF
%8 = icmp ne i32 %6, %7
%9 = icmp ne i32 %6, 10
%10 = and i1 %9, %8
br i1 %10, label %11, label %16
11: ; preds = %4
%12 = trunc i32 %6 to i8
%13 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %5
store i8 %12, i8* %13
%14 = add nuw nsw i64 %5, 1
%15 = icmp eq i64 %14, 999999
br i1 %15, label %19, label %4
16: ; preds = %4
%17 = trunc i64 %5 to i32
%18 = icmp eq i32 %17, 0
br i1 %18, label %136, label %19
19: ; preds = %11, %16
%20 = phi i32 [ %17, %16 ], [ 999999, %11 ]
%21 = icmp eq i32 %6, 10
%22 = sext i1 %21 to i32
%23 = add i32 %20, %22
%24 = icmp sgt i32 %23, -1
br i1 %24, label %25, label %136
25: ; preds = %19
%26 = zext i32 %23 to i64
%27 = add nuw nsw i64 %26, 1
%28 = icmp ult i32 %23, 7
br i1 %28, label %78, label %29
29: ; preds = %25
%30 = icmp ult i32 %23, 31
br i1 %30, label %58, label %31
31: ; preds = %29
%32 = and i64 %27, 8589934560
br label %33
33: ; preds = %33, %31
%34 = phi i64 [ 0, %31 ], [ %50, %33 ]
%35 = sub i64 %26, %34
%36 = and i64 %35, 4294967295
%37 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %36
%38 = getelementptr inbounds i8, i8* %37, i64 -15
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = shufflevector <16 x i8> %40, <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>
%42 = getelementptr inbounds i8, i8* %37, i64 -31
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = shufflevector <16 x i8> %44, <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>
%46 = getelementptr inbounds i8, i8* %0, i64 %34
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %41, <16 x i8>* %47
%48 = getelementptr inbounds i8, i8* %46, i64 16
%49 = bitcast i8* %48 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %49
%50 = add nuw i64 %34, 32
%51 = icmp eq i64 %50, %32
br i1 %51, label %52, label %33
52: ; preds = %33
%53 = icmp eq i64 %27, %32
br i1 %53, label %124, label %54
54: ; preds = %52
%55 = sub nsw i64 %26, %32
%56 = and i64 %27, 24
%57 = icmp eq i64 %56, 0
br i1 %57, label %78, label %58
58: ; preds = %29, %54
%59 = phi i64 [ %32, %54 ], [ 0, %29 ]
%60 = add nuw nsw i64 %26, 1
%61 = and i64 %60, 8589934584
%62 = sub nsw i64 %26, %61
br label %63
63: ; preds = %63, %58
%64 = phi i64 [ %59, %58 ], [ %74, %63 ]
%65 = sub i64 %26, %64
%66 = and i64 %65, 4294967295
%67 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %66
%68 = getelementptr inbounds i8, i8* %67, i64 -7
%69 = bitcast i8* %68 to <8 x i8>*
%70 = load <8 x i8>, <8 x i8>* %69
%71 = shufflevector <8 x i8> %70, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%72 = getelementptr inbounds i8, i8* %0, i64 %64
%73 = bitcast i8* %72 to <8 x i8>*
store <8 x i8> %71, <8 x i8>* %73
%74 = add nuw i64 %64, 8
%75 = icmp eq i64 %74, %61
br i1 %75, label %76, label %63
76: ; preds = %63
%77 = icmp eq i64 %60, %61
br i1 %77, label %124, label %78
78: ; preds = %25, %54, %76
%79 = phi i64 [ %26, %25 ], [ %55, %54 ], [ %62, %76 ]
%80 = add nsw i64 %79, 1
%81 = and i64 %80, 3
%82 = icmp eq i64 %81, 0
br i1 %82, label %94, label %83
83: ; preds = %78, %83
%84 = phi i64 [ %91, %83 ], [ %79, %78 ]
%85 = phi i64 [ %92, %83 ], [ 0, %78 ]
%86 = and i64 %84, 4294967295
%87 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %86
%88 = load i8, i8* %87
%89 = sub nuw nsw i64 %26, %84
%90 = getelementptr inbounds i8, i8* %0, i64 %89
store i8 %88, i8* %90
%91 = add nsw i64 %84, -1
%92 = add i64 %85, 1
%93 = icmp eq i64 %92, %81
br i1 %93, label %94, label %83
94: ; preds = %83, %78
%95 = phi i64 [ %79, %78 ], [ %91, %83 ]
%96 = icmp ult i64 %79, 3
br i1 %96, label %124, label %97
97: ; preds = %94, %97
%98 = phi i64 [ %122, %97 ], [ %95, %94 ]
%99 = and i64 %98, 4294967295
%100 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %99
%101 = load i8, i8* %100
%102 = sub nuw nsw i64 %26, %98
%103 = getelementptr inbounds i8, i8* %0, i64 %102
store i8 %101, i8* %103
%104 = add nsw i64 %98, -1
%105 = and i64 %104, 4294967295
%106 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %105
%107 = load i8, i8* %106
%108 = sub nuw nsw i64 %26, %104
%109 = getelementptr inbounds i8, i8* %0, i64 %108
store i8 %107, i8* %109
%110 = add nsw i64 %98, -2
%111 = and i64 %110, 4294967295
%112 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %111
%113 = load i8, i8* %112
%114 = sub nuw nsw i64 %26, %110
%115 = getelementptr inbounds i8, i8* %0, i64 %114
store i8 %113, i8* %115
%116 = add nsw i64 %98, -3
%117 = and i64 %116, 4294967295
%118 = getelementptr inbounds [1000000 x i8], [1000000 x i8]* %2, i64 0, i64 %117
%119 = load i8, i8* %118
%120 = sub nuw nsw i64 %26, %116
%121 = getelementptr inbounds i8, i8* %0, i64 %120
store i8 %119, i8* %121
%122 = add nsw i64 %98, -4
%123 = icmp eq i64 %116, 0
br i1 %123, label %124, label %97
124: ; preds = %94, %97, %76, %52
%125 = icmp sgt i32 %23, 0
br i1 %125, label %126, label %136
126: ; preds = %124
br i1 %21, label %127, label %131
127: ; preds = %126
%128 = add nuw nsw i32 %23, 1
%129 = zext i32 %128 to i64
%130 = getelementptr inbounds i8, i8* %0, i64 %129
store i8 10, i8* %130
br label %131
131: ; preds = %127, %126
%132 = phi i32 [ %128, %127 ], [ %20, %126 ]
%133 = add nuw nsw i32 %132, 1
%134 = zext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %0, i64 %134
store i8 0, i8* %135
br label %136
136: ; preds = %19, %124, %131, %16
%137 = phi i32 [ 0, %16 ], [ %133, %131 ], [ %23, %124 ], [ %23, %19 ]
ret i32 %137
}