#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 */
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ puts(char *);
int strlen(char *);
void reverse_sub(char *s) {
  int len = strlen(s);
  char *t = (char *)malloc(len + 1);
  char *token, *token_end;
  int size, total_size = 0;
  token_end = token = s;
  while (*s) {
    token = s;
    while (*s != ' ' && *s != '\0')
      s++;
    if (*s == '\n')
      break;
    token_end = s;
    size = token_end - token;
    total_size += size;
    memcpy(t + len - total_size, token, size);
    token = s;
    while (*s == ' ' && *s != '\0')
      s++;
    if (*s == '\n')
      break;
    token_end = s;
    size = token_end - token;
    total_size += size;
    memcpy(t + len - total_size, token, size);
  }
  t[len] = '\0';
  puts(t);
}


x86 assembly (clang, -O0):
<reverse_sub>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%edi
add    $0x1,%edi
call   1060 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,(%rax)
je     12d6 <reverse_sub+0x196>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x31(%rbp)
je     11b4 <reverse_sub+0x74>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11c4 <reverse_sub+0x84>
jmp    11d5 <reverse_sub+0x95>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    118f <reverse_sub+0x4f>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    11ea <reverse_sub+0xaa>
jmp    12d6 <reverse_sub+0x196>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
movslq -0xc(%rbp),%rax
add    %rax,%rdi
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
mov    -0x2c(%rbp),%edx
call   1050 <memcpy@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x32(%rbp)
jne    1259 <reverse_sub+0x119>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    1269 <reverse_sub+0x129>
jmp    127a <reverse_sub+0x13a>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1234 <reverse_sub+0xf4>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    128f <reverse_sub+0x14f>
jmp    12d6 <reverse_sub+0x196>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
movslq -0xc(%rbp),%rax
add    %rax,%rdi
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
mov    -0x2c(%rbp),%edx
call   1050 <memcpy@plt>
jmp    117a <reverse_sub+0x3a>
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   1030 <puts@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverse_sub>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r15
call   1040 <strlen@plt>
mov    %eax,%ebx
lea    0x1(%rbx),%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    (%r15),%al
movslq %ebx,%rcx
mov    %rcx,(%rsp)
test   %al,%al
je     1207 <reverse_sub+0xc7>
mov    %r14,%rbp
add    (%rsp),%rbp
xor    %r13d,%r13d
mov    %r13d,%ebx
mov    %r15,%r12
test   $0xdf,%al
je     11a1 <reverse_sub+0x61>
cs nopw 0x0(%rax,%rax,1)
movzbl 0x1(%r12),%eax
add    $0x1,%r12
add    $0x1,%ebx
test   $0xdf,%al
jne    1190 <reverse_sub+0x50>
mov    %r12d,%edx
sub    %r15d,%edx
add    %edx,%r13d
movslq %r13d,%rax
mov    %rbp,%rdi
sub    %rax,%rdi
mov    %r15,%rsi
call   1050 <memcpy@plt>
mov    %ebx,%r13d
xor    %ebx,%ebx
movzbl (%r12,%rbx,1),%eax
cmp    $0x20,%al
jne    11e0 <reverse_sub+0xa0>
add    $0x1,%rbx
add    $0x1,%r13d
jmp    11c0 <reverse_sub+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0xa,%al
je     1207 <reverse_sub+0xc7>
movslq %r13d,%rax
mov    %rbp,%rdi
sub    %rax,%rdi
mov    %r12,%rsi
mov    %ebx,%edx
call   1050 <memcpy@plt>
lea    (%r12,%rbx,1),%r15
mov    (%r12,%rbx,1),%al
test   %al,%al
jne    117c <reverse_sub+0x3c>
mov    (%rsp),%rax
movb   $0x0,(%r14,%rax,1)
mov    %r14,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>

