void reverse(char *s, int len) {
  int i, j, newline;
  char temp[10000];
  newline = 0;
  --len;
  if (s[len] == '\n') {
    newline = 1;
    --len;
  }
  j = 0;
  for (i = len; i >= 0; i--) {
    temp[j] = s[i];
    j++;
  }
  for (i = 0; i <= len; i++)
    s[i] = temp[i];
  if (newline)
    s[++len] = '\n';
  s[++len] = '\0';
}


x86 assembly (clang, -O0):
<reverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x26b0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1147 <reverse+0x47>
movl   $0x1,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     118b <reverse+0x8b>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x2730(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1154 <reverse+0x54>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11c2 <reverse+0xc2>
movslq -0x10(%rbp),%rax
mov    -0x2730(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1192 <reverse+0x92>
cmpl   $0x0,-0x18(%rbp)
je     11e0 <reverse+0xe0>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0xc(%rbp)
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0xc(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x26b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2718,%rsp
mov    %rdi,%r14
movslq %esi,%r13
lea    -0x1(%r13),%r15
mov    -0x1(%rdi,%r13,1),%r12b
add    $0xfffffffe,%r13d
cmp    $0xa,%r12b
cmovne %r15d,%r13d
test   %r13d,%r13d
js     12b7 <reverse+0x1a7>
mov    %r13d,%edx
lea    0x1(%r13),%r8d
cmp    $0x7,%r13d
jae    115c <reverse+0x4c>
xor    %ecx,%ecx
mov    %rdx,%rsi
jmp    128b <reverse+0x17b>
cmp    $0x1f,%r13d
jae    1169 <reverse+0x59>
xor    %ecx,%ecx
jmp    121d <reverse+0x10d>
mov    %r8d,%ecx
and    $0xffffffe0,%ecx
lea    0x10(%rsp),%rsi
mov    %rcx,%rdi
neg    %rdi
lea    (%rdx,%r14,1),%rbp
add    $0xfffffffffffffff1,%rbp
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rbp,%rbx,1),%xmm1
movdqu 0x0(%rbp,%rbx,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
movdqa %xmm2,-0x10(%rsi)
movdqa %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rdi
jne    1190 <reverse+0x80>
cmp    %r8,%rcx
je     12a3 <reverse+0x193>
test   $0x18,%r8b
je     1285 <reverse+0x175>
mov    %rcx,%rdi
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    (%rsp,%rdi,1),%rbp
mov    %rcx,%rbx
neg    %rbx
neg    %rdi
lea    (%rdx,%r14,1),%rax
add    $0xfffffffffffffff9,%rax
mov    %rdx,%rsi
sub    %rcx,%rsi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%rax,%rdi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x0(%rbp)
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rdi
cmp    %rdi,%rbx
jne    1250 <reverse+0x140>
cmp    %r8,%rcx
jne    128b <reverse+0x17b>
jmp    12a3 <reverse+0x193>
mov    %rdx,%rsi
sub    %rcx,%rsi
add    %r14,%rsi
xchg   %ax,%ax
movzbl (%rsi),%eax
mov    %al,(%rsp,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
cmp    %rcx,%r8
jne    1290 <reverse+0x180>
test   %r13d,%r13d
js     12b7 <reverse+0x1a7>
add    $0x1,%rdx
mov    %rsp,%rsi
mov    %r14,%rdi
call   1030 <memcpy@plt>
cmp    $0xa,%r12b
jne    12ca <reverse+0x1ba>
movslq %r13d,%r15
movb   $0xa,0x1(%r14,%r15,1)
add    $0x1,%r15
movslq %r15d,%rax
movb   $0x0,0x1(%rax,%r14,1)
add    $0x2718,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @reverse(i8* nocapture %0, i32 %1) {
%3 = alloca [10000 x i8]
%4 = getelementptr inbounds [10000 x i8], [10000 x i8]* %3, i64 0, i64 0
%5 = getelementptr inbounds [10000 x i8], [10000 x i8]* %3, i64 0, i64 0
%6 = add nsw i32 %1, -1
%7 = sext i32 %6 to i64
%8 = getelementptr inbounds i8, i8* %0, i64 %7
%9 = load i8, i8* %8
%10 = icmp eq i8 %9, 10
%11 = add nsw i32 %1, -2
%12 = select i1 %10, i32 %11, i32 %6
%13 = icmp sgt i32 %12, -1
br i1 %13, label %14, label %83
14: ; preds = %2
%15 = zext i32 %12 to i64
%16 = add nuw nsw i32 %12, 1
%17 = zext i32 %16 to i64
%18 = icmp ult i32 %12, 7
br i1 %18, label %66, label %19
19: ; preds = %14
%20 = icmp ult i32 %12, 31
br i1 %20, label %48, label %21
21: ; preds = %19
%22 = and i64 %17, 4294967264
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %40, %23 ]
%25 = sub i64 %15, %24
%26 = getelementptr inbounds i8, i8* %0, i64 %25
%27 = getelementptr inbounds i8, i8* %26, i64 -15
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = shufflevector <16 x i8> %29, <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>
%31 = getelementptr inbounds i8, i8* %26, i64 -16
%32 = getelementptr inbounds i8, i8* %31, i64 -15
%33 = bitcast i8* %32 to <16 x i8>*
%34 = load <16 x i8>, <16 x i8>* %33
%35 = shufflevector <16 x i8> %34, <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>
%36 = getelementptr inbounds [10000 x i8], [10000 x i8]* %3, i64 0, i64 %24
%37 = bitcast i8* %36 to <16 x i8>*
store <16 x i8> %30, <16 x i8>* %37
%38 = getelementptr inbounds i8, i8* %36, i64 16
%39 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %35, <16 x i8>* %39
%40 = add nuw i64 %24, 32
%41 = icmp eq i64 %40, %22
br i1 %41, label %42, label %23
42: ; preds = %23
%43 = icmp eq i64 %22, %17
br i1 %43, label %69, label %44
44: ; preds = %42
%45 = sub nsw i64 %15, %22
%46 = and i64 %17, 24
%47 = icmp eq i64 %46, 0
br i1 %47, label %66, label %48
48: ; preds = %19, %44
%49 = phi i64 [ %22, %44 ], [ 0, %19 ]
%50 = and i64 %17, 4294967288
%51 = sub nsw i64 %15, %50
%52 = getelementptr inbounds i8, i8* %0, i64 -7
br label %53
53: ; preds = %53, %48
%54 = phi i64 [ %49, %48 ], [ %62, %53 ]
%55 = sub i64 %15, %54
%56 = getelementptr inbounds i8, i8* %52, i64 %55
%57 = bitcast i8* %56 to <8 x i8>*
%58 = load <8 x i8>, <8 x i8>* %57
%59 = shufflevector <8 x i8> %58, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%60 = getelementptr inbounds [10000 x i8], [10000 x i8]* %3, i64 0, i64 %54
%61 = bitcast i8* %60 to <8 x i8>*
store <8 x i8> %59, <8 x i8>* %61
%62 = add nuw i64 %54, 8
%63 = icmp eq i64 %62, %50
br i1 %63, label %64, label %53
64: ; preds = %53
%65 = icmp eq i64 %50, %17
br i1 %65, label %69, label %66
66: ; preds = %14, %44, %64
%67 = phi i64 [ %15, %14 ], [ %45, %44 ], [ %51, %64 ]
%68 = phi i64 [ 0, %14 ], [ %22, %44 ], [ %50, %64 ]
br label %74
69: ; preds = %74, %64, %42
%70 = icmp slt i32 %12, 0
br i1 %70, label %83, label %71
71: ; preds = %69
%72 = zext i32 %12 to i64
%73 = add nuw nsw i64 %72, 1
br label %83
74: ; preds = %66, %74
%75 = phi i64 [ %81, %74 ], [ %67, %66 ]
%76 = phi i64 [ %80, %74 ], [ %68, %66 ]
%77 = getelementptr inbounds i8, i8* %0, i64 %75
%78 = load i8, i8* %77
%79 = getelementptr inbounds [10000 x i8], [10000 x i8]* %3, i64 0, i64 %76
store i8 %78, i8* %79
%80 = add nuw nsw i64 %76, 1
%81 = add nsw i64 %75, -1
%82 = icmp eq i64 %80, %17
br i1 %82, label %69, label %74
83: ; preds = %2, %71, %69
br i1 %10, label %84, label %88
84: ; preds = %83
%85 = add nsw i32 %12, 1
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %0, i64 %86
store i8 10, i8* %87
br label %88
88: ; preds = %84, %83
%89 = phi i32 [ %85, %84 ], [ %6, %83 ]
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %0, i64 %91
store i8 0, i8* %92
ret void
}