#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 */
char *malloc(int);
char *reverse(char *original) {
  int k = 0, i = 0;
  while (*(original + k++) != '\0')
    ;
  k--;
  char *rev = malloc(k);
  for (; i < k; i++) {
    *(rev + i) = *(original + (k - i - 1));
  }
  *(rev + k) = '\0';
  return rev;
}


x86 assembly (clang, -O0):
<reverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0xc(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     114e <reverse+0x3e>
jmp    112a <reverse+0x1a>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119b <reverse+0x8b>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1163 <reverse+0x53>
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
movabs $0x200000000,%rbx
movabs $0x300000000,%r13
mov    $0xffffffffffffffff,%r12
movabs $0xffffffff00000000,%r15
ff ff ff
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r15,%rbx
add    %r15,%r13
cmpb   $0x0,0x1(%r14,%r12,1)
lea    0x1(%r12),%r12
jne    1150 <reverse+0x40>
mov    %r12d,%edi
call   1030 <malloc@plt>
mov    %r12d,%r9d
test   %r12d,%r12d
je     11fe <reverse+0xee>
cmp    $0x8,%r9d
jae    1212 <reverse+0x102>
xor    %ebp,%ebp
mov    %r12d,%edx
sub    %ebp,%edx
lea    0x1(%rbp),%rcx
test   $0x1,%dl
je     11a9 <reverse+0x99>
mov    %rbp,%rdx
imul   %r15,%rdx
sub    %rbx,%rdx
sar    $0x20,%rdx
mov    (%r14,%rdx,1),%dl
mov    %dl,(%rax,%rbp,1)
mov    %rcx,%rbp
cmp    %rcx,%r9
je     11fe <reverse+0xee>
movabs $0xfffffffe00000000,%rcx
ff ff ff
mov    %r12d,%edx
imul   %rbp,%r15
mov    %r15,%rdi
sub    %r13,%rdi
sub    %rbx,%r15
nopl   0x0(%rax,%rax,1)
mov    %r15,%rsi
sar    $0x20,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,(%rax,%rbp,1)
mov    %rdi,%rsi
sar    $0x20,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,0x1(%rax,%rbp,1)
add    $0x2,%rbp
add    %rcx,%rdi
add    %rcx,%r15
cmp    %rbp,%rdx
jne    11d0 <reverse+0xc0>
movb   $0x0,(%rax,%r9,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r9),%rcx
lea    -0x1(%r12),%edx
mov    %edx,%edi
sub    %ecx,%edi
xor    %ebp,%ebp
cmp    %edx,%edi
jg     1183 <reverse+0x73>
shr    $0x20,%rcx
jne    1183 <reverse+0x73>
cmp    $0x20,%r9d
jae    1240 <reverse+0x130>
xor    %ebp,%ebp
jmp    130f <reverse+0x1ff>
mov    %rbx,%rdx
neg    %rdx
mov    %r12d,%r11d
mov    %r12d,%r8d
and    $0x1f,%r8d
mov    %r9,%rbp
sub    %r8,%rbp
sub    %r8,%r11
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
movabs $0xffffffe000000000,%r10
ff ff ff
nopl   0x0(%rax)
mov    %rdx,%rdi
sar    $0x20,%rdi
movdqu -0x1f(%r14,%rdi,1),%xmm1
movdqu -0xf(%r14,%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,(%rax,%rcx,1)
movdqu %xmm1,0x10(%rax,%rcx,1)
add    $0x20,%rcx
add    %r10,%rdx
cmp    %rcx,%r11
jne    1270 <reverse+0x160>
test   %r8,%r8
je     11fe <reverse+0xee>
cmp    $0x8,%r8d
jb     1183 <reverse+0x73>
mov    %rbp,%rsi
mov    %r12d,%edi
mov    %r12d,%r8d
and    $0x7,%r8d
mov    %r9,%rbp
sub    %r8,%rbp
mov    %rsi,%rdx
imul   %r15,%rdx
sub    %rbx,%rdx
sub    %r8,%rdi
pxor   %xmm0,%xmm0
movabs $0xfffffff800000000,%r10
ff ff ff
nopl   (%rax)
mov    %rdx,%rcx
sar    $0x20,%rcx
movq   -0x7(%r14,%rcx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rax,%rsi,1)
add    $0x8,%rsi
add    %r10,%rdx
cmp    %rsi,%rdi
jne    1340 <reverse+0x230>
test   %r8,%r8
jne    1183 <reverse+0x73>
jmp    11fe <reverse+0xee>

LLVM IR (-O0):
define i8* @reverse(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
store i8* %0, i8** %2
store i32 0, i32* %3
store i32 0, i32* %4
br label %6
6: ; preds = %15, %1
%7 = load i8*, i8** %2
%8 = load i32, i32* %3
%9 = add nsw i32 %8, 1
store i32 %9, i32* %3
%10 = sext i32 %8 to i64
%11 = getelementptr inbounds i8, i8* %7, i64 %10
%12 = load i8, i8* %11
%13 = sext i8 %12 to i32
%14 = icmp ne i32 %13, 0
br i1 %14, label %15, label %16
15: ; preds = %6
br label %6
16: ; preds = %6
%17 = load i32, i32* %3
%18 = add nsw i32 %17, -1
store i32 %18, i32* %3
%19 = load i32, i32* %3
%20 = call i8* @malloc(i32 %19)
store i8* %20, i8** %5
br label %21
21: ; preds = %38, %16
%22 = load i32, i32* %4
%23 = load i32, i32* %3
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %41
25: ; preds = %21
%26 = load i8*, i8** %2
%27 = load i32, i32* %3
%28 = load i32, i32* %4
%29 = sub nsw i32 %27, %28
%30 = sub nsw i32 %29, 1
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i8, i8* %26, i64 %31
%33 = load i8, i8* %32
%34 = load i8*, i8** %5
%35 = load i32, i32* %4
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
store i8 %33, i8* %37
br label %38
38: ; preds = %25
%39 = load i32, i32* %4
%40 = add nsw i32 %39, 1
store i32 %40, i32* %4
br label %21
41: ; preds = %21
%42 = load i8*, i8** %5
%43 = load i32, i32* %3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
store i8 0, i8* %45
%46 = load i8*, i8** %5
ret i8* %46
}

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