char *reverse(char *string) {
  static char back[64];
  int len = 0;
  int x;
  while (*string) {
    len++;
    string++;
  }
  string--;
  for (x = 0; x < len; x++) {
    back[x] = *string;
    string--;
  }
  back[x] = '\0';
  return (back);
}


x86 assembly (clang, -O0):
<reverse>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     1136 <reverse+0x36>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    110f <reverse+0xf>
mov    -0x8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1183 <reverse+0x83>
mov    -0x8(%rbp),%rax
mov    (%rax),%dl
movslq -0x10(%rbp),%rcx
lea    0x2eca(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1149 <reverse+0x49>
movslq -0x10(%rbp),%rcx
lea    0x2ea2(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2e97(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse>:
push   %rbx
cmpb   $0x0,(%rdi)
je     11ee <reverse+0xee>
xor    %ebx,%ebx
nopl   0x0(%rax)
cmpb   $0x0,0x1(%rdi,%rbx,1)
lea    0x1(%rbx),%rbx
jne    1110 <reverse+0x10>
lea    -0x1(%rbx),%rax
lea    (%rdi,%rbx,1),%rdx
cmp    $0x7,%eax
jb     114b <reverse+0x4b>
lea    0x2f01(%rip),%r8
mov    %rdx,%r9
sub    %rbx,%r9
cmp    %r8,%rdx
jbe    11fd <reverse+0xfd>
lea    (%r8,%rbx,1),%rsi
cmp    %rsi,%r9
jae    11fd <reverse+0xfd>
xor    %eax,%eax
mov    %rax,%r8
not    %r8
add    %rbx,%r8
test   $0x3,%bl
je     1195 <reverse+0x95>
mov    $0x1,%esi
sub    %rbx,%rsi
mov    $0x1,%cl
sub    %sil,%cl
movzbl %cl,%edi
and    $0x3,%edi
lea    0x2ebb(%rip),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%rdx),%ecx
add    $0xffffffffffffffff,%rdx
mov    %cl,(%rax,%rsi,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1180 <reverse+0x80>
cmp    $0x3,%r8
jb     11f0 <reverse+0xf0>
mov    %rax,%rsi
sub    %rbx,%rsi
add    $0x1,%rsi
lea    0x2e84(%rip),%rcx
add    %rcx,%rax
add    $0x3,%rax
mov    $0x1,%edi
nopl   0x0(%rax,%rax,1)
movzbl -0x2(%rdx,%rdi,1),%ecx
mov    %cl,-0x3(%rax)
movzbl -0x3(%rdx,%rdi,1),%ecx
mov    %cl,-0x2(%rax)
movzbl -0x4(%rdx,%rdi,1),%ecx
mov    %cl,-0x1(%rax)
movzbl -0x5(%rdx,%rdi,1),%ecx
mov    %cl,(%rax)
add    $0xfffffffffffffffc,%rdi
add    $0x4,%rax
cmp    %rdi,%rsi
jne    11c0 <reverse+0xc0>
jmp    11f0 <reverse+0xf0>
xor    %ebx,%ebx
lea    0x2e39(%rip),%rax
movb   $0x0,(%rbx,%rax,1)
pop    %rbx
ret
cmp    $0x1f,%eax
jae    1209 <reverse+0x109>
xor    %eax,%eax
jmp    12c6 <reverse+0x1c6>
mov    %ebx,%eax
and    $0x7fffffe0,%eax
mov    %rax,%r10
neg    %r10
lea    0x2e23(%rip),%rsi
xor    %edx,%edx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r9,%rdx,1),%r11
movdqu -0x20(%rbx,%r11,1),%xmm1
movdqu -0x10(%rbx,%r11,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    $0xffffffffffffffe0,%rdx
add    $0x20,%rsi
cmp    %rdx,%r10
jne    1230 <reverse+0x130>
cmp    %rax,%rbx
je     11f0 <reverse+0xf0>
test   $0x18,%bl
je     133c <reverse+0x23c>
mov    %rax,%rsi
mov    %ebx,%eax
and    $0x7ffffff8,%eax
mov    %ebx,%r10d
shr    $0x3,%r10d
and    $0xfffffff,%r10d
shl    $0x3,%r10
sub    %r10,%r9
mov    %r9,%rdx
add    %rbx,%rdx
sub    %rsi,%rdi
add    %rbx,%rdi
add    $0xfffffffffffffff8,%rdi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movq   (%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi,%r8,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdi
cmp    %rsi,%r10
jne    1300 <reverse+0x200>
cmp    %rax,%rbx
jne    114d <reverse+0x4d>
jmp    11f0 <reverse+0xf0>
mov    %ebx,%edx
and    $0x7fffffe0,%edx
sub    %rdx,%r9
add    %rbx,%r9
mov    %r9,%rdx
jmp    114d <reverse+0x4d>

LLVM IR (-O0):
@reverse.back = internal global [64 x i8] zeroinitializer
define i8* @reverse(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
store i8* %0, i8** %2
store i32 0, i32* %3
br label %5
5: ; preds = %9, %1
%6 = load i8*, i8** %2
%7 = load i8, i8* %6
%8 = icmp ne i8 %7, 0
br i1 %8, label %9, label %14
9: ; preds = %5
%10 = load i32, i32* %3
%11 = add nsw i32 %10, 1
store i32 %11, i32* %3
%12 = load i8*, i8** %2
%13 = getelementptr inbounds i8, i8* %12, i32 1
store i8* %13, i8** %2
br label %5
14: ; preds = %5
%15 = load i8*, i8** %2
%16 = getelementptr inbounds i8, i8* %15, i32 -1
store i8* %16, i8** %2
store i32 0, i32* %4
br label %17
17: ; preds = %29, %14
%18 = load i32, i32* %4
%19 = load i32, i32* %3
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %32
21: ; preds = %17
%22 = load i8*, i8** %2
%23 = load i8, i8* %22
%24 = load i32, i32* %4
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %25
store i8 %23, i8* %26
%27 = load i8*, i8** %2
%28 = getelementptr inbounds i8, i8* %27, i32 -1
store i8* %28, i8** %2
br label %29
29: ; preds = %21
%30 = load i32, i32* %4
%31 = add nsw i32 %30, 1
store i32 %31, i32* %4
br label %17
32: ; preds = %17
%33 = load i32, i32* %4
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %34
store i8 0, i8* %35
ret i8* getelementptr inbounds ([64 x i8], [64 x i8]* @reverse.back, i64 0, i64 0)
}

LLVM IR (-O2):
@reverse.back = internal global [64 x i8] zeroinitializer
define i8* @reverse(i8* nocapture %0) {
%2 = load i8, i8* %0
%3 = icmp eq i8 %2, 0
br i1 %3, label %113, label %84
4: ; preds = %84
%5 = zext i32 %87 to i64
%6 = icmp ult i32 %85, 7
br i1 %6, label %63, label %7
7: ; preds = %4
%8 = getelementptr [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %5
%9 = sub nsw i64 0, %5
%10 = getelementptr i8, i8* %88, i64 %9
%11 = icmp ugt i8* %88, getelementptr inbounds ([64 x i8], [64 x i8]* @reverse.back, i64 0, i64 0)
%12 = icmp ult i8* %10, %8
%13 = and i1 %11, %12
br i1 %13, label %63, label %14
14: ; preds = %7
%15 = icmp ult i32 %85, 31
br i1 %15, label %44, label %16
16: ; preds = %14
%17 = and i64 %5, 2147483616
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %35, %18 ]
%20 = sub i64 0, %19
%21 = getelementptr inbounds i8, i8* %86, i64 %20
%22 = getelementptr inbounds i8, i8* %21, i64 -15
%23 = bitcast i8* %22 to <16 x i8>*
%24 = load <16 x i8>, <16 x i8>* %23
%25 = shufflevector <16 x i8> %24, <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>
%26 = getelementptr inbounds i8, i8* %21, i64 -16
%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 [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %19
%32 = bitcast i8* %31 to <16 x i8>*
store <16 x i8> %25, <16 x i8>* %32
%33 = getelementptr inbounds i8, i8* %31, i64 16
%34 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> %30, <16 x i8>* %34
%35 = add nuw i64 %19, 32
%36 = icmp eq i64 %35, %17
br i1 %36, label %37, label %18
37: ; preds = %18
%38 = icmp eq i64 %17, %5
br i1 %38, label %111, label %39
39: ; preds = %37
%40 = sub nsw i64 0, %17
%41 = getelementptr i8, i8* %88, i64 %40
%42 = and i64 %5, 24
%43 = icmp eq i64 %42, 0
br i1 %43, label %63, label %44
44: ; preds = %14, %39
%45 = phi i64 [ %17, %39 ], [ 0, %14 ]
%46 = and i64 %5, 2147483640
%47 = sub nsw i64 0, %46
%48 = getelementptr i8, i8* %88, i64 %47
%49 = getelementptr inbounds i8, i8* %86, i64 -7
br label %50
50: ; preds = %50, %44
%51 = phi i64 [ %45, %44 ], [ %59, %50 ]
%52 = sub i64 0, %51
%53 = getelementptr inbounds i8, i8* %49, i64 %52
%54 = bitcast i8* %53 to <8 x i8>*
%55 = load <8 x i8>, <8 x i8>* %54
%56 = shufflevector <8 x i8> %55, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%57 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %51
%58 = bitcast i8* %57 to <8 x i8>*
store <8 x i8> %56, <8 x i8>* %58
%59 = add nuw i64 %51, 8
%60 = icmp eq i64 %59, %46
br i1 %60, label %61, label %50
61: ; preds = %50
%62 = icmp eq i64 %46, %5
br i1 %62, label %111, label %63
63: ; preds = %7, %4, %39, %61
%64 = phi i64 [ 0, %4 ], [ 0, %7 ], [ %17, %39 ], [ %46, %61 ]
%65 = phi i8* [ %88, %4 ], [ %88, %7 ], [ %41, %39 ], [ %48, %61 ]
%66 = xor i64 %64, -1
%67 = add nsw i64 %66, %5
%68 = and i64 %5, 3
%69 = icmp eq i64 %68, 0
br i1 %69, label %80, label %70
70: ; preds = %63, %70
%71 = phi i64 [ %77, %70 ], [ %64, %63 ]
%72 = phi i8* [ %74, %70 ], [ %65, %63 ]
%73 = phi i64 [ %78, %70 ], [ 0, %63 ]
%74 = getelementptr inbounds i8, i8* %72, i64 -1
%75 = load i8, i8* %74
%76 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %71
store i8 %75, i8* %76
%77 = add nuw nsw i64 %71, 1
%78 = add i64 %73, 1
%79 = icmp eq i64 %78, %68
br i1 %79, label %80, label %70
80: ; preds = %70, %63
%81 = phi i64 [ %64, %63 ], [ %77, %70 ]
%82 = phi i8* [ %65, %63 ], [ %74, %70 ]
%83 = icmp ult i64 %67, 3
br i1 %83, label %111, label %91
84: ; preds = %1, %84
%85 = phi i32 [ %87, %84 ], [ 0, %1 ]
%86 = phi i8* [ %88, %84 ], [ %0, %1 ]
%87 = add nuw nsw i32 %85, 1
%88 = getelementptr inbounds i8, i8* %86, i64 1
%89 = load i8, i8* %88
%90 = icmp eq i8 %89, 0
br i1 %90, label %4, label %84
91: ; preds = %80, %91
%92 = phi i64 [ %109, %91 ], [ %81, %80 ]
%93 = phi i8* [ %106, %91 ], [ %82, %80 ]
%94 = getelementptr inbounds i8, i8* %93, i64 -1
%95 = load i8, i8* %94
%96 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %92
store i8 %95, i8* %96
%97 = add nuw nsw i64 %92, 1
%98 = getelementptr inbounds i8, i8* %93, i64 -2
%99 = load i8, i8* %98
%100 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %97
store i8 %99, i8* %100
%101 = add nuw nsw i64 %92, 2
%102 = getelementptr inbounds i8, i8* %93, i64 -3
%103 = load i8, i8* %102
%104 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %101
store i8 %103, i8* %104
%105 = add nuw nsw i64 %92, 3
%106 = getelementptr inbounds i8, i8* %93, i64 -4
%107 = load i8, i8* %106
%108 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %105
store i8 %107, i8* %108
%109 = add nuw nsw i64 %92, 4
%110 = icmp eq i64 %109, %5
br i1 %110, label %111, label %91
111: ; preds = %80, %91, %61, %37
%112 = zext i32 %87 to i64
br label %113
113: ; preds = %111, %1
%114 = phi i64 [ 0, %1 ], [ %112, %111 ]
%115 = getelementptr inbounds [64 x i8], [64 x i8]* @reverse.back, i64 0, i64 %114
store i8 0, i8* %115
ret i8* getelementptr inbounds ([64 x i8], [64 x i8]* @reverse.back, i64 0, i64 0)
}