int main() {
  char *s, *r;
  int n;
  scanf("%d", &n);
  s = (char *)malloc((n + 1) * sizeof(char));
  r = (char *)malloc((n + 1) * sizeof(char));
  scanf("%s", s);
  int i;
  for (i = 0; i < n; i++) {
    *(r + i) = *(s + n - i - 1);
  }
  int x;
  for (i = 1; i++; i < n) {
    if (mod(*(s + i), *(s + i - 1)) == mod(*(r + i), *(r + i - 1))) {
      x = 1;
      continue;
    } else {
      x = 0;
      break;
    }
  }
  if (x == 1)
    printf("Good String");
  else if (x == 0)
    printf("Not Good String");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeaa(%rip),%rdi
lea    -0x1c(%rbp),%rsi
mov    $0x0,%al
call   1060 <scanf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rsi
lea    0xe6b(%rip),%rdi
mov    $0x0,%al
call   1060 <scanf@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11e3 <main+0xa3>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    -0x1(%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11a6 <main+0x66>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
je     126b <main+0x12b>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl -0x1(%rax,%rcx,1),%esi
mov    $0x0,%al
call   1030 <mod@plt>
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl -0x1(%rax,%rcx,1),%esi
mov    $0x0,%al
call   1030 <mod@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%eax
cmp    %ecx,%eax
jne    125a <main+0x11a>
movl   $0x1,-0x24(%rbp)
jmp    1266 <main+0x126>
movl   $0x0,-0x24(%rbp)
jmp    126b <main+0x12b>
jmp    11ea <main+0xaa>
cmpl   $0x1,-0x24(%rbp)
jne    1288 <main+0x148>
lea    0xd8e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12a5 <main+0x165>
cmpl   $0x0,-0x24(%rbp)
jne    12a0 <main+0x160>
lea    0xd6d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12a5 <main+0x165>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
lea    0xeb2(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
movslq 0x4(%rsp),%rbx
add    $0x1,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
lea    0xe83(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    12d2 <main+0x192>
cmp    $0x8,%eax
jae    11a2 <main+0x62>
xor    %ecx,%ecx
jmp    12b3 <main+0x173>
cmp    $0x20,%eax
jae    11ae <main+0x6e>
xor    %ecx,%ecx
jmp    1258 <main+0x118>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    (%rax,%r14,1),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%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,(%r15,%rsi,1)
movdqu %xmm1,0x10(%r15,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdx
cmp    %rsi,%rcx
jne    11d0 <main+0x90>
cmp    %rax,%rcx
je     12d2 <main+0x192>
test   $0x18,%al
je     12b3 <main+0x173>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rax,%rsi
sub    %rdx,%rsi
add    %r14,%rsi
add    $0xfffffffffffffff8,%rsi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r15,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    1280 <main+0x140>
cmp    %rax,%rcx
je     12d2 <main+0x192>
mov    %r15,%rdx
add    %rcx,%rdx
sub    %rcx,%rax
nopl   0x0(%rax)
movzbl -0x1(%r14,%rax,1),%ecx
mov    %cl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    12c0 <main+0x180>
mov    $0x2,%ebx
nopw   0x0(%rax,%rax,1)
movsbl (%r14,%rbx,1),%edi
movsbl -0x1(%r14,%rbx,1),%esi
xor    %eax,%eax
call   1030 <mod@plt>
mov    %eax,%ebp
movsbl (%r15,%rbx,1),%edi
movsbl -0x1(%r15,%rbx,1),%esi
xor    %eax,%eax
call   1030 <mod@plt>
add    $0x1,%rbx
cmp    %eax,%ebp
je     12e0 <main+0x1a0>
lea    0xcf1(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [12 x i8] c"Good String\00"
@.str.3 = [16 x i8] c"Not Good String\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 0, i32* %1
%7 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %4)
%8 = load i32, i32* %4
%9 = add nsw i32 %8, 1
%10 = sext i32 %9 to i64
%11 = mul i64 %10, 1
%12 = call i8* @malloc(i64 %11)
store i8* %12, i8** %2
%13 = load i32, i32* %4
%14 = add nsw i32 %13, 1
%15 = sext i32 %14 to i64
%16 = mul i64 %15, 1
%17 = call i8* @malloc(i64 %16)
store i8* %17, i8** %3
%18 = load i8*, i8** %2
%19 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %18)
store i32 0, i32* %5
br label %20
20: ; preds = %39, %0
%21 = load i32, i32* %5
%22 = load i32, i32* %4
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %42
24: ; preds = %20
%25 = load i8*, i8** %2
%26 = load i32, i32* %4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
%29 = load i32, i32* %5
%30 = sext i32 %29 to i64
%31 = sub i64 0, %30
%32 = getelementptr inbounds i8, i8* %28, i64 %31
%33 = getelementptr inbounds i8, i8* %32, i64 -1
%34 = load i8, i8* %33
%35 = load i8*, i8** %3
%36 = load i32, i32* %5
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
store i8 %34, i8* %38
br label %39
39: ; preds = %24
%40 = load i32, i32* %5
%41 = add nsw i32 %40, 1
store i32 %41, i32* %5
br label %20
42: ; preds = %20
store i32 1, i32* %5
br label %43
43: ; preds = %79, %42
%44 = load i32, i32* %5
%45 = add nsw i32 %44, 1
store i32 %45, i32* %5
%46 = icmp ne i32 %44, 0
br i1 %46, label %47, label %84
47: ; preds = %43
%48 = load i8*, i8** %2
%49 = load i32, i32* %5
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = load i8*, i8** %2
%55 = load i32, i32* %5
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
%58 = getelementptr inbounds i8, i8* %57, i64 -1
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %53, i32 %60)
%62 = load i8*, i8** %3
%63 = load i32, i32* %5
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %62, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = load i8*, i8** %3
%69 = load i32, i32* %5
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = getelementptr inbounds i8, i8* %71, i64 -1
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %67, i32 %74)
%76 = icmp eq i32 %61, %75
br i1 %76, label %77, label %78
77: ; preds = %47
store i32 1, i32* %6
br label %79
78: ; preds = %47
store i32 0, i32* %6
br label %84
79: ; preds = %77
%80 = load i32, i32* %5
%81 = load i32, i32* %4
%82 = icmp slt i32 %80, %81
%83 = zext i1 %82 to i32
br label %43
84: ; preds = %78, %43
%85 = load i32, i32* %6
%86 = icmp eq i32 %85, 1
br i1 %86, label %87, label %89
87: ; preds = %84
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
br label %95
89: ; preds = %84
%90 = load i32, i32* %6
%91 = icmp eq i32 %90, 0
br i1 %91, label %92, label %94
92: ; preds = %89
%93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0))
br label %94
94: ; preds = %92, %89
br label %95
95: ; preds = %94, %87
ret i32 0
}

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%s\00"
@.str.3 = [16 x i8] c"Not Good String\00"
define i32 @main() {
%1 = alloca i32
%2 = bitcast i32* %1 to i8*
%3 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%4 = load i32, i32* %1
%5 = add nsw i32 %4, 1
%6 = sext i32 %5 to i64
%7 = call i8* @malloc(i64 %6)
%8 = call i8* @malloc(i64 %6)
%9 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %7)
%10 = load i32, i32* %1
%11 = icmp sgt i32 %10, 0
br i1 %11, label %12, label %73
12: ; preds = %0
%13 = zext i32 %10 to i64
%14 = getelementptr inbounds i8, i8* %7, i64 %13
%15 = zext i32 %10 to i64
%16 = getelementptr inbounds i8, i8* %14, i64 -1
%17 = icmp ult i32 %10, 8
br i1 %17, label %63, label %18
18: ; preds = %12
%19 = icmp ult i32 %10, 32
br i1 %19, label %46, label %20
20: ; preds = %18
%21 = and i64 %15, 4294967264
br label %22
22: ; preds = %22, %20
%23 = phi i64 [ 0, %20 ], [ %39, %22 ]
%24 = sub nsw i64 0, %23
%25 = getelementptr inbounds i8, i8* %16, i64 %24
%26 = getelementptr inbounds i8, i8* %25, i64 -15
%27 = bitcast i8* %26 to <16 x i8>*
%28 = load <16 x i8>, <16 x i8>* %27
%29 = shufflevector <16 x i8> %28, <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>
%30 = getelementptr inbounds i8, i8* %25, i64 -16
%31 = getelementptr inbounds i8, i8* %30, i64 -15
%32 = bitcast i8* %31 to <16 x i8>*
%33 = load <16 x i8>, <16 x i8>* %32
%34 = shufflevector <16 x i8> %33, <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>
%35 = getelementptr inbounds i8, i8* %8, i64 %23
%36 = bitcast i8* %35 to <16 x i8>*
store <16 x i8> %29, <16 x i8>* %36
%37 = getelementptr inbounds i8, i8* %35, i64 16
%38 = bitcast i8* %37 to <16 x i8>*
store <16 x i8> %34, <16 x i8>* %38
%39 = add nuw i64 %23, 32
%40 = icmp eq i64 %39, %21
br i1 %40, label %41, label %22
41: ; preds = %22
%42 = icmp eq i64 %21, %15
br i1 %42, label %73, label %43
43: ; preds = %41
%44 = and i64 %15, 24
%45 = icmp eq i64 %44, 0
br i1 %45, label %63, label %46
46: ; preds = %18, %43
%47 = phi i64 [ %21, %43 ], [ 0, %18 ]
%48 = and i64 %15, 4294967288
%49 = getelementptr inbounds i8, i8* %16, i64 -7
br label %50
50: ; preds = %50, %46
%51 = phi i64 [ %47, %46 ], [ %59, %50 ]
%52 = sub nsw 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 i8, i8* %8, 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, %48
br i1 %60, label %61, label %50
61: ; preds = %50
%62 = icmp eq i64 %48, %15
br i1 %62, label %73, label %63
63: ; preds = %12, %43, %61
%64 = phi i64 [ 0, %12 ], [ %21, %43 ], [ %48, %61 ]
br label %65
65: ; preds = %63, %65
%66 = phi i64 [ %71, %65 ], [ %64, %63 ]
%67 = sub nsw i64 0, %66
%68 = getelementptr inbounds i8, i8* %16, i64 %67
%69 = load i8, i8* %68
%70 = getelementptr inbounds i8, i8* %8, i64 %66
store i8 %69, i8* %70
%71 = add nuw nsw i64 %66, 1
%72 = icmp eq i64 %71, %15
br i1 %72, label %73, label %65
73: ; preds = %65, %41, %61, %0
br label %74
74: ; preds = %73, %74
%75 = phi i64 [ %76, %74 ], [ 1, %73 ]
%76 = add nuw nsw i64 %75, 1
%77 = getelementptr inbounds i8, i8* %7, i64 %76
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = getelementptr inbounds i8, i8* %7, i64 %75
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %79, i32 %82)
%84 = getelementptr inbounds i8, i8* %8, i64 %76
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = getelementptr inbounds i8, i8* %8, i64 %75
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %86, i32 %89)
%91 = icmp eq i32 %83, %90
br i1 %91, label %74, label %92
92: ; preds = %74
%93 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0))
ret i32 0
}