#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__ abs(char);
int strlen(char *);
char *checkfunny(char *s) {
  int i;
  static char *yes = "Funny";
  static char *no = "Not Funny";
  int len = strlen(s);
  char rev[1000];
  for (i = 0; i < len; i++) {
    rev[len - i - 1] = s[i];
  }
  rev[len] = '\0';
  int flag;
  for (i = 1; i <= len / 2; i++) {
    if (abs(s[i] - s[i - 1]) == abs(rev[i] - rev[i - 1])) {
      flag = 1;
    } else {
      flag = 0;
      break;
    }
  }
  if (flag) {
    return yes;
  } else {
    return no;
  }
}


x86 assembly (clang, -O0):
<checkfunny>:
push   %rbp
mov    %rsp,%rbp
sub    $0x410,%rsp
mov    %rdi,-0x10(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1179 <checkfunny+0x59>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0x400(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1142 <checkfunny+0x22>
movslq -0x18(%rbp),%rax
movb   $0x0,-0x400(%rbp,%rax,1)
movl   $0x1,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x408(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x408(%rbp),%eax
cmp    %ecx,%eax
jg     1249 <checkfunny+0x129>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
movsbl %al,%edi
call   1030 <abs@plt>
mov    %rax,-0x410(%rbp)
movslq -0x14(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl -0x400(%rbp,%rcx,1),%ecx
ff
sub    %ecx,%eax
movsbl %al,%edi
call   1030 <abs@plt>
mov    %rax,%rcx
mov    -0x410(%rbp),%rax
cmp    %rcx,%rax
jne    1227 <checkfunny+0x107>
movl   $0x1,-0x404(%rbp)
jmp    1236 <checkfunny+0x116>
movl   $0x0,-0x404(%rbp)
jmp    1249 <checkfunny+0x129>
jmp    123b <checkfunny+0x11b>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    118c <checkfunny+0x6c>
cmpl   $0x0,-0x404(%rbp)
je     1266 <checkfunny+0x146>
mov    0x2dd3(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    1271 <checkfunny+0x151>
mov    0x2dcb(%rip),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x410,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkfunny>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3e8,%rsp
mov    %rdi,%r12
call   1040 <strlen@plt>
mov    %eax,%r14d
test   %eax,%eax
jle    1150 <checkfunny+0x30>
mov    %r14d,%eax
cmp    $0x8,%r14d
jae    1163 <checkfunny+0x43>
xor    %ecx,%ecx
jmp    1287 <checkfunny+0x167>
movslq %r14d,%rax
movb   $0x0,(%rsp,%rax,1)
lea    0xea6(%rip),%r15
jmp    1348 <checkfunny+0x228>
lea    -0x1(%rax),%rsi
lea    -0x1(%r14),%edx
mov    %edx,%edi
sub    %esi,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jg     1287 <checkfunny+0x167>
shr    $0x20,%rsi
jne    1287 <checkfunny+0x167>
cmp    $0x20,%r14d
jae    1190 <checkfunny+0x70>
xor    %ecx,%ecx
jmp    1235 <checkfunny+0x115>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%r12,%rsi,1),%xmm1
movdqu 0x10(%r12,%rsi,1),%xmm2
movslq %edx,%rdx
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 %xmm1,-0xf(%rsp,%rdx,1)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,-0x1f(%rsp,%rdx,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    11a0 <checkfunny+0x80>
cmp    %rax,%rcx
je     12e4 <checkfunny+0x1c4>
test   $0x18,%al
je     1287 <checkfunny+0x167>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %r14d,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%r12,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
movslq %esi,%rsi
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,-0x7(%rsp,%rsi,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    1250 <checkfunny+0x130>
cmp    %rax,%rcx
je     12e4 <checkfunny+0x1c4>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
je     12a6 <checkfunny+0x186>
mov    (%r12,%rcx,1),%bl
mov    %ecx,%esi
not    %esi
add    %r14d,%esi
movslq %esi,%rsi
mov    %bl,(%rsp,%rsi,1)
or     $0x1,%rcx
add    %rax,%rdx
je     12e4 <checkfunny+0x1c4>
sub    %rcx,%rax
mov    %ecx,%edx
not    %edx
add    %r14d,%edx
add    %r12,%rcx
add    $0x1,%rcx
xor    %esi,%esi
xchg   %ax,%ax
movzbl -0x1(%rcx,%rsi,1),%ebx
movslq %edx,%rdx
mov    %bl,(%rsp,%rdx,1)
movzbl (%rcx,%rsi,1),%ebx
lea    -0x1(%rdx),%edi
movslq %edi,%rdi
mov    %bl,(%rsp,%rdi,1)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rax
jne    12c0 <checkfunny+0x1a0>
movslq %r14d,%rax
movb   $0x0,(%rsp,%rax,1)
lea    0xd12(%rip),%r15
cmp    $0x2,%r14d
jl     1348 <checkfunny+0x228>
shr    %r14d
xor    %ebx,%ebx
lea    0xcfc(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x1(%r12,%rbx,1),%eax
sub    (%r12,%rbx,1),%al
movsbl %al,%edi
call   1030 <abs@plt>
mov    %rax,%r13
movzbl 0x1(%rsp,%rbx,1),%eax
sub    (%rsp,%rbx,1),%al
movsbl %al,%edi
call   1030 <abs@plt>
cmp    %rax,%r13
jne    1345 <checkfunny+0x225>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1310 <checkfunny+0x1f0>
jmp    1348 <checkfunny+0x228>
mov    %rbp,%r15
mov    %r15,%rax
add    $0x3e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@checkfunny.yes = internal global i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i32 0, i32 0)
@.str = [6 x i8] c"Funny\00"
@checkfunny.no = internal global i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i32 0, i32 0)
@.str.1 = [10 x i8] c"Not Funny\00"
define i8* @checkfunny(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca [1000 x i8]
%7 = alloca i32
store i8* %0, i8** %3
%8 = load i8*, i8** %3
%9 = call i32 @strlen(i8* %8)
store i32 %9, i32* %5
store i32 0, i32* %4
br label %10
10: ; preds = %26, %1
%11 = load i32, i32* %4
%12 = load i32, i32* %5
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %29
14: ; preds = %10
%15 = load i8*, i8** %3
%16 = load i32, i32* %4
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = load i32, i32* %5
%21 = load i32, i32* %4
%22 = sub nsw i32 %20, %21
%23 = sub nsw i32 %22, 1
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %24
store i8 %19, i8* %25
br label %26
26: ; preds = %14
%27 = load i32, i32* %4
%28 = add nsw i32 %27, 1
store i32 %28, i32* %4
br label %10
29: ; preds = %10
%30 = load i32, i32* %5
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %31
store i8 0, i8* %32
store i32 1, i32* %4
br label %33
33: ; preds = %73, %29
%34 = load i32, i32* %4
%35 = load i32, i32* %5
%36 = sdiv i32 %35, 2
%37 = icmp sle i32 %34, %36
br i1 %37, label %38, label %76
38: ; preds = %33
%39 = load i8*, i8** %3
%40 = load i32, i32* %4
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = load i8*, i8** %3
%46 = load i32, i32* %4
%47 = sub nsw i32 %46, 1
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i8, i8* %45, i64 %48
%50 = load i8, i8* %49
%51 = sext i8 %50 to i32
%52 = sub nsw i32 %44, %51
%53 = trunc i32 %52 to i8
%54 = call i64 @abs(i8 signext %53)
%55 = load i32, i32* %4
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %56
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = load i32, i32* %4
%61 = sub nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [1000 x i8], [1000 x i8]* %6, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = sub nsw i32 %59, %65
%67 = trunc i32 %66 to i8
%68 = call i64 @abs(i8 signext %67)
%69 = icmp eq i64 %54, %68
br i1 %69, label %70, label %71
70: ; preds = %38
store i32 1, i32* %7
br label %72
71: ; preds = %38
store i32 0, i32* %7
br label %76
72: ; preds = %70
br label %73
73: ; preds = %72
%74 = load i32, i32* %4
%75 = add nsw i32 %74, 1
store i32 %75, i32* %4
br label %33
76: ; preds = %71, %33
%77 = load i32, i32* %7
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %81
79: ; preds = %76
%80 = load i8*, i8** @checkfunny.yes
store i8* %80, i8** %2
br label %83
81: ; preds = %76
%82 = load i8*, i8** @checkfunny.no
store i8* %82, i8** %2
br label %83
83: ; preds = %81, %79
%84 = load i8*, i8** %2
ret i8* %84
}

LLVM IR (-O2):
@.str = [6 x i8] c"Funny\00"
@.str.1 = [10 x i8] c"Not Funny\00"
define i8* @checkfunny(i8* %0) {
%2 = alloca [1000 x i8]
%3 = tail call i32 @strlen(i8* %0)
%4 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 0
%5 = icmp sgt i32 %3, 0
br i1 %5, label %9, label %6
6: ; preds = %1
%7 = sext i32 %3 to i64
%8 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %7
store i8 0, i8* %8
br label %134
9: ; preds = %1
%10 = zext i32 %3 to i64
%11 = icmp ult i32 %3, 8
br i1 %11, label %70, label %12
12: ; preds = %9
%13 = add nsw i64 %10, -1
%14 = add i32 %3, -1
%15 = trunc i64 %13 to i32
%16 = sub i32 %14, %15
%17 = icmp sgt i32 %16, %14
%18 = icmp ugt i64 %13, 4294967295
%19 = or i1 %17, %18
br i1 %19, label %70, label %20
20: ; preds = %12
%21 = icmp ult i32 %3, 32
br i1 %21, label %50, label %22
22: ; preds = %20
%23 = and i64 %10, 4294967264
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %43, %24 ]
%26 = trunc i64 %25 to i32
%27 = getelementptr inbounds i8, i8* %0, i64 %25
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = getelementptr inbounds i8, i8* %27, i64 16
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = xor i32 %26, -1
%34 = add i32 %3, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %35
%37 = 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>
%38 = getelementptr inbounds i8, i8* %36, i64 -15
%39 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %37, <16 x i8>* %39
%40 = shufflevector <16 x i8> %32, <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 -31
%42 = bitcast i8* %41 to <16 x i8>*
store <16 x i8> %40, <16 x i8>* %42
%43 = add nuw i64 %25, 32
%44 = icmp eq i64 %43, %23
br i1 %44, label %45, label %24
45: ; preds = %24
%46 = icmp eq i64 %23, %10
br i1 %46, label %107, label %47
47: ; preds = %45
%48 = and i64 %10, 24
%49 = icmp eq i64 %48, 0
br i1 %49, label %70, label %50
50: ; preds = %20, %47
%51 = phi i64 [ %23, %47 ], [ 0, %20 ]
%52 = and i64 %10, 4294967288
br label %53
53: ; preds = %53, %50
%54 = phi i64 [ %51, %50 ], [ %66, %53 ]
%55 = trunc i64 %54 to i32
%56 = getelementptr inbounds i8, i8* %0, i64 %54
%57 = bitcast i8* %56 to <8 x i8>*
%58 = load <8 x i8>, <8 x i8>* %57
%59 = xor i32 %55, -1
%60 = add i32 %3, %59
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %61
%63 = 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>
%64 = getelementptr inbounds i8, i8* %62, i64 -7
%65 = bitcast i8* %64 to <8 x i8>*
store <8 x i8> %63, <8 x i8>* %65
%66 = add nuw i64 %54, 8
%67 = icmp eq i64 %66, %52
br i1 %67, label %68, label %53
68: ; preds = %53
%69 = icmp eq i64 %52, %10
br i1 %69, label %107, label %70
70: ; preds = %12, %9, %47, %68
%71 = phi i64 [ 0, %9 ], [ 0, %12 ], [ %23, %47 ], [ %52, %68 ]
%72 = xor i64 %71, -1
%73 = and i64 %10, 1
%74 = icmp eq i64 %73, 0
br i1 %74, label %84, label %75
75: ; preds = %70
%76 = getelementptr inbounds i8, i8* %0, i64 %71
%77 = load i8, i8* %76
%78 = trunc i64 %71 to i32
%79 = xor i32 %78, -1
%80 = add i32 %3, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %81
store i8 %77, i8* %82
%83 = or i64 %71, 1
br label %84
84: ; preds = %75, %70
%85 = phi i64 [ %71, %70 ], [ %83, %75 ]
%86 = sub nsw i64 0, %10
%87 = icmp eq i64 %72, %86
br i1 %87, label %107, label %88
88: ; preds = %84, %88
%89 = phi i64 [ %105, %88 ], [ %85, %84 ]
%90 = getelementptr inbounds i8, i8* %0, i64 %89
%91 = load i8, i8* %90
%92 = trunc i64 %89 to i32
%93 = xor i32 %92, -1
%94 = add i32 %3, %93
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %95
store i8 %91, i8* %96
%97 = add nuw nsw i64 %89, 1
%98 = getelementptr inbounds i8, i8* %0, i64 %97
%99 = load i8, i8* %98
%100 = trunc i64 %97 to i32
%101 = xor i32 %100, -1
%102 = add i32 %3, %101
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %103
store i8 %99, i8* %104
%105 = add nuw nsw i64 %89, 2
%106 = icmp eq i64 %105, %10
br i1 %106, label %107, label %88
107: ; preds = %84, %88, %68, %45
%108 = sext i32 %3 to i64
%109 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %108
store i8 0, i8* %109
%110 = icmp slt i32 %3, 2
br i1 %110, label %134, label %111
111: ; preds = %107
%112 = lshr i32 %3, 1
%113 = add nuw nsw i32 %112, 1
%114 = zext i32 %113 to i64
br label %118
115: ; preds = %118
%116 = add nuw nsw i64 %119, 1
%117 = icmp eq i64 %116, %114
br i1 %117, label %134, label %118
118: ; preds = %111, %115
%119 = phi i64 [ 1, %111 ], [ %116, %115 ]
%120 = getelementptr inbounds i8, i8* %0, i64 %119
%121 = load i8, i8* %120
%122 = add nsw i64 %119, -1
%123 = getelementptr inbounds i8, i8* %0, i64 %122
%124 = load i8, i8* %123
%125 = sub i8 %121, %124
%126 = tail call i64 @abs(i8 signext %125)
%127 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %119
%128 = load i8, i8* %127
%129 = getelementptr inbounds [1000 x i8], [1000 x i8]* %2, i64 0, i64 %122
%130 = load i8, i8* %129
%131 = sub i8 %128, %130
%132 = tail call i64 @abs(i8 signext %131)
%133 = icmp eq i64 %126, %132
br i1 %133, label %115, label %134
134: ; preds = %115, %118, %6, %107
%135 = phi i8* [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), %107 ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), %6 ], [ getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), %118 ], [ getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), %115 ]
ret i8* %135
}