#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 */
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, int *);
void encrypt(char str[50][50], char encrypted[50][50]) {
  int n, i, j, fromZero, temp = 0;
  int length = 50;
  for (i = 0; i < length; i++) {
    for (j = 0; j < length; j++) {
      encrypted[i][j] = '\0';
    }
  }
  printf("Input an integer N to encrypt: ");
  scanf("%i", &n);
  getchar();
  for (i = 0; i < length; i++) {
    for (j = 0; j < length; j++) {
      if (str[i][j] >= 'a' && str[i][j] <= 'z') {
        fromZero = str[i][j] - 'a';
        temp = (fromZero + n) % 26;
        while (temp < 0)
          temp += 26;
        encrypted[i][j] = temp + 'a';
      } else if (str[i][j] >= 'A' && str[i][j] <= 'Z') {
        fromZero = str[i][j] - 'A';
        temp = (fromZero + n) % 26;
        while (temp < 0)
          temp += 26;
        encrypted[i][j] = temp + 'A';
      } else {
        encrypted[i][j] = str[i][j];
      }
    }
  }
  for (i = 0; i < length; i++) {
    for (j = 0; j < length; j++) {
      str[i][j] = encrypted[i][j];
    }
  }
  for (i = 0; i < length; i++) {
    for (j = 0; j < length; j++) {
      if (encrypted[i][j] == '\n' || encrypted[i][j] == '\r') {
        encrypted[i][j] = '\0';
      } else {
        encrypted[i][j] = str[j][i];
      }
    }
  }
  int charFound;
  for (i = 0; i < length; i++) {
    charFound = 0;
    for (j = length - 1; j >= 0; j--) {
      if (!charFound && encrypted[i][j] != '\0')
        charFound = 1;
      if (charFound && encrypted[i][j] == '\0')
        encrypted[i][j] = ' ';
    }
  }
  for (j = 0; j < length; j++) {
    charFound = 0;
    for (i = length - 1; i >= 0; i--) {
      if (!charFound && encrypted[i][j] != '\0')
        charFound = 1;
      if (charFound && encrypted[i][j] == '\0')
        encrypted[i][j] = ' ';
    }
  }
}


