#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 BUFSIZ;
int /*<<< orphan*/ gets(char *);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ puts(char *);
size_t strlen(char *);
int main() {
  int t = 0, i = 0, h = 0, j;
  char cumle[BUFSIZ], cumle2[BUFSIZ];
  printf("Cumle giriniz\n");
  gets(cumle);
  for (i; i <= strlen(cumle); i++) {
    if (cumle[i] == ' ' || cumle[i] == '\0') {
      j = j - 1;
      for (j; j >= t; j--) {
        cumle2[h] = cumle[j];
        h++;
      }
      h++;
      cumle2[h - 1] = ' ';
      t = i + 1;
    }
  }
  cumle2[strlen(cumle)] = '\0';
  puts(cumle2);
  printf("\n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    0x2e75(%rip),%rax
mov    (%rax),%ecx
mov    %rsp,%rdx
mov    %rdx,-0x20(%rbp)
mov    %rcx,%rsi
add    $0xf,%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x28(%rbp)
mov    (%rax),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
lea    0xe4b(%rip),%rdi
call   1050 <printf@plt>
mov    -0x38(%rbp),%rdi
call   1060 <gets@plt>
mov    -0x38(%rbp),%rdi
movslq -0xc(%rbp),%rax
mov    %rax,-0x48(%rbp)
call   1040 <strlen@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
cmp    %rcx,%rax
ja     1286 <main+0x146>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     120e <main+0xce>
mov    -0x38(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1273 <main+0x133>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jl     1250 <main+0x110>
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
movslq -0x14(%rbp),%rdx
mov    (%rcx,%rdx,1),%dl
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1217 <main+0xd7>
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x10(%rbp)
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1278 <main+0x138>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11c3 <main+0x83>
mov    -0x38(%rbp),%rdi
call   1040 <strlen@plt>
mov    -0x40(%rbp),%rdi
movb   $0x0,(%rdi,%rax,1)
call   1030 <puts@plt>
lea    0xd6a(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    0x2e88(%rip),%rax
mov    (%rax),%eax
mov    %rsp,%r15
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%r14
sub    %rax,%r14
mov    %r14,%rsp
lea    0xe85(%rip),%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
call   1060 <gets@plt>
mov    %r15,%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    %rax,-0x30(%rbp)
mov    %rax,%r10
add    $0x1,%r10
lea    -0x10(%r15),%rax
mov    %rax,-0x38(%rbp)
lea    0x10(%r14),%r9
xor    %r11d,%r11d
pxor   %xmm0,%xmm0
xor    %eax,%eax
xor    %ebx,%ebx
jmp    11de <main+0x9e>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%edx
movslq %ebx,%rax
add    $0x1,%ebx
movb   $0x20,(%r14,%rax,1)
add    $0x1,%r11
mov    %r11d,%eax
cmp    %r10,%r11
je     12ee <main+0x1ae>
testb  $0xdf,(%r15,%r11,1)
jne    1210 <main+0xd0>
cmp    %eax,%edx
jle    11c0 <main+0x80>
movslq %edx,%rdi
lea    -0x1(%rdi),%rdx
movslq %eax,%rcx
movslq %ebx,%rsi
mov    %rdi,%r12
sub    %rcx,%r12
cmp    $0x20,%r12
jae    121e <main+0xde>
mov    %rsi,%rbx
jmp    12c6 <main+0x186>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
cmp    %r10,%r11
jne    11de <main+0x9e>
jmp    12ee <main+0x1ae>
mov    %r12,%r8
and    $0xffffffffffffffe0,%r8
lea    (%r8,%rsi,1),%rbx
sub    %r8,%rdx
mov    %r8,%r13
neg    %r13
add    -0x38(%rbp),%rdi
add    %r9,%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rax,1),%xmm1
movdqu (%rdi,%rax,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,-0x10(%rsi)
movdqu %xmm1,(%rsi)
add    $0xffffffffffffffe0,%rax
add    $0x20,%rsi
cmp    %rax,%r13
jne    1240 <main+0x100>
cmp    %r8,%r12
je     11c3 <main+0x83>
mov    %rdx,%rax
nopl   0x0(%rax)
movzbl (%r15,%rax,1),%edx
mov    %dl,(%r14,%rbx,1)
add    $0x1,%rbx
lea    -0x1(%rax),%rdx
cmp    %rcx,%rax
mov    %rdx,%rax
jg     12d0 <main+0x190>
jmp    11c3 <main+0x83>
mov    -0x30(%rbp),%rax
movb   $0x0,(%r14,%rax,1)
mov    %r14,%rdi
call   1040 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@BUFSIZ = global i32 0
@str = [14 x i8] c"Cumle giriniz\00"
define i32 @main() {
%1 = load i32, i32* @BUFSIZ
%2 = zext i32 %1 to i64
%3 = alloca i8, i64 %2
%4 = alloca i8, i64 %2
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str, i64 0, i64 0))
%6 = call i32 @gets(i8* %3)
%7 = call i64 @strlen(i8* %3)
%8 = add nuw i64 %7, 1
br label %9
9: ; preds = %0, %79
%10 = phi i64 [ 0, %0 ], [ %80, %79 ]
%11 = phi i32 [ 0, %0 ], [ %83, %79 ]
%12 = phi i32 [ undef, %0 ], [ %82, %79 ]
%13 = phi i32 [ 0, %0 ], [ %81, %79 ]
%14 = getelementptr inbounds i8, i8* %3, i64 %10
%15 = load i8, i8* %14
switch i8 %15, label %16 [
i8 32, label %18
i8 0, label %18
]
16: ; preds = %9
%17 = add nuw nsw i64 %10, 1
br label %79
18: ; preds = %9, %9
%19 = add nsw i32 %12, -1
%20 = icmp sgt i32 %12, %11
br i1 %20, label %21, label %71
21: ; preds = %18
%22 = sext i32 %12 to i64
%23 = add nsw i64 %22, -1
%24 = sext i32 %11 to i64
%25 = sext i32 %13 to i64
%26 = sub nsw i64 %22, %24
%27 = icmp ult i64 %26, 32
br i1 %27, label %54, label %28
28: ; preds = %21
%29 = and i64 %26, -32
%30 = add nsw i64 %29, %25
%31 = sub nsw i64 %23, %29
br label %32
32: ; preds = %32, %28
%33 = phi i64 [ 0, %28 ], [ %50, %32 ]
%34 = add i64 %33, %25
%35 = sub i64 %23, %33
%36 = getelementptr inbounds i8, i8* %3, i64 %35
%37 = getelementptr inbounds i8, i8* %36, i64 -15
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = shufflevector <16 x i8> %39, <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>
%41 = getelementptr inbounds i8, i8* %36, i64 -16
%42 = getelementptr inbounds i8, i8* %41, i64 -15
%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* %4, i64 %34
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %40, <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 %33, 32
%51 = icmp eq i64 %50, %29
br i1 %51, label %52, label %32
52: ; preds = %32
%53 = icmp eq i64 %26, %29
br i1 %53, label %66, label %54
54: ; preds = %21, %52
%55 = phi i64 [ %25, %21 ], [ %30, %52 ]
%56 = phi i64 [ %23, %21 ], [ %31, %52 ]
br label %57
57: ; preds = %54, %57
%58 = phi i64 [ %63, %57 ], [ %55, %54 ]
%59 = phi i64 [ %64, %57 ], [ %56, %54 ]
%60 = getelementptr inbounds i8, i8* %3, i64 %59
%61 = load i8, i8* %60
%62 = getelementptr inbounds i8, i8* %4, i64 %58
store i8 %61, i8* %62
%63 = add nsw i64 %58, 1
%64 = add nsw i64 %59, -1
%65 = icmp sgt i64 %59, %24
br i1 %65, label %57, label %66
66: ; preds = %57, %52
%67 = phi i64 [ %30, %52 ], [ %63, %57 ]
%68 = phi i64 [ %31, %52 ], [ %64, %57 ]
%69 = trunc i64 %67 to i32
%70 = trunc i64 %68 to i32
br label %71
71: ; preds = %66, %18
%72 = phi i32 [ %13, %18 ], [ %69, %66 ]
%73 = phi i32 [ %19, %18 ], [ %70, %66 ]
%74 = add nsw i32 %72, 1
%75 = sext i32 %72 to i64
%76 = getelementptr inbounds i8, i8* %4, i64 %75
store i8 32, i8* %76
%77 = add nuw nsw i64 %10, 1
%78 = trunc i64 %77 to i32
br label %79
79: ; preds = %16, %71
%80 = phi i64 [ %17, %16 ], [ %77, %71 ]
%81 = phi i32 [ %13, %16 ], [ %74, %71 ]
%82 = phi i32 [ %12, %16 ], [ %73, %71 ]
%83 = phi i32 [ %11, %16 ], [ %78, %71 ]
%84 = icmp eq i64 %80, %8
br i1 %84, label %85, label %9
85: ; preds = %79
%86 = getelementptr inbounds i8, i8* %4, i64 %7
store i8 0, i8* %86
%87 = call i32 @puts(i8* %4)
%88 = call i32 @putchar(i32 10)
ret i32 0
}