void destroy(char word[65], char scramble[64], char hide[3][65], int select) {
  int i, upper_b = 126, lower_b = 32, rotate;
  rotate = upper_b - lower_b;
  for (i = 0; i < 64; i++) {
    scramble[i] =
        (((word[i] - lower_b) + (hide[select][i] - lower_b)) % rotate +
         lower_b);
  }
  scramble[i] = '\0';
}


x86 assembly (clang, -O0):
<destroy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x7e,-0x24(%rbp)
movl   $0x20,-0x28(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x40,-0x20(%rbp)
jge    1186 <destroy+0x86>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    -0x28(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
imul   $0x41,%rdx,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    -0x28(%rbp),%ecx
add    %ecx,%eax
cltd
idivl  -0x2c(%rbp)
add    -0x28(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1131 <destroy+0x31>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<destroy>:
push   %rbx
movslq %ecx,%rax
lea    0x40(%rdi),%rcx
mov    %rax,%r8
shl    $0x6,%r8
add    %rax,%r8
cmp    %rsi,%rcx
seta   %r10b
lea    0x40(%rsi),%rax
cmp    %rdi,%rax
seta   %r11b
lea    (%rdx,%r8,1),%rcx
add    $0x40,%rcx
cmp    %rsi,%rcx
seta   %bl
lea    (%rdx,%r8,1),%rcx
cmp    %rax,%rcx
setb   %r9b
test   %r11b,%r10b
jne    13fe <destroy+0x2fe>
and    %r9b,%bl
jne    13fe <destroy+0x2fe>
movdqu (%rdi),%xmm0
punpckhbw %xmm0,%xmm4
psraw  $0x8,%xmm4
punpcklbw %xmm0,%xmm5
psraw  $0x8,%xmm5
movdqu (%rdx,%r8,1),%xmm0
punpckhbw %xmm0,%xmm1
psraw  $0x8,%xmm1
punpcklbw %xmm0,%xmm0
psraw  $0x8,%xmm0
movdqa 0xe7b(%rip),%xmm2
paddw  %xmm2,%xmm4
paddw  %xmm1,%xmm4
paddw  %xmm2,%xmm5
paddw  %xmm0,%xmm5
movdqa 0xe73(%rip),%xmm0
movdqa %xmm5,%xmm3
pmulhw %xmm0,%xmm3
paddw  %xmm5,%xmm3
movdqa %xmm3,%xmm1
psrlw  $0xf,%xmm1
psrlw  $0x6,%xmm3
paddw  %xmm1,%xmm3
movdqa 0xe5d(%rip),%xmm1
pmullw %xmm1,%xmm3
psubw  %xmm3,%xmm5
movdqa %xmm4,%xmm3
pmulhw %xmm0,%xmm3
paddw  %xmm4,%xmm3
movdqa %xmm3,%xmm6
psrlw  $0xf,%xmm6
psrlw  $0x6,%xmm3
paddw  %xmm6,%xmm3
pmullw %xmm1,%xmm3
psubw  %xmm3,%xmm4
movdqa 0xe37(%rip),%xmm3
pand   %xmm3,%xmm4
pand   %xmm3,%xmm5
packuswb %xmm4,%xmm5
movdqa 0xe32(%rip),%xmm8
paddb  %xmm8,%xmm5
movdqu %xmm5,(%rsi)
movdqu 0x10(%rdi),%xmm6
punpckhbw %xmm6,%xmm5
psraw  $0x8,%xmm5
punpcklbw %xmm6,%xmm6
psraw  $0x8,%xmm6
movdqu 0x10(%rdx,%r8,1),%xmm7
punpckhbw %xmm7,%xmm4
psraw  $0x8,%xmm4
punpcklbw %xmm7,%xmm7
psraw  $0x8,%xmm7
paddw  %xmm2,%xmm5
paddw  %xmm4,%xmm5
paddw  %xmm2,%xmm6
paddw  %xmm7,%xmm6
movdqa %xmm6,%xmm4
pmulhw %xmm0,%xmm4
paddw  %xmm6,%xmm4
movdqa %xmm4,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x6,%xmm4
paddw  %xmm7,%xmm4
pmullw %xmm1,%xmm4
psubw  %xmm4,%xmm6
movdqa %xmm5,%xmm4
pmulhw %xmm0,%xmm4
paddw  %xmm5,%xmm4
movdqa %xmm4,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x6,%xmm4
paddw  %xmm7,%xmm4
pmullw %xmm1,%xmm4
psubw  %xmm4,%xmm5
pand   %xmm3,%xmm5
pand   %xmm3,%xmm6
packuswb %xmm5,%xmm6
paddb  %xmm8,%xmm6
movdqu %xmm6,0x10(%rsi)
movdqu 0x20(%rdi),%xmm4
punpckhbw %xmm4,%xmm5
psraw  $0x8,%xmm5
punpcklbw %xmm4,%xmm6
psraw  $0x8,%xmm6
movdqu 0x20(%rdx,%r8,1),%xmm4
punpckhbw %xmm4,%xmm7
psraw  $0x8,%xmm7
punpcklbw %xmm4,%xmm4
psraw  $0x8,%xmm4
paddw  %xmm2,%xmm5
paddw  %xmm7,%xmm5
paddw  %xmm2,%xmm6
paddw  %xmm4,%xmm6
movdqa %xmm6,%xmm4
pmulhw %xmm0,%xmm4
paddw  %xmm6,%xmm4
movdqa %xmm4,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x6,%xmm4
paddw  %xmm7,%xmm4
pmullw %xmm1,%xmm4
psubw  %xmm4,%xmm6
movdqa %xmm5,%xmm4
pmulhw %xmm0,%xmm4
paddw  %xmm5,%xmm4
movdqa %xmm4,%xmm7
psrlw  $0xf,%xmm7
psrlw  $0x6,%xmm4
paddw  %xmm7,%xmm4
pmullw %xmm1,%xmm4
psubw  %xmm4,%xmm5
pand   %xmm3,%xmm5
pand   %xmm3,%xmm6
packuswb %xmm5,%xmm6
paddb  %xmm8,%xmm6
movdqu %xmm6,0x20(%rsi)
movdqu 0x30(%rdi),%xmm4
punpckhbw %xmm4,%xmm5
psraw  $0x8,%xmm5
punpcklbw %xmm4,%xmm6
psraw  $0x8,%xmm6
movdqu 0x30(%rdx,%r8,1),%xmm4
punpckhbw %xmm4,%xmm7
psraw  $0x8,%xmm7
punpcklbw %xmm4,%xmm4
psraw  $0x8,%xmm4
paddw  %xmm2,%xmm5
paddw  %xmm7,%xmm5
paddw  %xmm2,%xmm6
paddw  %xmm4,%xmm6
movdqa %xmm6,%xmm2
pmulhw %xmm0,%xmm2
paddw  %xmm6,%xmm2
movdqa %xmm2,%xmm4
psrlw  $0xf,%xmm4
psrlw  $0x6,%xmm2
paddw  %xmm4,%xmm2
pmullw %xmm1,%xmm2
psubw  %xmm2,%xmm6
pmulhw %xmm5,%xmm0
paddw  %xmm5,%xmm0
movdqa %xmm0,%xmm2
psrlw  $0xf,%xmm2
psrlw  $0x6,%xmm0
paddw  %xmm2,%xmm0
pmullw %xmm1,%xmm0
psubw  %xmm0,%xmm5
pand   %xmm3,%xmm5
pand   %xmm3,%xmm6
packuswb %xmm5,%xmm6
paddb  %xmm8,%xmm6
movdqu %xmm6,0x30(%rsi)
jmp    1490 <destroy+0x390>
add    %rdx,%r8
add    $0x1,%r8
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsbl (%rdi,%rcx,1),%edx
movsbl -0x1(%r8,%rcx,1),%ebx
lea    (%rdx,%rbx,1),%eax
add    %ebx,%edx
add    $0xffffffc0,%edx
movswl %dx,%ebx
imul   $0xffffae4d,%ebx,%ebx
shr    $0x10,%ebx
add    %ebx,%eax
add    $0xffffffc0,%eax
movzwl %ax,%eax
mov    %eax,%ebx
shr    $0xf,%ebx
shr    $0x6,%eax
add    %ebx,%eax
imul   $0x5e,%eax,%eax
sub    %eax,%edx
add    $0x20,%dl
mov    %dl,(%rsi,%rcx,1)
movsbl 0x1(%rdi,%rcx,1),%eax
movsbl (%r8,%rcx,1),%edx
lea    (%rax,%rdx,1),%ebx
add    %edx,%eax
add    $0xffffffc0,%eax
movswl %ax,%edx
imul   $0xffffae4d,%edx,%edx
shr    $0x10,%edx
add    %ebx,%edx
add    $0xffffffc0,%edx
movzwl %dx,%edx
mov    %edx,%ebx
shr    $0xf,%ebx
shr    $0x6,%edx
add    %ebx,%edx
imul   $0x5e,%edx,%edx
sub    %edx,%eax
add    $0x20,%al
mov    %al,0x1(%rsi,%rcx,1)
add    $0x2,%rcx
cmp    $0x40,%rcx
jne    1410 <destroy+0x310>
movb   $0x0,0x40(%rsi)
pop    %rbx
ret

LLVM IR (-O0):
define void @destroy(i8* %0, i8* %1, [65 x i8]* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca [65 x i8]*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store [65 x i8]* %2, [65 x i8]** %7
store i32 %3, i32* %8
store i32 126, i32* %10
store i32 32, i32* %11
%13 = load i32, i32* %10
%14 = load i32, i32* %11
%15 = sub nsw i32 %13, %14
store i32 %15, i32* %12
store i32 0, i32* %9
br label %16
16: ; preds = %49, %4
%17 = load i32, i32* %9
%18 = icmp slt i32 %17, 64
br i1 %18, label %19, label %52
19: ; preds = %16
%20 = load i8*, i8** %5
%21 = load i32, i32* %9
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = sext i8 %24 to i32
%26 = load i32, i32* %11
%27 = sub nsw i32 %25, %26
%28 = load [65 x i8]*, [65 x i8]** %7
%29 = load i32, i32* %8
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds [65 x i8], [65 x i8]* %28, i64 %30
%32 = load i32, i32* %9
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [65 x i8], [65 x i8]* %31, i64 0, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = load i32, i32* %11
%38 = sub nsw i32 %36, %37
%39 = add nsw i32 %27, %38
%40 = load i32, i32* %12
%41 = srem i32 %39, %40
%42 = load i32, i32* %11
%43 = add nsw i32 %41, %42
%44 = trunc i32 %43 to i8
%45 = load i8*, i8** %6
%46 = load i32, i32* %9
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %45, i64 %47
store i8 %44, i8* %48
br label %49
49: ; preds = %19
%50 = load i32, i32* %9
%51 = add nsw i32 %50, 1
store i32 %51, i32* %9
br label %16
52: ; preds = %16
%53 = load i8*, i8** %6
%54 = load i32, i32* %9
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
store i8 0, i8* %56
ret void
}

LLVM IR (-O2):
define void @destroy(i8* nocapture %0, i8* nocapture writeonly %1, [65 x i8]* nocapture %2, i32 %3) {
%5 = sext i32 %3 to i64
%6 = getelementptr i8, i8* %1, i64 64
%7 = getelementptr i8, i8* %0, i64 64
%8 = getelementptr [65 x i8], [65 x i8]* %2, i64 %5, i64 0
%9 = getelementptr [65 x i8], [65 x i8]* %2, i64 %5, i64 64
%10 = icmp ugt i8* %7, %1
%11 = icmp ugt i8* %6, %0
%12 = and i1 %10, %11
%13 = icmp ugt i8* %9, %1
%14 = icmp ult i8* %8, %6
%15 = and i1 %13, %14
%16 = or i1 %12, %15
br i1 %16, label %76, label %17
17: ; preds = %4
%18 = bitcast i8* %0 to <16 x i8>*
%19 = load <16 x i8>, <16 x i8>* %18
%20 = sext <16 x i8> %19 to <16 x i16>
%21 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 0
%22 = bitcast i8* %21 to <16 x i8>*
%23 = load <16 x i8>, <16 x i8>* %22
%24 = sext <16 x i8> %23 to <16 x i16>
%25 = add nsw <16 x i16> %20, <i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64>
%26 = add nsw <16 x i16> %25, %24
%27 = srem <16 x i16> %26, <i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94>
%28 = trunc <16 x i16> %27 to <16 x i8>
%29 = add nsw <16 x i8> %28, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%30 = bitcast i8* %1 to <16 x i8>*
store <16 x i8> %29, <16 x i8>* %30
%31 = getelementptr inbounds i8, i8* %0, i64 16
%32 = bitcast i8* %31 to <16 x i8>*
%33 = load <16 x i8>, <16 x i8>* %32
%34 = sext <16 x i8> %33 to <16 x i16>
%35 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 16
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = sext <16 x i8> %37 to <16 x i16>
%39 = add nsw <16 x i16> %34, <i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64>
%40 = add nsw <16 x i16> %39, %38
%41 = srem <16 x i16> %40, <i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94>
%42 = trunc <16 x i16> %41 to <16 x i8>
%43 = add nsw <16 x i8> %42, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%44 = getelementptr inbounds i8, i8* %1, i64 16
%45 = bitcast i8* %44 to <16 x i8>*
store <16 x i8> %43, <16 x i8>* %45
%46 = getelementptr inbounds i8, i8* %0, i64 32
%47 = bitcast i8* %46 to <16 x i8>*
%48 = load <16 x i8>, <16 x i8>* %47
%49 = sext <16 x i8> %48 to <16 x i16>
%50 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 32
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = sext <16 x i8> %52 to <16 x i16>
%54 = add nsw <16 x i16> %49, <i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64>
%55 = add nsw <16 x i16> %54, %53
%56 = srem <16 x i16> %55, <i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94>
%57 = trunc <16 x i16> %56 to <16 x i8>
%58 = add nsw <16 x i8> %57, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%59 = getelementptr inbounds i8, i8* %1, i64 32
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %58, <16 x i8>* %60
%61 = getelementptr inbounds i8, i8* %0, i64 48
%62 = bitcast i8* %61 to <16 x i8>*
%63 = load <16 x i8>, <16 x i8>* %62
%64 = sext <16 x i8> %63 to <16 x i16>
%65 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 48
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = sext <16 x i8> %67 to <16 x i16>
%69 = add nsw <16 x i16> %64, <i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64, i16 -64>
%70 = add nsw <16 x i16> %69, %68
%71 = srem <16 x i16> %70, <i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94, i16 94>
%72 = trunc <16 x i16> %71 to <16 x i8>
%73 = add nsw <16 x i8> %72, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%74 = getelementptr inbounds i8, i8* %1, i64 48
%75 = bitcast i8* %74 to <16 x i8>*
store <16 x i8> %73, <16 x i8>* %75
br label %105
76: ; preds = %4, %76
%77 = phi i64 [ %103, %76 ], [ 0, %4 ]
%78 = getelementptr inbounds i8, i8* %0, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i16
%81 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 %77
%82 = load i8, i8* %81
%83 = sext i8 %82 to i16
%84 = add nsw i16 %80, -64
%85 = add nsw i16 %84, %83
%86 = srem i16 %85, 94
%87 = trunc i16 %86 to i8
%88 = add nsw i8 %87, 32
%89 = getelementptr inbounds i8, i8* %1, i64 %77
store i8 %88, i8* %89
%90 = or i64 %77, 1
%91 = getelementptr inbounds i8, i8* %0, i64 %90
%92 = load i8, i8* %91
%93 = sext i8 %92 to i16
%94 = getelementptr inbounds [65 x i8], [65 x i8]* %2, i64 %5, i64 %90
%95 = load i8, i8* %94
%96 = sext i8 %95 to i16
%97 = add nsw i16 %93, -64
%98 = add nsw i16 %97, %96
%99 = srem i16 %98, 94
%100 = trunc i16 %99 to i8
%101 = add nsw i8 %100, 32
%102 = getelementptr inbounds i8, i8* %1, i64 %90
store i8 %101, i8* %102
%103 = add nuw nsw i64 %77, 2
%104 = icmp eq i64 %103, 64
br i1 %104, label %105, label %76
105: ; preds = %76, %17
%106 = getelementptr inbounds i8, i8* %1, i64 64
store i8 0, i8* %106
ret void
}