x86 assembly (clang, -O0):
<encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x32,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11ac <encrypt+0x7c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1199 <encrypt+0x69>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1168 <encrypt+0x38>
jmp    119e <encrypt+0x6e>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1155 <encrypt+0x25>
lea    0xe4d(%rip),%rdi
call   1030 <printf@plt>
lea    0xe61(%rip),%rdi
lea    -0x14(%rbp),%rsi
call   1050 <scanf@plt>
mov    $0x0,%al
call   1040 <getchar@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    139e <encrypt+0x26e>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    138b <encrypt+0x25b>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jl     129e <encrypt+0x16e>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x7a,%eax
jg     129e <encrypt+0x16e>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x61,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x14(%rbp),%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    127b <encrypt+0x14b>
mov    -0x24(%rbp),%eax
add    $0x1a,%eax
mov    %eax,-0x24(%rbp)
jmp    1263 <encrypt+0x133>
mov    -0x24(%rbp),%eax
add    $0x61,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1378 <encrypt+0x248>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     1347 <encrypt+0x217>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     1347 <encrypt+0x217>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x41,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    -0x14(%rbp),%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
mov    %edx,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jge    1324 <encrypt+0x1f4>
mov    -0x24(%rbp),%eax
add    $0x1a,%eax
mov    %eax,-0x24(%rbp)
jmp    130c <encrypt+0x1dc>
mov    -0x24(%rbp),%eax
add    $0x41,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1373 <encrypt+0x243>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1378 <encrypt+0x248>
jmp    137d <encrypt+0x24d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e9 <encrypt+0xb9>
jmp    1390 <encrypt+0x260>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d6 <encrypt+0xa6>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1411 <encrypt+0x2e1>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13fe <encrypt+0x2ce>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    13b8 <encrypt+0x288>
jmp    1403 <encrypt+0x2d3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13a5 <encrypt+0x275>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14e5 <encrypt+0x3b5>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14d2 <encrypt+0x3a2>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     1477 <encrypt+0x347>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xd,%eax
jne    1493 <encrypt+0x363>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    14bf <encrypt+0x38f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14c4 <encrypt+0x394>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    142b <encrypt+0x2fb>
jmp    14d7 <encrypt+0x3a7>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1418 <encrypt+0x2e8>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15aa <encrypt+0x47a>
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     1597 <encrypt+0x467>
cmpl   $0x0,-0x2c(%rbp)
jne    1543 <encrypt+0x413>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1543 <encrypt+0x413>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1584 <encrypt+0x454>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1584 <encrypt+0x454>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    1589 <encrypt+0x459>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1508 <encrypt+0x3d8>
jmp    159c <encrypt+0x46c>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    14ec <encrypt+0x3bc>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    166f <encrypt+0x53f>
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     165c <encrypt+0x52c>
cmpl   $0x0,-0x2c(%rbp)
jne    1608 <encrypt+0x4d8>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1608 <encrypt+0x4d8>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1649 <encrypt+0x519>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1649 <encrypt+0x519>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x32,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
jmp    164e <encrypt+0x51e>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    15cd <encrypt+0x49d>
jmp    1661 <encrypt+0x531>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15b1 <encrypt+0x481>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<encrypt>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,%r12
mov    %rdi,%r14
xor    %r15d,%r15d
mov    $0x9c4,%edx
mov    %rsi,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
lea    0xf53(%rip),%rdi
call   1030 <printf@plt>
lea    0xf67(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1060 <scanf@plt>
xor    %eax,%eax
call   1050 <getchar@plt>
mov    0xc(%rsp),%r8d
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm11
movdqa 0xe5e(%rip),%xmm3
movdqa 0xe65(%rip),%xmm12
movdqa 0xe6c(%rip),%xmm13
movdqa 0xe73(%rip),%xmm10
movdqa 0xe7a(%rip),%xmm8
movdqa 0xe82(%rip),%xmm7
mov    %r12,%r9
mov    %r14,%rdx
movdqa %xmm11,0x20(%rsp)
jmp    11f6 <encrypt+0xb6>
nopl   (%rax)
add    $0x1,%r15
add    $0x32,%rdx
add    $0x32,%r9
cmp    $0x32,%r15
je     1be3 <encrypt+0xaa3>
imul   $0x32,%r15,%rax
lea    (%r14,%rax,1),%rsi
add    $0x32,%rsi
lea    (%r12,%rax,1),%rdi
cmp    %rsi,%rdi
jae    1230 <encrypt+0xf0>
lea    (%r14,%rax,1),%rsi
add    %r12,%rax
add    $0x32,%rax
cmp    %rax,%rsi
jae    1230 <encrypt+0xf0>
xor    %esi,%esi
jmp    1b76 <encrypt+0xa36>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rdx,%rsi,1),%xmm2
movdqa %xmm2,0x60(%rsp)
punpckhbw %xmm2,%xmm1
punpckhwd %xmm1,%xmm9
psrad  $0x18,%xmm9
punpcklwd %xmm1,%xmm4
psrad  $0x18,%xmm4
punpcklbw %xmm2,%xmm1
punpckhwd %xmm1,%xmm5
psrad  $0x18,%xmm5
punpcklwd %xmm1,%xmm6
psrad  $0x18,%xmm6
movdqa %xmm2,%xmm1
paddb  %xmm3,%xmm1
movdqa %xmm1,%xmm3
pminub %xmm12,%xmm3
pcmpeqb %xmm1,%xmm3
movdqa %xmm2,%xmm1
paddb  %xmm13,%xmm1
movdqa %xmm1,%xmm2
pminub %xmm12,%xmm2
pcmpeqb %xmm1,%xmm2
pand   %xmm3,%xmm2
movdqa %xmm2,0x70(%rsp)
movdqa %xmm6,%xmm13
paddd  %xmm11,%xmm13
movdqa %xmm13,0x50(%rsp)
movdqa %xmm10,%xmm2
paddd  %xmm10,%xmm13
movdqa %xmm5,%xmm12
paddd  %xmm11,%xmm12
movdqa %xmm12,0x40(%rsp)
paddd  %xmm10,%xmm12
movdqa %xmm4,%xmm10
paddd  %xmm11,%xmm10
movdqa %xmm10,0x10(%rsp)
paddd  %xmm2,%xmm10
paddd  %xmm11,%xmm9
movdqa %xmm9,0x30(%rsp)
paddd  %xmm2,%xmm9
movdqa %xmm9,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm9,%xmm3
pmuludq %xmm8,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm9,%xmm3
pand   %xmm8,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm1,%xmm3
psrld  $0x1f,%xmm3
psrad  $0x3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
psubd  %xmm1,%xmm9
movdqa %xmm10,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm10,%xmm3
pmuludq %xmm8,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm10,%xmm3
pand   %xmm8,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm1,%xmm3
psrld  $0x1f,%xmm3
psrad  $0x3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
psubd  %xmm1,%xmm10
movdqa %xmm12,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm12,%xmm3
pmuludq %xmm8,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm12,%xmm3
pand   %xmm8,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm1,%xmm3
psrld  $0x1f,%xmm3
psrad  $0x3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
psubd  %xmm1,%xmm12
movdqa %xmm13,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm13,%xmm3
pmuludq %xmm8,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pxor   %xmm3,%xmm3
pcmpgtd %xmm13,%xmm3
pand   %xmm8,%xmm3
psubd  %xmm3,%xmm1
movdqa %xmm1,%xmm3
psrld  $0x1f,%xmm3
psrad  $0x3,%xmm1
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
psubd  %xmm1,%xmm13
movdqa %xmm12,%xmm1
pxor   %xmm0,%xmm0
pcmpgtd %xmm0,%xmm1
pand   %xmm12,%xmm1
movdqa %xmm10,%xmm5
pcmpgtd %xmm0,%xmm5
pand   %xmm10,%xmm5
movdqa %xmm9,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm9,%xmm6
psubd  %xmm9,%xmm6
psubd  %xmm10,%xmm5
psubd  %xmm12,%xmm1
movdqa %xmm5,%xmm14
pcmpeqd %xmm0,%xmm14
pcmpeqd %xmm15,%xmm15
pxor   %xmm15,%xmm14
paddd  %xmm14,%xmm5
movdqa %xmm6,%xmm4
pcmpeqd %xmm0,%xmm4
pxor   %xmm15,%xmm4
paddd  %xmm4,%xmm6
movdqa %xmm7,%xmm11
pshufd $0xf5,%xmm6,%xmm7
pmuludq %xmm8,%xmm6
pshufd $0xed,%xmm6,%xmm6
pmuludq %xmm8,%xmm7
pshufd $0xed,%xmm7,%xmm7
punpckldq %xmm7,%xmm6
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm8,%xmm5
pshufd $0xed,%xmm5,%xmm5
pmuludq %xmm8,%xmm7
pshufd $0xed,%xmm7,%xmm7
punpckldq %xmm7,%xmm5
movdqa %xmm1,%xmm3
pcmpeqd %xmm0,%xmm3
pxor   %xmm15,%xmm3
paddd  %xmm3,%xmm1
pshufd $0xf5,%xmm1,%xmm7
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pmuludq %xmm8,%xmm7
pshufd $0xed,%xmm7,%xmm7
punpckldq %xmm7,%xmm1
movdqa %xmm13,%xmm7
pcmpgtd %xmm0,%xmm7
pand   %xmm13,%xmm7
psubd  %xmm13,%xmm7
movdqa %xmm8,%xmm2
movdqa %xmm7,%xmm8
pcmpeqd %xmm0,%xmm8
pxor   %xmm15,%xmm8
paddd  %xmm8,%xmm7
pshufd $0xf5,%xmm7,%xmm0
pmuludq %xmm2,%xmm7
pshufd $0xed,%xmm7,%xmm7
pmuludq %xmm2,%xmm0
pshufd $0xed,%xmm0,%xmm0
punpckldq %xmm0,%xmm7
psrld  $0x3,%xmm7
psubd  %xmm8,%xmm7
movdqa %xmm2,%xmm8
psrld  $0x3,%xmm1
psubd  %xmm3,%xmm1
psrld  $0x3,%xmm6
psrld  $0x3,%xmm5
psubd  %xmm14,%xmm5
psubd  %xmm4,%xmm6
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm11,%xmm6
pshufd $0xe8,%xmm6,%xmm3
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm11,%xmm5
pshufd $0xe8,%xmm5,%xmm4
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
pshufd $0xf5,%xmm1,%xmm0
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
pshufd $0xf5,%xmm7,%xmm0
pmuludq %xmm11,%xmm7
pshufd $0xe8,%xmm7,%xmm14
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm14
paddd  %xmm13,%xmm14
paddd  %xmm12,%xmm1
movdqa 0xa10(%rip),%xmm0
movdqa 0x9e8(%rip),%xmm2
paddd  %xmm10,%xmm4
paddd  %xmm9,%xmm3
pand   %xmm2,%xmm3
pand   %xmm2,%xmm4
packuswb %xmm3,%xmm4
pand   %xmm2,%xmm1
pand   %xmm2,%xmm14
packuswb %xmm1,%xmm14
packuswb %xmm4,%xmm14
movdqa 0x50(%rsp),%xmm15
paddd  %xmm0,%xmm15
movdqa 0x40(%rsp),%xmm3
paddd  %xmm0,%xmm3
movdqa 0x10(%rsp),%xmm2
paddd  %xmm0,%xmm2
movdqa 0x30(%rsp),%xmm12
paddd  %xmm0,%xmm12
movdqa %xmm12,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm12,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pxor   %xmm1,%xmm1
pcmpgtd %xmm12,%xmm1
pand   %xmm8,%xmm1
psubd  %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1f,%xmm1
psrad  $0x3,%xmm0
paddd  %xmm1,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
psubd  %xmm0,%xmm12
movdqa %xmm2,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pxor   %xmm1,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm8,%xmm1
psubd  %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1f,%xmm1
psrad  $0x3,%xmm0
paddd  %xmm1,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
psubd  %xmm0,%xmm2
movdqa %xmm3,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm3,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pxor   %xmm1,%xmm1
pcmpgtd %xmm3,%xmm1
pand   %xmm8,%xmm1
psubd  %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1f,%xmm1
psrad  $0x3,%xmm0
paddd  %xmm1,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
psubd  %xmm0,%xmm3
movdqa %xmm15,%xmm0
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm15,%xmm1
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
pxor   %xmm1,%xmm1
pcmpgtd %xmm15,%xmm1
pand   %xmm8,%xmm1
psubd  %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x1f,%xmm1
psrad  $0x3,%xmm0
paddd  %xmm1,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm11,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm11,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
psubd  %xmm0,%xmm15
movdqa %xmm15,%xmm1
pxor   %xmm5,%xmm5
pcmpgtd %xmm5,%xmm1
pand   %xmm15,%xmm1
movdqa %xmm3,%xmm0
pcmpgtd %xmm5,%xmm3
pand   %xmm0,%xmm3
movdqa %xmm0,%xmm13
movdqa %xmm2,%xmm0
movdqa %xmm2,0x10(%rsp)
movdqa %xmm2,%xmm4
pcmpgtd %xmm5,%xmm4
pand   %xmm2,%xmm4
movdqa %xmm12,%xmm7
pcmpgtd %xmm5,%xmm7
pxor   %xmm2,%xmm2
pand   %xmm12,%xmm7
psubd  %xmm12,%xmm7
psubd  %xmm0,%xmm4
psubd  %xmm13,%xmm3
psubd  %xmm15,%xmm1
movdqa %xmm1,%xmm9
pcmpeqd %xmm2,%xmm9
pcmpeqd %xmm0,%xmm0
pxor   %xmm0,%xmm9
paddd  %xmm9,%xmm1
movdqa %xmm3,%xmm10
pcmpeqd %xmm2,%xmm10
pxor   %xmm0,%xmm10
paddd  %xmm10,%xmm3
movdqa %xmm4,%xmm6
pcmpeqd %xmm2,%xmm6
pxor   %xmm0,%xmm6
pcmpeqd %xmm0,%xmm0
paddd  %xmm6,%xmm4
movdqa %xmm7,%xmm5
pcmpeqd %xmm2,%xmm5
pxor   %xmm0,%xmm5
paddd  %xmm5,%xmm7
pshufd $0xf5,%xmm7,%xmm0
pmuludq %xmm8,%xmm7
pshufd $0xed,%xmm7,%xmm7
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
punpckldq %xmm0,%xmm7
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm8,%xmm4
pshufd $0xed,%xmm4,%xmm4
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm8,%xmm3
pshufd $0xed,%xmm3,%xmm3
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
pshufd $0xf5,%xmm1,%xmm0
pmuludq %xmm8,%xmm1
pshufd $0xed,%xmm1,%xmm1
pmuludq %xmm8,%xmm0
pshufd $0xed,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
psrld  $0x3,%xmm1
psubd  %xmm9,%xmm1
movdqa 0x6d2(%rip),%xmm9
psrld  $0x3,%xmm3
psubd  %xmm10,%xmm3
psrld  $0x3,%xmm4
psubd  %xmm6,%xmm4
movdqa 0x676(%rip),%xmm10
psrld  $0x3,%xmm7
psubd  %xmm5,%xmm7
pshufd $0xf5,%xmm7,%xmm0
pmuludq %xmm11,%xmm7
pshufd $0xe8,%xmm7,%xmm5
movdqa %xmm11,%xmm7
movdqa 0x6c0(%rip),%xmm11
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm5
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm7,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
pshufd $0xf5,%xmm3,%xmm0
pmuludq %xmm7,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
pshufd $0xf5,%xmm1,%xmm0
pmuludq %xmm7,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
paddd  %xmm15,%xmm1
paddd  %xmm13,%xmm3
paddd  0x10(%rsp),%xmm4
paddd  %xmm12,%xmm5
movdqa 0x605(%rip),%xmm0
pand   %xmm0,%xmm5
pand   %xmm0,%xmm4
packuswb %xmm5,%xmm4
movdqa 0x5b0(%rip),%xmm13
pand   %xmm0,%xmm3
pand   %xmm0,%xmm1
packuswb %xmm3,%xmm1
movdqa 0x57c(%rip),%xmm3
packuswb %xmm4,%xmm1
movdqa 0x57f(%rip),%xmm12
movdqa 0x60(%rsp),%xmm4
movdqa %xmm4,%xmm0
paddb  %xmm11,%xmm0
movdqa 0x608(%rip),%xmm5
movdqa %xmm0,%xmm2
pminub %xmm5,%xmm2
pcmpeqb %xmm0,%xmm2
movdqa 0x20(%rsp),%xmm11
paddb  %xmm9,%xmm14
movdqa 0x5c8(%rip),%xmm5
paddb  %xmm5,%xmm1
pand   %xmm2,%xmm14
pandn  %xmm1,%xmm2
por    %xmm14,%xmm2
movdqa 0x70(%rsp),%xmm1
pand   %xmm1,%xmm4
pandn  %xmm2,%xmm1
por    %xmm4,%xmm1
movdqu %xmm1,(%r9,%rsi,1)
add    $0x10,%rsi
cmp    $0x30,%rsi
jne    1240 <encrypt+0x100>
mov    $0x30,%esi
jmp    1b76 <encrypt+0xa36>
nopw   0x0(%rax,%rax,1)
lea    (%rdi,%r8,1),%eax
add    $0xffffff9f,%eax
movslq %eax,%rdi
imul   $0x4ec4ec4f,%rdi,%rax
mov    %rax,%rbx
shr    $0x3f,%rbx
sar    $0x23,%rax
add    %ebx,%eax
lea    (%rax,%rax,4),%ebx
lea    (%rbx,%rbx,4),%ebx
add    %eax,%ebx
sub    %ebx,%edi
test   %edi,%edi
mov    $0x0,%eax
cmovg  %edi,%eax
xor    %ebx,%ebx
sub    %edi,%eax
setne  %bl
sub    %ebx,%eax
imul   $0x4ec4ec4f,%rax,%rcx
shr    $0x23,%rcx
add    %ebx,%ecx
lea    (%rcx,%rcx,4),%eax
lea    (%rax,%rax,4),%eax
add    %ecx,%eax
add    %edi,%eax
add    $0x61,%al
mov    %al,(%r9,%rsi,1)
add    $0x1,%rsi
cmp    $0x32,%rsi
je     11e0 <encrypt+0xa0>
movzbl (%rdx,%rsi,1),%eax
movsbl %al,%edi
lea    -0x61(%rdi),%ebx
cmp    $0x19,%bl
jbe    1b10 <encrypt+0x9d0>
lea    -0x41(%rax),%ecx
cmp    $0x19,%cl
ja     1b64 <encrypt+0xa24>
lea    (%rdi,%r8,1),%eax
add    $0xffffffbf,%eax
movslq %eax,%rdi
imul   $0x4ec4ec4f,%rdi,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x23,%rax
add    %ecx,%eax
lea    (%rax,%rax,4),%ecx
lea    (%rcx,%rcx,4),%ecx
add    %eax,%ecx
sub    %ecx,%edi
test   %edi,%edi
mov    $0x0,%eax
cmovg  %edi,%eax
xor    %ecx,%ecx
sub    %edi,%eax
setne  %cl
sub    %ecx,%eax
imul   $0x4ec4ec4f,%rax,%rbx
shr    $0x23,%rbx
add    %ecx,%ebx
lea    (%rbx,%rbx,4),%eax
lea    (%rax,%rax,4),%eax
add    %ebx,%eax
add    %edi,%eax
add    $0x41,%al
jmp    1b64 <encrypt+0xa24>
xor    %r10d,%r10d
mov    %r12,%rcx
mov    %r14,%rdx
jmp    1c06 <encrypt+0xac6>
xchg   %ax,%ax
add    $0x1,%r10
add    $0x32,%rdx
add    $0x32,%rcx
cmp    $0x32,%r10
je     1ce1 <encrypt+0xba1>
imul   $0x32,%r10,%rax
lea    (%r12,%rax,1),%rsi
add    $0x32,%rsi
lea    (%r12,%rax,1),%r8
lea    (%r14,%rax,1),%r9
add    $0x32,%r9
lea    (%r14,%rax,1),%rbx
cmp    %rsi,%rbx
jae    1c30 <encrypt+0xaf0>
cmp    %r9,%r8
jae    1c30 <encrypt+0xaf0>
xor    %edi,%edi
jmp    1c59 <encrypt+0xb19>
movups (%r12,%rax,1),%xmm0
movups %xmm0,(%r14,%rax,1)
movups 0x10(%r12,%rax,1),%xmm0
movups %xmm0,0x10(%r14,%rax,1)
movdqu 0x20(%r12,%rax,1),%xmm0
movdqu %xmm0,0x20(%r14,%rax,1)
mov    $0x30,%edi
cmp    %r9,%r8
setb   %al
cmp    %rsi,%rbx
setb   %r8b
and    %al,%r8b
lea    0x4(%rdi),%rbx
mov    $0x2,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rsi
movzbl (%rcx,%rdi,1),%ebx
mov    %bl,(%rdx,%rdi,1)
add    $0x1,%rdi
lea    0x1(%rsi),%rbx
add    $0xffffffffffffffff,%rax
jne    1c80 <encrypt+0xb40>
test   %r8b,%r8b
je     1bf0 <encrypt+0xab0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rcx,%rsi,1),%eax
mov    %al,-0x3(%rdx,%rsi,1)
movzbl -0x2(%rcx,%rsi,1),%eax
mov    %al,-0x2(%rdx,%rsi,1)
movzbl -0x1(%rcx,%rsi,1),%eax
mov    %al,-0x1(%rdx,%rsi,1)
movzbl (%rcx,%rsi,1),%eax
mov    %al,(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    $0x35,%rsi
jne    1cb0 <encrypt+0xb70>
jmp    1bf0 <encrypt+0xab0>
xor    %eax,%eax
mov    %r12,%rcx
jmp    1d02 <encrypt+0xbc2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x32,%rcx
add    $0x1,%r14
cmp    $0x32,%rax
je     1d51 <encrypt+0xc11>
mov    $0x1,%edx
mov    %r14,%rsi
jmp    1d22 <encrypt+0xbe2>
nopl   0x0(%rax)
mov    %dil,(%rcx,%rdx,1)
add    $0x2,%rdx
add    $0x64,%rsi
cmp    $0x33,%rdx
je     1cf0 <encrypt+0xbb0>
movzbl -0x1(%rcx,%rdx,1),%ebx
xor    %edi,%edi
cmp    $0xa,%bl
je     1d36 <encrypt+0xbf6>
cmp    $0xd,%bl
je     1d36 <encrypt+0xbf6>
movzbl (%rsi),%edi
mov    %dil,-0x1(%rcx,%rdx,1)
movzbl (%rcx,%rdx,1),%ebx
xor    %edi,%edi
cmp    $0xa,%bl
je     1d10 <encrypt+0xbd0>
cmp    $0xd,%bl
je     1d10 <encrypt+0xbd0>
movzbl 0x32(%rsi),%edi
jmp    1d10 <encrypt+0xbd0>
xor    %eax,%eax
mov    %r12,%rcx
jmp    1d6e <encrypt+0xc2e>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x32,%rcx
cmp    $0x32,%rax
je     1da5 <encrypt+0xc65>
mov    $0x31,%edx
xor    %esi,%esi
jmp    1d8e <encrypt+0xc4e>
nopw   0x0(%rax,%rax,1)
xor    %esi,%esi
test   %bl,%bl
setne  %sil
add    $0xffffffffffffffff,%rdx
jae    1d60 <encrypt+0xc20>
movzbl (%rcx,%rdx,1),%ebx
test   %esi,%esi
je     1d80 <encrypt+0xc40>
mov    $0x1,%esi
test   %bl,%bl
jne    1d88 <encrypt+0xc48>
movb   $0x20,(%rcx,%rdx,1)
jmp    1d88 <encrypt+0xc48>
xor    %eax,%eax
jmp    1dbe <encrypt+0xc7e>
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x32,%rax
je     1dfa <encrypt+0xcba>
mov    $0x992,%ecx
xor    %edx,%edx
jmp    1de1 <encrypt+0xca1>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
test   %bl,%bl
setne  %dl
add    $0xffffffffffffffce,%rcx
cmp    $0xffffffffffffffce,%rcx
je     1db0 <encrypt+0xc70>
movzbl (%r12,%rcx,1),%ebx
test   %edx,%edx
je     1dd0 <encrypt+0xc90>
mov    $0x1,%edx
test   %bl,%bl
jne    1dd7 <encrypt+0xc97>
movb   $0x20,(%r12,%rcx,1)
jmp    1dd7 <encrypt+0xc97>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [32 x i8] c"Input an integer N to encrypt: \00"
@.str.1 = [3 x i8] c"%i\00"
define void @encrypt([50 x i8]* %0, [50 x i8]* %1) {
%3 = alloca [50 x i8]*
%4 = alloca [50 x i8]*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store [50 x i8]* %0, [50 x i8]** %3
store [50 x i8]* %1, [50 x i8]** %4
store i32 0, i32* %9
store i32 50, i32* %10
store i32 0, i32* %6
br label %12
12: ; preds = %33, %2
%13 = load i32, i32* %6
%14 = load i32, i32* %10
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %36
16: ; preds = %12
store i32 0, i32* %7
br label %17
17: ; preds = %29, %16
%18 = load i32, i32* %7
%19 = load i32, i32* %10
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %32
21: ; preds = %17
%22 = load [50 x i8]*, [50 x i8]** %4
%23 = load i32, i32* %6
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [50 x i8], [50 x i8]* %22, i64 %24
%26 = load i32, i32* %7
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [50 x i8], [50 x i8]* %25, i64 0, i64 %27
store i8 0, i8* %28
br label %29
29: ; preds = %21
%30 = load i32, i32* %7
%31 = add nsw i32 %30, 1
store i32 %31, i32* %7
br label %17
32: ; preds = %17
br label %33
33: ; preds = %32
%34 = load i32, i32* %6
%35 = add nsw i32 %34, 1
store i32 %35, i32* %6
br label %12
36: ; preds = %12
%37 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0))
%38 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %5)
%39 = call i32 (...) @getchar()
store i32 0, i32* %6
br label %40
40: ; preds = %179, %36
%41 = load i32, i32* %6
%42 = load i32, i32* %10
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %182
44: ; preds = %40
store i32 0, i32* %7
br label %45
45: ; preds = %175, %44
%46 = load i32, i32* %7
%47 = load i32, i32* %10
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %178
49: ; preds = %45
%50 = load [50 x i8]*, [50 x i8]** %3
%51 = load i32, i32* %6
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [50 x i8], [50 x i8]* %50, i64 %52
%54 = load i32, i32* %7
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [50 x i8], [50 x i8]* %53, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp sge i32 %58, 97
br i1 %59, label %60, label %103
60: ; preds = %49
%61 = load [50 x i8]*, [50 x i8]** %3
%62 = load i32, i32* %6
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [50 x i8], [50 x i8]* %61, i64 %63
%65 = load i32, i32* %7
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [50 x i8], [50 x i8]* %64, i64 0, i64 %66
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = icmp sle i32 %69, 122
br i1 %70, label %71, label %103
71: ; preds = %60
%72 = load [50 x i8]*, [50 x i8]** %3
%73 = load i32, i32* %6
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [50 x i8], [50 x i8]* %72, i64 %74
%76 = load i32, i32* %7
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [50 x i8], [50 x i8]* %75, i64 0, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
%81 = sub nsw i32 %80, 97
store i32 %81, i32* %8
%82 = load i32, i32* %8
%83 = load i32, i32* %5
%84 = add nsw i32 %82, %83
%85 = srem i32 %84, 26
store i32 %85, i32* %9
br label %86
86: ; preds = %89, %71
%87 = load i32, i32* %9
%88 = icmp slt i32 %87, 0
br i1 %88, label %89, label %92
89: ; preds = %86
%90 = load i32, i32* %9
%91 = add nsw i32 %90, 26
store i32 %91, i32* %9
br label %86
92: ; preds = %86
%93 = load i32, i32* %9
%94 = add nsw i32 %93, 97
%95 = trunc i32 %94 to i8
%96 = load [50 x i8]*, [50 x i8]** %4
%97 = load i32, i32* %6
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [50 x i8], [50 x i8]* %96, i64 %98
%100 = load i32, i32* %7
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [50 x i8], [50 x i8]* %99, i64 0, i64 %101
store i8 %95, i8* %102
br label %174
103: ; preds = %60, %49
%104 = load [50 x i8]*, [50 x i8]** %3
%105 = load i32, i32* %6
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [50 x i8], [50 x i8]* %104, i64 %106
%108 = load i32, i32* %7
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [50 x i8], [50 x i8]* %107, i64 0, i64 %109
%111 = load i8, i8* %110
%112 = sext i8 %111 to i32
%113 = icmp sge i32 %112, 65
br i1 %113, label %114, label %157
114: ; preds = %103
%115 = load [50 x i8]*, [50 x i8]** %3
%116 = load i32, i32* %6
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [50 x i8], [50 x i8]* %115, i64 %117
%119 = load i32, i32* %7
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [50 x i8], [50 x i8]* %118, i64 0, i64 %120
%122 = load i8, i8* %121
%123 = sext i8 %122 to i32
%124 = icmp sle i32 %123, 90
br i1 %124, label %125, label %157
125: ; preds = %114
%126 = load [50 x i8]*, [50 x i8]** %3
%127 = load i32, i32* %6
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [50 x i8], [50 x i8]* %126, i64 %128
%130 = load i32, i32* %7
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [50 x i8], [50 x i8]* %129, i64 0, i64 %131
%133 = load i8, i8* %132
%134 = sext i8 %133 to i32
%135 = sub nsw i32 %134, 65
store i32 %135, i32* %8
%136 = load i32, i32* %8
%137 = load i32, i32* %5
%138 = add nsw i32 %136, %137
%139 = srem i32 %138, 26
store i32 %139, i32* %9
br label %140
140: ; preds = %143, %125
%141 = load i32, i32* %9
%142 = icmp slt i32 %141, 0
br i1 %142, label %143, label %146
143: ; preds = %140
%144 = load i32, i32* %9
%145 = add nsw i32 %144, 26
store i32 %145, i32* %9
br label %140
146: ; preds = %140
%147 = load i32, i32* %9
%148 = add nsw i32 %147, 65
%149 = trunc i32 %148 to i8
%150 = load [50 x i8]*, [50 x i8]** %4
%151 = load i32, i32* %6
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [50 x i8], [50 x i8]* %150, i64 %152
%154 = load i32, i32* %7
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [50 x i8], [50 x i8]* %153, i64 0, i64 %155
store i8 %149, i8* %156
br label %173
157: ; preds = %114, %103
%158 = load [50 x i8]*, [50 x i8]** %3
%159 = load i32, i32* %6
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [50 x i8], [50 x i8]* %158, i64 %160
%162 = load i32, i32* %7
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [50 x i8], [50 x i8]* %161, i64 0, i64 %163
%165 = load i8, i8* %164
%166 = load [50 x i8]*, [50 x i8]** %4
%167 = load i32, i32* %6
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [50 x i8], [50 x i8]* %166, i64 %168
%170 = load i32, i32* %7
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [50 x i8], [50 x i8]* %169, i64 0, i64 %171
store i8 %165, i8* %172
br label %173
173: ; preds = %157, %146
br label %174
174: ; preds = %173, %92
br label %175
175: ; preds = %174
%176 = load i32, i32* %7
%177 = add nsw i32 %176, 1
store i32 %177, i32* %7
br label %45
178: ; preds = %45
br label %179
179: ; preds = %178
%180 = load i32, i32* %6
%181 = add nsw i32 %180, 1
store i32 %181, i32* %6
br label %40
182: ; preds = %40
store i32 0, i32* %6
br label %183
183: ; preds = %212, %182
%184 = load i32, i32* %6
%185 = load i32, i32* %10
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %215
187: ; preds = %183
store i32 0, i32* %7
br label %188
188: ; preds = %208, %187
%189 = load i32, i32* %7
%190 = load i32, i32* %10
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %211
192: ; preds = %188
%193 = load [50 x i8]*, [50 x i8]** %4
%194 = load i32, i32* %6
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [50 x i8], [50 x i8]* %193, i64 %195
%197 = load i32, i32* %7
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [50 x i8], [50 x i8]* %196, i64 0, i64 %198
%200 = load i8, i8* %199
%201 = load [50 x i8]*, [50 x i8]** %3
%202 = load i32, i32* %6
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [50 x i8], [50 x i8]* %201, i64 %203
%205 = load i32, i32* %7
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [50 x i8], [50 x i8]* %204, i64 0, i64 %206
store i8 %200, i8* %207
br label %208
208: ; preds = %192
%209 = load i32, i32* %7
%210 = add nsw i32 %209, 1
store i32 %210, i32* %7
br label %188
211: ; preds = %188
br label %212
212: ; preds = %211
%213 = load i32, i32* %6
%214 = add nsw i32 %213, 1
store i32 %214, i32* %6
br label %183
215: ; preds = %183
store i32 0, i32* %6
br label %216
216: ; preds = %276, %215
%217 = load i32, i32* %6
%218 = load i32, i32* %10
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %279
220: ; preds = %216
store i32 0, i32* %7
br label %221
221: ; preds = %272, %220
%222 = load i32, i32* %7
%223 = load i32, i32* %10
%224 = icmp slt i32 %222, %223
br i1 %224, label %225, label %275
225: ; preds = %221
%226 = load [50 x i8]*, [50 x i8]** %4
%227 = load i32, i32* %6
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [50 x i8], [50 x i8]* %226, i64 %228
%230 = load i32, i32* %7
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds [50 x i8], [50 x i8]* %229, i64 0, i64 %231
%233 = load i8, i8* %232
%234 = sext i8 %233 to i32
%235 = icmp eq i32 %234, 10
br i1 %235, label %247, label %236
236: ; preds = %225
%237 = load [50 x i8]*, [50 x i8]** %4
%238 = load i32, i32* %6
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [50 x i8], [50 x i8]* %237, i64 %239
%241 = load i32, i32* %7
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [50 x i8], [50 x i8]* %240, i64 0, i64 %242
%244 = load i8, i8* %243
%245 = sext i8 %244 to i32
%246 = icmp eq i32 %245, 13
br i1 %246, label %247, label %255
247: ; preds = %236, %225
%248 = load [50 x i8]*, [50 x i8]** %4
%249 = load i32, i32* %6
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds [50 x i8], [50 x i8]* %248, i64 %250
%252 = load i32, i32* %7
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [50 x i8], [50 x i8]* %251, i64 0, i64 %253
store i8 0, i8* %254
br label %271
255: ; preds = %236
%256 = load [50 x i8]*, [50 x i8]** %3
%257 = load i32, i32* %7
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [50 x i8], [50 x i8]* %256, i64 %258
%260 = load i32, i32* %6
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [50 x i8], [50 x i8]* %259, i64 0, i64 %261
%263 = load i8, i8* %262
%264 = load [50 x i8]*, [50 x i8]** %4
%265 = load i32, i32* %6
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds [50 x i8], [50 x i8]* %264, i64 %266
%268 = load i32, i32* %7
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [50 x i8], [50 x i8]* %267, i64 0, i64 %269
store i8 %263, i8* %270
br label %271
271: ; preds = %255, %247
br label %272
272: ; preds = %271
%273 = load i32, i32* %7
%274 = add nsw i32 %273, 1
store i32 %274, i32* %7
br label %221
275: ; preds = %221
br label %276
276: ; preds = %275
%277 = load i32, i32* %6
%278 = add nsw i32 %277, 1
store i32 %278, i32* %6
br label %216
279: ; preds = %216
store i32 0, i32* %6
br label %280
280: ; preds = %332, %279
%281 = load i32, i32* %6
%282 = load i32, i32* %10
%283 = icmp slt i32 %281, %282
br i1 %283, label %284, label %335
284: ; preds = %280
store i32 0, i32* %11
%285 = load i32, i32* %10
%286 = sub nsw i32 %285, 1
store i32 %286, i32* %7
br label %287
287: ; preds = %328, %284
%288 = load i32, i32* %7
%289 = icmp sge i32 %288, 0
br i1 %289, label %290, label %331
290: ; preds = %287
%291 = load i32, i32* %11
%292 = icmp ne i32 %291, 0
br i1 %292, label %305, label %293
293: ; preds = %290
%294 = load [50 x i8]*, [50 x i8]** %4
%295 = load i32, i32* %6
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [50 x i8], [50 x i8]* %294, i64 %296
%298 = load i32, i32* %7
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [50 x i8], [50 x i8]* %297, i64 0, i64 %299
%301 = load i8, i8* %300
%302 = sext i8 %301 to i32
%303 = icmp ne i32 %302, 0
br i1 %303, label %304, label %305
304: ; preds = %293
store i32 1, i32* %11
br label %305
305: ; preds = %304, %293, %290
%306 = load i32, i32* %11
%307 = icmp ne i32 %306, 0
br i1 %307, label %308, label %327
308: ; preds = %305
%309 = load [50 x i8]*, [50 x i8]** %4
%310 = load i32, i32* %6
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [50 x i8], [50 x i8]* %309, i64 %311
%313 = load i32, i32* %7
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds [50 x i8], [50 x i8]* %312, i64 0, i64 %314
%316 = load i8, i8* %315
%317 = sext i8 %316 to i32
%318 = icmp eq i32 %317, 0
br i1 %318, label %319, label %327
319: ; preds = %308
%320 = load [50 x i8]*, [50 x i8]** %4
%321 = load i32, i32* %6
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds [50 x i8], [50 x i8]* %320, i64 %322
%324 = load i32, i32* %7
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds [50 x i8], [50 x i8]* %323, i64 0, i64 %325
store i8 32, i8* %326
br label %327
327: ; preds = %319, %308, %305
br label %328
328: ; preds = %327
%329 = load i32, i32* %7
%330 = add nsw i32 %329, -1
store i32 %330, i32* %7
br label %287
331: ; preds = %287
br label %332
332: ; preds = %331
%333 = load i32, i32* %6
%334 = add nsw i32 %333, 1
store i32 %334, i32* %6
br label %280
335: ; preds = %280
store i32 0, i32* %7
br label %336
336: ; preds = %388, %335
%337 = load i32, i32* %7
%338 = load i32, i32* %10
%339 = icmp slt i32 %337, %338
br i1 %339, label %340, label %391
340: ; preds = %336
store i32 0, i32* %11
%341 = load i32, i32* %10
%342 = sub nsw i32 %341, 1
store i32 %342, i32* %6
br label %343
343: ; preds = %384, %340
%344 = load i32, i32* %6
%345 = icmp sge i32 %344, 0
br i1 %345, label %346, label %387
346: ; preds = %343
%347 = load i32, i32* %11
%348 = icmp ne i32 %347, 0
br i1 %348, label %361, label %349
349: ; preds = %346
%350 = load [50 x i8]*, [50 x i8]** %4
%351 = load i32, i32* %6
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [50 x i8], [50 x i8]* %350, i64 %352
%354 = load i32, i32* %7
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [50 x i8], [50 x i8]* %353, i64 0, i64 %355
%357 = load i8, i8* %356
%358 = sext i8 %357 to i32
%359 = icmp ne i32 %358, 0
br i1 %359, label %360, label %361
360: ; preds = %349
store i32 1, i32* %11
br label %361
361: ; preds = %360, %349, %346
%362 = load i32, i32* %11
%363 = icmp ne i32 %362, 0
br i1 %363, label %364, label %383
364: ; preds = %361
%365 = load [50 x i8]*, [50 x i8]** %4
%366 = load i32, i32* %6
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds [50 x i8], [50 x i8]* %365, i64 %367
%369 = load i32, i32* %7
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [50 x i8], [50 x i8]* %368, i64 0, i64 %370
%372 = load i8, i8* %371
%373 = sext i8 %372 to i32
%374 = icmp eq i32 %373, 0
br i1 %374, label %375, label %383
375: ; preds = %364
%376 = load [50 x i8]*, [50 x i8]** %4
%377 = load i32, i32* %6
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds [50 x i8], [50 x i8]* %376, i64 %378
%380 = load i32, i32* %7
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [50 x i8], [50 x i8]* %379, i64 0, i64 %381
store i8 32, i8* %382
br label %383
383: ; preds = %375, %364, %361
br label %384
384: ; preds = %383
%385 = load i32, i32* %6
%386 = add nsw i32 %385, -1
store i32 %386, i32* %6
br label %343
387: ; preds = %343
br label %388
388: ; preds = %387
%389 = load i32, i32* %7
%390 = add nsw i32 %389, 1
store i32 %390, i32* %7
br label %336
391: ; preds = %336
ret void
}