LLVM IR (-O0):
define void @reverse_sub(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %2
%9 = load i8*, i8** %2
%10 = call i32 @strlen(i8* %9)
store i32 %10, i32* %3
%11 = load i32, i32* %3
%12 = add nsw i32 %11, 1
%13 = call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to i8*
store i8* %14, i8** %4
store i32 0, i32* %8
%15 = load i8*, i8** %2
store i8* %15, i8** %5
store i8* %15, i8** %6
br label %16
16: ; preds = %87, %1
%17 = load i8*, i8** %2
%18 = load i8, i8* %17
%19 = icmp ne i8 %18, 0
br i1 %19, label %20, label %109
20: ; preds = %16
%21 = load i8*, i8** %2
store i8* %21, i8** %5
br label %22
22: ; preds = %34, %20
%23 = load i8*, i8** %2
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = icmp ne i32 %25, 32
br i1 %26, label %27, label %32
27: ; preds = %22
%28 = load i8*, i8** %2
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = icmp ne i32 %30, 0
br label %32
32: ; preds = %27, %22
%33 = phi i1 [ false, %22 ], [ %31, %27 ]
br i1 %33, label %34, label %37
34: ; preds = %32
%35 = load i8*, i8** %2
%36 = getelementptr inbounds i8, i8* %35, i32 1
store i8* %36, i8** %2
br label %22
37: ; preds = %32
%38 = load i8*, i8** %2
%39 = load i8, i8* %38
%40 = sext i8 %39 to i32
%41 = icmp eq i32 %40, 10
br i1 %41, label %42, label %43
42: ; preds = %37
br label %109
43: ; preds = %37
%44 = load i8*, i8** %2
store i8* %44, i8** %6
%45 = load i8*, i8** %6
%46 = load i8*, i8** %5
%47 = ptrtoint i8* %45 to i64
%48 = ptrtoint i8* %46 to i64
%49 = sub i64 %47, %48
%50 = trunc i64 %49 to i32
store i32 %50, i32* %7
%51 = load i32, i32* %7
%52 = load i32, i32* %8
%53 = add nsw i32 %52, %51
store i32 %53, i32* %8
%54 = load i8*, i8** %4
%55 = load i32, i32* %3
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = load i32, i32* %8
%59 = sext i32 %58 to i64
%60 = sub i64 0, %59
%61 = getelementptr inbounds i8, i8* %57, i64 %60
%62 = load i8*, i8** %5
%63 = load i32, i32* %7
%64 = call i32 @memcpy(i8* %61, i8* %62, i32 %63)
%65 = load i8*, i8** %2
store i8* %65, i8** %5
br label %66
66: ; preds = %78, %43
%67 = load i8*, i8** %2
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = icmp eq i32 %69, 32
br i1 %70, label %71, label %76
71: ; preds = %66
%72 = load i8*, i8** %2
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp ne i32 %74, 0
br label %76
76: ; preds = %71, %66
%77 = phi i1 [ false, %66 ], [ %75, %71 ]
br i1 %77, label %78, label %81
78: ; preds = %76
%79 = load i8*, i8** %2
%80 = getelementptr inbounds i8, i8* %79, i32 1
store i8* %80, i8** %2
br label %66
81: ; preds = %76
%82 = load i8*, i8** %2
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = icmp eq i32 %84, 10
br i1 %85, label %86, label %87
86: ; preds = %81
br label %109
87: ; preds = %81
%88 = load i8*, i8** %2
store i8* %88, i8** %6
%89 = load i8*, i8** %6
%90 = load i8*, i8** %5
%91 = ptrtoint i8* %89 to i64
%92 = ptrtoint i8* %90 to i64
%93 = sub i64 %91, %92
%94 = trunc i64 %93 to i32
store i32 %94, i32* %7
%95 = load i32, i32* %7
%96 = load i32, i32* %8
%97 = add nsw i32 %96, %95
store i32 %97, i32* %8
%98 = load i8*, i8** %4
%99 = load i32, i32* %3
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = load i32, i32* %8
%103 = sext i32 %102 to i64
%104 = sub i64 0, %103
%105 = getelementptr inbounds i8, i8* %101, i64 %104
%106 = load i8*, i8** %5
%107 = load i32, i32* %7
%108 = call i32 @memcpy(i8* %105, i8* %106, i32 %107)
br label %16
109: ; preds = %86, %42, %16
%110 = load i8*, i8** %4
%111 = load i32, i32* %3
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, i64 %112
store i8 0, i8* %113
%114 = load i8*, i8** %4
%115 = call i32 @puts(i8* %114)
ret void
}

LLVM IR (-O2):
define void @reverse_sub(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = add nsw i32 %2, 1
%4 = tail call i64 @malloc(i32 %3)
%5 = inttoptr i64 %4 to i8*
%6 = load i8, i8* %0
%7 = icmp eq i8 %6, 0
%8 = sext i32 %2 to i64
br i1 %7, label %47, label %9
9: ; preds = %1
%10 = getelementptr inbounds i8, i8* %5, i64 %8
br label %11
11: ; preds = %9, %36
%12 = phi i8 [ %6, %9 ], [ %45, %36 ]
%13 = phi i32 [ 0, %9 ], [ %40, %36 ]
%14 = phi i8* [ %0, %9 ], [ %32, %36 ]
br label %15
15: ; preds = %11, %18
%16 = phi i8 [ %20, %18 ], [ %12, %11 ]
%17 = phi i8* [ %19, %18 ], [ %14, %11 ]
switch i8 %16, label %18 [
i8 0, label %21
i8 32, label %21
]
18: ; preds = %15
%19 = getelementptr inbounds i8, i8* %17, i64 1
%20 = load i8, i8* %19
br label %15
21: ; preds = %15, %15
%22 = ptrtoint i8* %17 to i64
%23 = ptrtoint i8* %14 to i64
%24 = sub i64 %22, %23
%25 = trunc i64 %24 to i32
%26 = add nsw i32 %13, %25
%27 = sext i32 %26 to i64
%28 = sub nsw i64 0, %27
%29 = getelementptr inbounds i8, i8* %10, i64 %28
%30 = tail call i32 @memcpy(i8* %29, i8* %14, i32 %25)
br label %31
31: ; preds = %34, %21
%32 = phi i8* [ %17, %21 ], [ %35, %34 ]
%33 = load i8, i8* %32
switch i8 %33, label %36 [
i8 32, label %34
i8 10, label %47
]
34: ; preds = %31
%35 = getelementptr inbounds i8, i8* %32, i64 1
br label %31
36: ; preds = %31
%37 = ptrtoint i8* %32 to i64
%38 = sub i64 %37, %22
%39 = trunc i64 %38 to i32
%40 = add nsw i32 %26, %39
%41 = sext i32 %40 to i64
%42 = sub nsw i64 0, %41
%43 = getelementptr inbounds i8, i8* %10, i64 %42
%44 = tail call i32 @memcpy(i8* %43, i8* %17, i32 %39)
%45 = load i8, i8* %32
%46 = icmp eq i8 %45, 0
br i1 %46, label %47, label %11
47: ; preds = %36, %31, %1
%48 = getelementptr inbounds i8, i8* %5, i64 %8
store i8 0, i8* %48
%49 = tail call i32 @puts(i8* dereferenceable(1) %5)
ret void
}