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 < n; i++) {
    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
cmp    -0x1c(%rbp),%eax
jge    126c <main+0x12c>
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    1252 <main+0x112>
movl   $0x1,-0x24(%rbp)
jmp    125e <main+0x11e>
movl   $0x0,-0x24(%rbp)
jmp    126c <main+0x12c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ea <main+0xaa>
cmpl   $0x1,-0x24(%rbp)
jne    1289 <main+0x149>
lea    0xd8d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12a6 <main+0x166>
cmpl   $0x0,-0x24(%rbp)
jne    12a1 <main+0x161>
lea    0xd6c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    12a6 <main+0x166>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xeae(%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,%r15
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r12
lea    0xe7f(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <scanf@plt>
mov    0x4(%rsp),%eax
lea    0xe71(%rip),%r14
test   %eax,%eax
jle    132d <main+0x1ed>
cmp    $0x8,%eax
jae    11ad <main+0x6d>
xor    %ecx,%ecx
jmp    12b3 <main+0x173>
cmp    $0x20,%eax
jae    11b9 <main+0x79>
xor    %ecx,%ecx
jmp    1258 <main+0x118>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    (%rax,%r15,1),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
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,(%r12,%rsi,1)
movdqu %xmm1,0x10(%r12,%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    %r15,%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,(%r12,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    1280 <main+0x140>
cmp    %rax,%rcx
je     12d2 <main+0x192>
mov    %r12,%rdx
add    %rcx,%rdx
mov    %rax,%rsi
sub    %rcx,%rsi
nop
movzbl -0x1(%r15,%rsi,1),%ecx
mov    %cl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    12c0 <main+0x180>
cmp    $0x2,%eax
jl     132d <main+0x1ed>
mov    $0x1,%ebx
lea    0xd23(%rip),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl (%r15,%rbx,1),%edi
movsbl -0x1(%r15,%rbx,1),%esi
xor    %eax,%eax
call   1030 <mod@plt>
mov    %eax,%ebp
movsbl (%r12,%rbx,1),%edi
movsbl -0x1(%r12,%rbx,1),%esi
xor    %eax,%eax
call   1030 <mod@plt>
cmp    %eax,%ebp
jne    132a <main+0x1ea>
add    $0x1,%rbx
movslq 0x4(%rsp),%rax
cmp    %rax,%rbx
jl     12f0 <main+0x1b0>
jmp    132d <main+0x1ed>
mov    %r13,%r14
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
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 = load i32, i32* %4
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %82
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 %82
79: ; preds = %77
%80 = load i32, i32* %5
%81 = add nsw i32 %80, 1
store i32 %81, i32* %5
br label %43
82: ; preds = %78, %43
%83 = load i32, i32* %6
%84 = icmp eq i32 %83, 1
br i1 %84, label %85, label %87
85: ; preds = %82
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
br label %93
87: ; preds = %82
%88 = load i32, i32* %6
%89 = icmp eq i32 %88, 0
br i1 %89, label %90, label %92
90: ; preds = %87
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0))
br label %92
92: ; preds = %90, %87
br label %93
93: ; preds = %92, %85
ret i32 0
}

LLVM IR (-O2):
@.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 = 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 %97
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 %65, 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 %65, label %63
63: ; preds = %12, %43, %61
%64 = phi i64 [ 0, %12 ], [ %21, %43 ], [ %48, %61 ]
br label %67
65: ; preds = %67, %61, %41
%66 = icmp sgt i32 %10, 1
br i1 %66, label %79, label %97
67: ; preds = %63, %67
%68 = phi i64 [ %73, %67 ], [ %64, %63 ]
%69 = sub nsw i64 0, %68
%70 = getelementptr inbounds i8, i8* %16, i64 %69
%71 = load i8, i8* %70
%72 = getelementptr inbounds i8, i8* %8, i64 %68
store i8 %71, i8* %72
%73 = add nuw nsw i64 %68, 1
%74 = icmp eq i64 %73, %15
br i1 %74, label %65, label %67
75: ; preds = %79
%76 = load i32, i32* %1
%77 = sext i32 %76 to i64
%78 = icmp slt i64 %96, %77
br i1 %78, label %79, label %97
79: ; preds = %65, %75
%80 = phi i64 [ %96, %75 ], [ 1, %65 ]
%81 = getelementptr inbounds i8, i8* %7, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = getelementptr inbounds i8, i8* %81, i64 -1
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %83, i32 %86)
%88 = getelementptr inbounds i8, i8* %8, i64 %80
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = getelementptr inbounds i8, i8* %88, i64 -1
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = call i32 (i32, i32, ...) bitcast (i32 (...)* @mod to i32 (i32, i32, ...)*)(i32 %90, i32 %93)
%95 = icmp eq i32 %87, %94
%96 = add nuw nsw i64 %80, 1
br i1 %95, label %75, label %97
97: ; preds = %79, %75, %65, %0
%98 = phi i8* [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), %0 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), %65 ], [ getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), %75 ], [ getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), %79 ]
%99 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) %98)
ret i32 0
}