LLVM IR (-O2):
@.str = [32 x i8] c"Input an integer N to encrypt: \00"
@.str.1 = [3 x i8] c"%i\00"
define void @encrypt([50 x i8]* nocapture %0, [50 x i8]* nocapture %1) {
%3 = getelementptr [50 x i8], [50 x i8]* %1, i64 0, i64 0
%4 = alloca i32
%5 = bitcast i32* %4 to i8*
%6 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0))
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %4)
%8 = call i32 (...) @getchar()
%9 = load i32, i32* %4
%10 = insertelement <16 x i32> poison, i32 %9, i64 0
%11 = shufflevector <16 x i32> %10, <16 x i32> poison, <16 x i32> zeroinitializer
br label %12
12: ; preds = %2, %116
%13 = phi i64 [ 0, %2 ], [ %117, %116 ]
%14 = add nuw i64 %13, 1
%15 = getelementptr [50 x i8], [50 x i8]* %0, i64 %14, i64 0
%16 = getelementptr [50 x i8], [50 x i8]* %0, i64 %13, i64 0
%17 = getelementptr [50 x i8], [50 x i8]* %1, i64 %14, i64 0
%18 = getelementptr [50 x i8], [50 x i8]* %1, i64 %13, i64 0
%19 = icmp ult i8* %18, %15
%20 = icmp ult i8* %16, %17
%21 = and i1 %19, %20
br i1 %21, label %69, label %22
22: ; preds = %12, %22
%23 = phi i64 [ %67, %22 ], [ 0, %12 ]
%24 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %13, i64 %23
%25 = bitcast i8* %24 to <16 x i8>*
%26 = load <16 x i8>, <16 x i8>* %25
%27 = sext <16 x i8> %26 to <16 x i32>
%28 = add <16 x i8> %26, <i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123, i8 -123>
%29 = icmp ult <16 x i8> %28, <i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26>
%30 = add <16 x i8> %26, <i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91, i8 -91>
%31 = icmp ult <16 x i8> %30, <i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26, i8 -26>
%32 = add nsw <16 x i32> %27, <i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65, i32 -65>
%33 = add nsw <16 x i32> %32, %11
%34 = srem <16 x i32> %33, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%35 = call <16 x i32> @llvm.smax.v16i32(<16 x i32> %34, <16 x i32> zeroinitializer)
%36 = sub nsw <16 x i32> %35, %34
%37 = icmp ne <16 x i32> %36, zeroinitializer
%38 = zext <16 x i1> %37 to <16 x i32>
%39 = sub nsw <16 x i32> %36, %38
%40 = udiv <16 x i32> %39, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%41 = add nuw nsw <16 x i32> %40, %38
%42 = mul <16 x i32> %41, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%43 = add <16 x i32> %34, %42
%44 = trunc <16 x i32> %43 to <16 x i8>
%45 = add <16 x i8> %44, <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
%46 = add nsw <16 x i32> %27, <i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97, i32 -97>
%47 = add nsw <16 x i32> %46, %11
%48 = srem <16 x i32> %47, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%49 = call <16 x i32> @llvm.smax.v16i32(<16 x i32> %48, <16 x i32> zeroinitializer)
%50 = sub nsw <16 x i32> %49, %48
%51 = icmp ne <16 x i32> %50, zeroinitializer
%52 = zext <16 x i1> %51 to <16 x i32>
%53 = sub nsw <16 x i32> %50, %52
%54 = udiv <16 x i32> %53, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%55 = add nuw nsw <16 x i32> %54, %52
%56 = mul <16 x i32> %55, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%57 = add <16 x i32> %48, %56
%58 = trunc <16 x i32> %57 to <16 x i8>
%59 = add <16 x i8> %58, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%60 = add <16 x i8> %26, <i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65, i8 -65>
%61 = icmp ult <16 x i8> %60, <i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26, i8 26>
%62 = and <16 x i1> %29, %31
%63 = select <16 x i1> %61, <16 x i8> %45, <16 x i8> %59
%64 = select <16 x i1> %62, <16 x i8> %26, <16 x i8> %63
%65 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %13, i64 %23
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %66
%67 = add nuw i64 %23, 16
%68 = icmp eq i64 %67, 48
br i1 %68, label %69, label %22
69: ; preds = %22, %12
%70 = phi i64 [ 0, %12 ], [ 48, %22 ]
br label %71
71: ; preds = %69, %111
%72 = phi i64 [ %114, %111 ], [ %70, %69 ]
%73 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %13, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = add i8 %74, -97
%77 = icmp ult i8 %76, 26
br i1 %77, label %78, label %93
78: ; preds = %71
%79 = add nsw i32 %75, -97
%80 = add nsw i32 %79, %9
%81 = srem i32 %80, 26
%82 = call i32 @llvm.smax.i32(i32 %81, i32 0)
%83 = sub nsw i32 %82, %81
%84 = icmp ne i32 %83, 0
%85 = zext i1 %84 to i32
%86 = sub nsw i32 %83, %85
%87 = udiv i32 %86, 26
%88 = add nuw nsw i32 %87, %85
%89 = mul i32 %88, 26
%90 = add i32 %81, %89
%91 = trunc i32 %90 to i8
%92 = add i8 %91, 97
br label %111
93: ; preds = %71
%94 = add i8 %74, -65
%95 = icmp ult i8 %94, 26
br i1 %95, label %96, label %111
96: ; preds = %93
%97 = add nsw i32 %75, -65
%98 = add nsw i32 %97, %9
%99 = srem i32 %98, 26
%100 = call i32 @llvm.smax.i32(i32 %99, i32 0)
%101 = sub nsw i32 %100, %99
%102 = icmp ne i32 %101, 0
%103 = zext i1 %102 to i32
%104 = sub nsw i32 %101, %103
%105 = udiv i32 %104, 26
%106 = add nuw nsw i32 %105, %103
%107 = mul i32 %106, 26
%108 = add i32 %99, %107
%109 = trunc i32 %108 to i8
%110 = add i8 %109, 65
br label %111
111: ; preds = %93, %78, %96
%112 = phi i8 [ %92, %78 ], [ %110, %96 ], [ %74, %93 ]
%113 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %13, i64 %72
store i8 %112, i8* %113
%114 = add nuw nsw i64 %72, 1
%115 = icmp eq i64 %114, 50
br i1 %115, label %116, label %71
116: ; preds = %111
%117 = add nuw nsw i64 %13, 1
%118 = icmp eq i64 %117, 50
br i1 %118, label %119, label %12
119: ; preds = %116, %177
%120 = phi i64 [ %178, %177 ], [ 0, %116 ]
%121 = add nuw i64 %120, 1
%122 = getelementptr [50 x i8], [50 x i8]* %1, i64 %121, i64 0
%123 = getelementptr [50 x i8], [50 x i8]* %1, i64 %120, i64 0
%124 = getelementptr [50 x i8], [50 x i8]* %0, i64 %121, i64 0
%125 = getelementptr [50 x i8], [50 x i8]* %0, i64 %120, i64 0
%126 = icmp ult i8* %125, %122
%127 = icmp ult i8* %123, %124
%128 = and i1 %126, %127
br i1 %128, label %145, label %129
129: ; preds = %119
%130 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 0
%131 = bitcast i8* %130 to <16 x i8>*
%132 = load <16 x i8>, <16 x i8>* %131
%133 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 0
%134 = bitcast i8* %133 to <16 x i8>*
store <16 x i8> %132, <16 x i8>* %134
%135 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 16
%136 = bitcast i8* %135 to <16 x i8>*
%137 = load <16 x i8>, <16 x i8>* %136
%138 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 16
%139 = bitcast i8* %138 to <16 x i8>*
store <16 x i8> %137, <16 x i8>* %139
%140 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 32
%141 = bitcast i8* %140 to <16 x i8>*
%142 = load <16 x i8>, <16 x i8>* %141
%143 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 32
%144 = bitcast i8* %143 to <16 x i8>*
store <16 x i8> %142, <16 x i8>* %144
br label %145
145: ; preds = %129, %119
%146 = phi i64 [ 0, %119 ], [ 48, %129 ]
%147 = and i1 %126, %127
br label %148
148: ; preds = %148, %145
%149 = phi i64 [ %154, %148 ], [ %146, %145 ]
%150 = phi i64 [ %155, %148 ], [ 0, %145 ]
%151 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 %149
%152 = load i8, i8* %151
%153 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 %149
store i8 %152, i8* %153
%154 = add nuw nsw i64 %149, 1
%155 = add i64 %150, 1
%156 = icmp eq i64 %155, 2
br i1 %156, label %157, label %148
157: ; preds = %148
br i1 %147, label %158, label %177
158: ; preds = %157, %158
%159 = phi i64 [ %175, %158 ], [ %154, %157 ]
%160 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 %159
%161 = load i8, i8* %160
%162 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 %159
store i8 %161, i8* %162
%163 = add nuw nsw i64 %159, 1
%164 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 %163
%165 = load i8, i8* %164
%166 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 %163
store i8 %165, i8* %166
%167 = add nuw nsw i64 %159, 2
%168 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 %167
%169 = load i8, i8* %168
%170 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 %167
store i8 %169, i8* %170
%171 = add nuw nsw i64 %159, 3
%172 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %120, i64 %171
%173 = load i8, i8* %172
%174 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %120, i64 %171
store i8 %173, i8* %174
%175 = add nuw nsw i64 %159, 4
%176 = icmp eq i64 %175, 50
br i1 %176, label %177, label %158
177: ; preds = %158, %157
%178 = add nuw nsw i64 %120, 1
%179 = icmp eq i64 %178, 50
br i1 %179, label %180, label %119
180: ; preds = %177, %201
%181 = phi i64 [ %202, %201 ], [ 0, %177 ]
br label %182
182: ; preds = %197, %180
%183 = phi i64 [ 0, %180 ], [ %199, %197 ]
%184 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %181, i64 %183
%185 = load i8, i8* %184
switch i8 %185, label %186 [
i8 10, label %189
i8 13, label %189
]
186: ; preds = %182
%187 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %183, i64 %181
%188 = load i8, i8* %187
br label %189
189: ; preds = %182, %182, %186
%190 = phi i8 [ %188, %186 ], [ 0, %182 ], [ 0, %182 ]
store i8 %190, i8* %184
%191 = or i64 %183, 1
%192 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %181, i64 %191
%193 = load i8, i8* %192
switch i8 %193, label %194 [
i8 10, label %197
i8 13, label %197
]
194: ; preds = %189
%195 = getelementptr inbounds [50 x i8], [50 x i8]* %0, i64 %191, i64 %181
%196 = load i8, i8* %195
br label %197
197: ; preds = %194, %189, %189
%198 = phi i8 [ %196, %194 ], [ 0, %189 ], [ 0, %189 ]
store i8 %198, i8* %192
%199 = add nuw nsw i64 %183, 2
%200 = icmp eq i64 %199, 50
br i1 %200, label %201, label %182
201: ; preds = %197
%202 = add nuw nsw i64 %181, 1
%203 = icmp eq i64 %202, 50
br i1 %203, label %204, label %180
204: ; preds = %201, %223
%205 = phi i64 [ %224, %223 ], [ 0, %201 ]
br label %206
206: ; preds = %204, %219
%207 = phi i64 [ 49, %204 ], [ %221, %219 ]
%208 = phi i32 [ 0, %204 ], [ %220, %219 ]
%209 = icmp eq i32 %208, 0
%210 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %205, i64 %207
%211 = load i8, i8* %210
%212 = icmp eq i8 %211, 0
br i1 %209, label %213, label %216
213: ; preds = %206
%214 = xor i1 %212, true
%215 = zext i1 %214 to i32
br label %219
216: ; preds = %206
br i1 %212, label %217, label %219
217: ; preds = %216
%218 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %205, i64 %207
store i8 32, i8* %218
br label %219
219: ; preds = %213, %216, %217
%220 = phi i32 [ 1, %216 ], [ 1, %217 ], [ %215, %213 ]
%221 = add nsw i64 %207, -1
%222 = icmp eq i64 %207, 0
br i1 %222, label %223, label %206
223: ; preds = %219
%224 = add nuw nsw i64 %205, 1
%225 = icmp eq i64 %224, 50
br i1 %225, label %226, label %204
226: ; preds = %223, %245
%227 = phi i64 [ %246, %245 ], [ 0, %223 ]
br label %228
228: ; preds = %226, %241
%229 = phi i64 [ 49, %226 ], [ %243, %241 ]
%230 = phi i32 [ 0, %226 ], [ %242, %241 ]
%231 = icmp eq i32 %230, 0
%232 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %229, i64 %227
%233 = load i8, i8* %232
%234 = icmp eq i8 %233, 0
br i1 %231, label %235, label %238
235: ; preds = %228
%236 = xor i1 %234, true
%237 = zext i1 %236 to i32
br label %241
238: ; preds = %228
br i1 %234, label %239, label %241
239: ; preds = %238
%240 = getelementptr inbounds [50 x i8], [50 x i8]* %1, i64 %229, i64 %227
store i8 32, i8* %240
br label %241
241: ; preds = %235, %238, %239
%242 = phi i32 [ 1, %238 ], [ 1, %239 ], [ %237, %235 ]
%243 = add nsw i64 %229, -1
%244 = icmp eq i64 %229, 0
br i1 %244, label %245, label %228
245: ; preds = %241
%246 = add nuw nsw i64 %227, 1
%247 = icmp eq i64 %246, 50
br i1 %247, label %248, label %226
248: ; preds = %245
ret void
}