#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*/ printf(char *);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  char *str;
  char rvrse[1000];
  int n, c = 0;
  scanf("%d", &n);
  str = (char *)malloc((n + 1) * sizeof(char));
  scanf("%s", str);
  for (int i = 0; i < n; i++) {
    rvrse[i] = str[n - 1 - i];
  }
  for (int i = 1; i < n; i++) {
    if ((str[i] - str[i - 1] == rvrse[i] - rvrse[i - 1]) ||
        ((str[i] - str[i - 1]) + (rvrse[i] - rvrse[i - 1]) == 0)) {
      c++;
    }
  }
  if (c == n - 1 && n != 0)
    printf("Good String");
  else if (n != 0)
    printf("Not Good String");
  else if (n == 0)
    printf("Good String");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x410,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x408(%rbp)
lea    0xead(%rip),%rdi
lea    -0x404(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x404(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rsi
lea    0xe7d(%rip),%rdi
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x40c(%rbp)
mov    -0x40c(%rbp),%eax
cmp    -0x404(%rbp),%eax
jge    11e4 <main+0xb4>
mov    -0x10(%rbp),%rax
mov    -0x404(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x40c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x40c(%rbp),%rax
mov    %cl,-0x400(%rbp,%rax,1)
mov    -0x40c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40c(%rbp)
jmp    1197 <main+0x67>
movl   $0x1,-0x410(%rbp)
mov    -0x410(%rbp),%eax
cmp    -0x404(%rbp),%eax
jge    12cf <main+0x19f>
mov    -0x10(%rbp),%rax
movslq -0x410(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x410(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
movslq -0x410(%rbp),%rcx
movsbl -0x400(%rbp,%rcx,1),%ecx
ff
mov    -0x410(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl -0x400(%rbp,%rdx,1),%edx
ff
sub    %edx,%ecx
cmp    %ecx,%eax
je     12a7 <main+0x177>
mov    -0x10(%rbp),%rax
movslq -0x410(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x410(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
movslq -0x410(%rbp),%rcx
movsbl -0x400(%rbp,%rcx,1),%ecx
ff
mov    -0x410(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl -0x400(%rbp,%rdx,1),%edx
ff
sub    %edx,%ecx
add    %ecx,%eax
cmp    $0x0,%eax
jne    12b6 <main+0x186>
mov    -0x408(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x408(%rbp)
jmp    12bb <main+0x18b>
mov    -0x410(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x410(%rbp)
jmp    11ee <main+0xbe>
mov    -0x408(%rbp),%eax
mov    -0x404(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1304 <main+0x1d4>
cmpl   $0x0,-0x404(%rbp)
je     1304 <main+0x1d4>
lea    0xd10(%rip),%rdi
call   1030 <printf@plt>
jmp    1345 <main+0x215>
cmpl   $0x0,-0x404(%rbp)
je     1322 <main+0x1f2>
lea    0xcee(%rip),%rdi
call   1030 <printf@plt>
jmp    1340 <main+0x210>
cmpl   $0x0,-0x404(%rbp)
jne    133b <main+0x20b>
lea    0xcd4(%rip),%rdi
call   1030 <printf@plt>
jmp    1340 <main+0x210>
jmp    1345 <main+0x215>
xor    %eax,%eax
add    $0x410,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r14
push   %rbx
sub    $0x400,%rsp
lea    0xebe(%rip),%rdi
xor    %ebp,%ebp
lea    0xc(%rsp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%edi
add    $0x1,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
lea    0xe9d(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
mov    0xc(%rsp),%r9d
test   %r9d,%r9d
jle    1513 <main+0x3e3>
cmp    $0x8,%r9d
jae    118b <main+0x5b>
xor    %ecx,%ecx
jmp    12b8 <main+0x188>
lea    -0x1(%r9),%rsi
lea    -0x1(%r9),%edx
mov    %edx,%edi
sub    %esi,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jg     12b8 <main+0x188>
shr    $0x20,%rsi
jne    12b8 <main+0x188>
cmp    $0x20,%r9d
jae    11b8 <main+0x88>
xor    %ecx,%ecx
jmp    1268 <main+0x138>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %edx,%rdx
movdqu -0x1f(%r14,%rdx,1),%xmm1
movdqu -0xf(%r14,%rdx,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
movdqa %xmm2,0x10(%rsp,%rsi,1)
movdqa %xmm1,0x20(%rsp,%rsi,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    11d0 <main+0xa0>
cmp    %r9,%rcx
je     1325 <main+0x1f5>
test   $0x18,%r9b
je     12b8 <main+0x188>
mov    %rcx,%rdx
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %r9d,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movslq %esi,%rsi
movq   -0x7(%r14,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x10(%rsp,%rdx,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    1280 <main+0x150>
cmp    %r9,%rcx
je     1325 <main+0x1f5>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%r9b
je     12da <main+0x1aa>
mov    %ecx,%esi
not    %esi
add    %r9d,%esi
movslq %esi,%rsi
mov    (%r14,%rsi,1),%al
mov    %al,0x10(%rsp,%rcx,1)
or     $0x1,%rcx
add    %r9,%rdx
je     1325 <main+0x1f5>
mov    %r9,%rdx
sub    %rcx,%rdx
mov    %ecx,%esi
not    %esi
add    %r9d,%esi
lea    0x10(%rsp),%rax
add    %rax,%rcx
add    $0x1,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
movzbl (%r14,%rsi,1),%eax
mov    %al,-0x1(%rcx,%rdi,1)
lea    -0x1(%rsi),%eax
cltq
movzbl (%r14,%rax,1),%eax
mov    %al,(%rcx,%rdi,1)
add    $0x2,%rdi
add    $0xfffffffe,%esi
cmp    %rdi,%rdx
jne    1300 <main+0x1d0>
xor    %ebp,%ebp
cmp    $0x2,%r9d
jl     1513 <main+0x3e3>
mov    (%r14),%dl
mov    0x10(%rsp),%dil
lea    -0x1(%r9),%r8
cmp    $0x8,%r8
jae    134f <main+0x21f>
xor    %ebp,%ebp
mov    $0x1,%ecx
jmp    14e0 <main+0x3b0>
mov    %r8,%rsi
and    $0xfffffffffffffff8,%rsi
lea    0x1(%rsi),%rcx
movzbl %dil,%eax
movd   %eax,%xmm3
pslld  $0x18,%xmm3
movzbl %dl,%eax
movd   %eax,%xmm1
pslld  $0x18,%xmm1
pxor   %xmm9,%xmm9
xor    %edi,%edi
pxor   %xmm10,%xmm10
nop
mov    0x1(%r14,%rdi,1),%eax
movd   %eax,%xmm8
movd   %eax,%xmm4
punpcklbw %xmm4,%xmm4
pshufd $0x44,%xmm4,%xmm5
pshuflw $0x0,%xmm5,%xmm5
pshufhw $0xa4,%xmm5,%xmm7
movss  %xmm1,%xmm7
movd   0x5(%r14,%rdi,1),%xmm1
punpcklwd %xmm4,%xmm5
psrad  $0x18,%xmm5
punpcklbw %xmm1,%xmm6
punpcklwd %xmm6,%xmm4
psrad  $0x18,%xmm4
psrad  $0x18,%xmm7
psubd  %xmm7,%xmm5
pshufd $0x44,%xmm6,%xmm6
pshuflw $0x0,%xmm6,%xmm6
pshufhw $0xa4,%xmm6,%xmm6
movss  %xmm8,%xmm6
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm4
mov    0x11(%rsp,%rdi,1),%eax
movd   %eax,%xmm8
movd   %eax,%xmm7
punpcklbw %xmm7,%xmm7
pshufd $0x44,%xmm7,%xmm6
pshuflw $0x0,%xmm6,%xmm6
pshufhw $0xa4,%xmm6,%xmm6
movss  %xmm3,%xmm6
movd   0x15(%rsp,%rdi,1),%xmm3
punpcklwd %xmm7,%xmm7
psrad  $0x18,%xmm7
punpcklbw %xmm3,%xmm0
punpcklwd %xmm0,%xmm2
psrad  $0x18,%xmm2
psrad  $0x18,%xmm6
psubd  %xmm6,%xmm7
pshufd $0x44,%xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufhw $0xa4,%xmm0,%xmm0
movss  %xmm8,%xmm0
psrad  $0x18,%xmm0
psubd  %xmm0,%xmm2
pxor   %xmm0,%xmm0
psubd  %xmm7,%xmm0
pcmpeqd %xmm5,%xmm0
pcmpeqd %xmm7,%xmm5
pxor   %xmm6,%xmm6
psubd  %xmm2,%xmm6
pcmpeqd %xmm4,%xmm6
pcmpeqd %xmm2,%xmm4
movdqa %xmm5,%xmm2
pandn  %xmm0,%xmm2
psrld  $0x1f,%xmm2
psubd  %xmm5,%xmm2
paddd  %xmm2,%xmm9
movdqa %xmm4,%xmm0
pandn  %xmm6,%xmm0
psrld  $0x1f,%xmm0
psubd  %xmm4,%xmm0
paddd  %xmm0,%xmm10
add    $0x8,%rdi
cmp    %rdi,%rsi
jne    1380 <main+0x250>
paddd  %xmm9,%xmm10
pshufd $0xee,%xmm10,%xmm0
paddd  %xmm10,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%ebp
cmp    %rsi,%r8
je     1513 <main+0x3e3>
movd   %xmm3,%edi
shr    $0x18,%edi
movd   %xmm1,%edx
shr    $0x18,%edx
nopw   0x0(%rax,%rax,1)
movsbl (%r14,%rcx,1),%eax
movsbl %dl,%esi
mov    %eax,%edx
sub    %esi,%eax
movsbl 0x10(%rsp,%rcx,1),%esi
movsbl %dil,%ebx
mov    %esi,%edi
sub    %ebx,%esi
cmp    %esi,%eax
sete   %bl
add    %eax,%esi
sete   %al
or     %bl,%al
movzbl %al,%eax
add    %eax,%ebp
add    $0x1,%rcx
cmp    %rcx,%r9
jne    14e0 <main+0x3b0>
mov    %r9d,%eax
add    $0xffffffff,%eax
lea    0xae6(%rip),%rcx
lea    0xae3(%rip),%rdi
cmovae %rdi,%rcx
cmp    %eax,%ebp
cmovne %rcx,%rdi
add    $0xffffffff,%r9d
cmovae %rcx,%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x400,%rsp
pop    %rbx
pop    %r14
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 [1000 x i8]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %5
%8 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %4)
%9 = load i32, i32* %4
%10 = add nsw i32 %9, 1
%11 = sext i32 %10 to i64
%12 = mul i64 %11, 1
%13 = trunc i64 %12 to i32
%14 = call i64 @malloc(i32 %13)
%15 = inttoptr i64 %14 to i8*
store i8* %15, i8** %2
%16 = load i8*, i8** %2
%17 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %16)
store i32 0, i32* %6
br label %18
18: ; preds = %34, %0
%19 = load i32, i32* %6
%20 = load i32, i32* %4
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %37
22: ; preds = %18
%23 = load i8*, i8** %2
%24 = load i32, i32* %4
%25 = sub nsw i32 %24, 1
%26 = load i32, i32* %6
%27 = sub nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i8, i8* %23, i64 %28
%30 = load i8, i8* %29
%31 = load i32, i32* %6
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 %32
store i8 %30, i8* %33
br label %34
34: ; preds = %22
%35 = load i32, i32* %6
%36 = add nsw i32 %35, 1
store i32 %36, i32* %6
br label %18
37: ; preds = %18
store i32 1, i32* %7
br label %38
38: ; preds = %103, %37
%39 = load i32, i32* %7
%40 = load i32, i32* %4
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %106
42: ; preds = %38
%43 = load i8*, i8** %2
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = sext i8 %47 to i32
%49 = load i8*, i8** %2
%50 = load i32, i32* %7
%51 = sub nsw i32 %50, 1
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %49, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = sub nsw i32 %48, %55
%57 = load i32, i32* %7
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 %58
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = load i32, i32* %7
%63 = sub nsw i32 %62, 1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = sub nsw i32 %61, %67
%69 = icmp eq i32 %56, %68
br i1 %69, label %99, label %70
70: ; preds = %42
%71 = load i8*, i8** %2
%72 = load i32, i32* %7
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %71, i64 %73
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = load i8*, i8** %2
%78 = load i32, i32* %7
%79 = sub nsw i32 %78, 1
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %77, i64 %80
%82 = load i8, i8* %81
%83 = sext i8 %82 to i32
%84 = sub nsw i32 %76, %83
%85 = load i32, i32* %7
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 %86
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = load i32, i32* %7
%91 = sub nsw i32 %90, 1
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [1000 x i8], [1000 x i8]* %3, i64 0, i64 %92
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = sub nsw i32 %89, %95
%97 = add nsw i32 %84, %96
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %102
99: ; preds = %70, %42
%100 = load i32, i32* %5
%101 = add nsw i32 %100, 1
store i32 %101, i32* %5
br label %102
102: ; preds = %99, %70
br label %103
103: ; preds = %102
%104 = load i32, i32* %7
%105 = add nsw i32 %104, 1
store i32 %105, i32* %7
br label %38
106: ; preds = %38
%107 = load i32, i32* %5
%108 = load i32, i32* %4
%109 = sub nsw i32 %108, 1
%110 = icmp eq i32 %107, %109
br i1 %110, label %111, label %116
111: ; preds = %106
%112 = load i32, i32* %4
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %116
114: ; preds = %111
%115 = call i32 @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
br label %128
116: ; preds = %111, %106
%117 = load i32, i32* %4
%118 = icmp ne i32 %117, 0
br i1 %118, label %119, label %121
119: ; preds = %116
%120 = call i32 @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0))
br label %127
121: ; preds = %116
%122 = load i32, i32* %4
%123 = icmp eq i32 %122, 0
br i1 %123, label %124, label %126
124: ; preds = %121
%125 = call i32 @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0))
br label %126
126: ; preds = %124, %121
br label %127
127: ; preds = %126, %119
br label %128
128: ; preds = %127, %114
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 [1000 x i8]
%2 = alloca i32
%3 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 0
%4 = bitcast i32* %2 to i8*
%5 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
%6 = load i32, i32* %2
%7 = add nsw i32 %6, 1
%8 = call i64 @malloc(i32 %7)
%9 = inttoptr i64 %8 to i8*
%10 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %9)
%11 = load i32, i32* %2
%12 = icmp sgt i32 %11, 0
br i1 %12, label %13, label %185
13: ; preds = %0
%14 = zext i32 %11 to i64
%15 = icmp ult i32 %11, 8
br i1 %15, label %75, label %16
16: ; preds = %13
%17 = add nsw i64 %14, -1
%18 = add i32 %11, -1
%19 = trunc i64 %17 to i32
%20 = sub i32 %18, %19
%21 = icmp sgt i32 %20, %18
%22 = icmp ugt i64 %17, 4294967295
%23 = or i1 %21, %22
br i1 %23, label %75, label %24
24: ; preds = %16
%25 = icmp ult i32 %11, 32
br i1 %25, label %55, label %26
26: ; preds = %24
%27 = and i64 %14, 4294967264
br label %28
28: ; preds = %28, %26
%29 = phi i64 [ 0, %26 ], [ %48, %28 ]
%30 = trunc i64 %29 to i32
%31 = xor i32 %30, -1
%32 = add i32 %11, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %9, i64 %33
%35 = getelementptr inbounds i8, i8* %34, i64 -15
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = shufflevector <16 x i8> %37, <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>
%39 = getelementptr inbounds i8, i8* %34, i64 -16
%40 = getelementptr inbounds i8, i8* %39, i64 -15
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = shufflevector <16 x i8> %42, <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>
%44 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %29
%45 = bitcast i8* %44 to <16 x i8>*
store <16 x i8> %38, <16 x i8>* %45
%46 = getelementptr inbounds i8, i8* %44, i64 16
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %47
%48 = add nuw i64 %29, 32
%49 = icmp eq i64 %48, %27
br i1 %49, label %50, label %28
50: ; preds = %28
%51 = icmp eq i64 %27, %14
br i1 %51, label %93, label %52
52: ; preds = %50
%53 = and i64 %14, 24
%54 = icmp eq i64 %53, 0
br i1 %54, label %75, label %55
55: ; preds = %24, %52
%56 = phi i64 [ %27, %52 ], [ 0, %24 ]
%57 = and i64 %14, 4294967288
%58 = getelementptr inbounds i8, i8* %9, i64 -7
br label %59
59: ; preds = %59, %55
%60 = phi i64 [ %56, %55 ], [ %71, %59 ]
%61 = trunc i64 %60 to i32
%62 = xor i32 %61, -1
%63 = add i32 %11, %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %58, i64 %64
%66 = bitcast i8* %65 to <8 x i8>*
%67 = load <8 x i8>, <8 x i8>* %66
%68 = shufflevector <8 x i8> %67, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%69 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %60
%70 = bitcast i8* %69 to <8 x i8>*
store <8 x i8> %68, <8 x i8>* %70
%71 = add nuw i64 %60, 8
%72 = icmp eq i64 %71, %57
br i1 %72, label %73, label %59
73: ; preds = %59
%74 = icmp eq i64 %57, %14
br i1 %74, label %93, label %75
75: ; preds = %16, %13, %52, %73
%76 = phi i64 [ 0, %13 ], [ 0, %16 ], [ %27, %52 ], [ %57, %73 ]
%77 = xor i64 %76, -1
%78 = and i64 %14, 1
%79 = icmp eq i64 %78, 0
br i1 %79, label %89, label %80
80: ; preds = %75
%81 = trunc i64 %76 to i32
%82 = xor i32 %81, -1
%83 = add i32 %11, %82
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i8, i8* %9, i64 %84
%86 = load i8, i8* %85
%87 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %76
store i8 %86, i8* %87
%88 = or i64 %76, 1
br label %89
89: ; preds = %80, %75
%90 = phi i64 [ %76, %75 ], [ %88, %80 ]
%91 = sub nsw i64 0, %14
%92 = icmp eq i64 %77, %91
br i1 %92, label %93, label %166
93: ; preds = %89, %166, %73, %50
%94 = icmp sgt i32 %11, 1
br i1 %94, label %95, label %185
95: ; preds = %93
%96 = zext i32 %11 to i64
%97 = load i8, i8* %9
%98 = load i8, i8* %3
%99 = add nsw i64 %14, -1
%100 = icmp ult i64 %99, 8
br i1 %100, label %161, label %101
101: ; preds = %95
%102 = and i64 %99, -8
%103 = or i64 %102, 1
%104 = insertelement <4 x i8> poison, i8 %98, i64 3
%105 = insertelement <4 x i8> poison, i8 %97, i64 3
br label %106
106: ; preds = %106, %101
%107 = phi i64 [ 0, %101 ], [ %153, %106 ]
%108 = phi <4 x i8> [ %104, %101 ], [ %132, %106 ]
%109 = phi <4 x i8> [ %105, %101 ], [ %118, %106 ]
%110 = phi <4 x i32> [ zeroinitializer, %101 ], [ %151, %106 ]
%111 = phi <4 x i32> [ zeroinitializer, %101 ], [ %152, %106 ]
%112 = or i64 %107, 1
%113 = getelementptr inbounds i8, i8* %9, i64 %112
%114 = bitcast i8* %113 to <4 x i8>*
%115 = load <4 x i8>, <4 x i8>* %114
%116 = getelementptr inbounds i8, i8* %113, i64 4
%117 = bitcast i8* %116 to <4 x i8>*
%118 = load <4 x i8>, <4 x i8>* %117
%119 = shufflevector <4 x i8> %109, <4 x i8> %115, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%120 = shufflevector <4 x i8> %115, <4 x i8> %118, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%121 = sext <4 x i8> %115 to <4 x i32>
%122 = sext <4 x i8> %118 to <4 x i32>
%123 = sext <4 x i8> %119 to <4 x i32>
%124 = sext <4 x i8> %120 to <4 x i32>
%125 = sub nsw <4 x i32> %121, %123
%126 = sub nsw <4 x i32> %122, %124
%127 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %112
%128 = bitcast i8* %127 to <4 x i8>*
%129 = load <4 x i8>, <4 x i8>* %128
%130 = getelementptr inbounds i8, i8* %127, i64 4
%131 = bitcast i8* %130 to <4 x i8>*
%132 = load <4 x i8>, <4 x i8>* %131
%133 = shufflevector <4 x i8> %108, <4 x i8> %129, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%134 = shufflevector <4 x i8> %129, <4 x i8> %132, <4 x i32> <i32 3, i32 4, i32 5, i32 6>
%135 = sext <4 x i8> %129 to <4 x i32>
%136 = sext <4 x i8> %132 to <4 x i32>
%137 = sext <4 x i8> %133 to <4 x i32>
%138 = sext <4 x i8> %134 to <4 x i32>
%139 = sub nsw <4 x i32> %135, %137
%140 = sub nsw <4 x i32> %136, %138
%141 = icmp eq <4 x i32> %125, %139
%142 = icmp eq <4 x i32> %126, %140
%143 = sub nsw <4 x i32> zeroinitializer, %139
%144 = sub nsw <4 x i32> zeroinitializer, %140
%145 = icmp eq <4 x i32> %125, %143
%146 = icmp eq <4 x i32> %126, %144
%147 = select <4 x i1> %141, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %145
%148 = select <4 x i1> %142, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %146
%149 = zext <4 x i1> %147 to <4 x i32>
%150 = zext <4 x i1> %148 to <4 x i32>
%151 = add <4 x i32> %110, %149
%152 = add <4 x i32> %111, %150
%153 = add nuw i64 %107, 8
%154 = icmp eq i64 %153, %102
br i1 %154, label %155, label %106
155: ; preds = %106
%156 = add <4 x i32> %152, %151
%157 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %156)
%158 = icmp eq i64 %99, %102
%159 = extractelement <4 x i8> %132, i64 3
%160 = extractelement <4 x i8> %118, i64 3
br i1 %158, label %185, label %161
161: ; preds = %95, %155
%162 = phi i8 [ %159, %155 ], [ %98, %95 ]
%163 = phi i8 [ %160, %155 ], [ %97, %95 ]
%164 = phi i64 [ %103, %155 ], [ 1, %95 ]
%165 = phi i32 [ %157, %155 ], [ 0, %95 ]
br label %194
166: ; preds = %89, %166
%167 = phi i64 [ %183, %166 ], [ %90, %89 ]
%168 = trunc i64 %167 to i32
%169 = xor i32 %168, -1
%170 = add i32 %11, %169
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i8, i8* %9, i64 %171
%173 = load i8, i8* %172
%174 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %167
store i8 %173, i8* %174
%175 = add nuw nsw i64 %167, 1
%176 = trunc i64 %175 to i32
%177 = xor i32 %176, -1
%178 = add i32 %11, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %9, i64 %179
%181 = load i8, i8* %180
%182 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %175
store i8 %181, i8* %182
%183 = add nuw nsw i64 %167, 2
%184 = icmp eq i64 %183, %14
br i1 %184, label %93, label %166
185: ; preds = %194, %155, %0, %93
%186 = phi i32 [ 0, %93 ], [ 0, %0 ], [ %157, %155 ], [ %214, %194 ]
%187 = add nsw i32 %11, -1
%188 = icmp eq i32 %186, %187
%189 = icmp ne i32 %11, 0
%190 = and i1 %189, %188
%191 = select i1 %189, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0)
%192 = select i1 %190, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i8* %191
%193 = call i32 @printf(i8* dereferenceable(1) %192)
ret i32 0
194: ; preds = %161, %194
%195 = phi i8 [ %205, %194 ], [ %162, %161 ]
%196 = phi i8 [ %200, %194 ], [ %163, %161 ]
%197 = phi i64 [ %215, %194 ], [ %164, %161 ]
%198 = phi i32 [ %214, %194 ], [ %165, %161 ]
%199 = getelementptr inbounds i8, i8* %9, i64 %197
%200 = load i8, i8* %199
%201 = sext i8 %200 to i32
%202 = sext i8 %196 to i32
%203 = sub nsw i32 %201, %202
%204 = getelementptr inbounds [1000 x i8], [1000 x i8]* %1, i64 0, i64 %197
%205 = load i8, i8* %204
%206 = sext i8 %205 to i32
%207 = sext i8 %195 to i32
%208 = sub nsw i32 %206, %207
%209 = icmp eq i32 %203, %208
%210 = sub nsw i32 0, %208
%211 = icmp eq i32 %203, %210
%212 = select i1 %209, i1 true, i1 %211
%213 = zext i1 %212 to i32
%214 = add nuw nsw i32 %198, %213
%215 = add nuw nsw i64 %197, 1
%216 = icmp eq i64 %215, %96
br i1 %216, label %185, label %194
}