int main() {
  char lang[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
                 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
                 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
                 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
                 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '0', '1', '2',
                 '3', '4', '5', '6', '7', '8', '9', ' '};
  char pt[5], key[5];
  int len = 63;
  int i, j, k;
  int ptm[2][2], keym[2][2];
  printf("Enter Plain Text: ");
  scanf("%s", pt);
  printf("Enter Key Of Length 4 Of Prime Numbers:");
  for (i = 0; i < 4; i++) {
    key[i] = getche();
  }
  printf("\n\n");
  if (strlen(pt) != 4) {
    printf("Length Of Plain Text Should Be Equal To 4\n");
    exit(0);
  }
  int flag = -1;
  for (i = 0; i < 4; i++) {
    if ((i + 1) % 2 == 1) {
      flag++;
    }
    for (j = 0; j < len; j++) {
      if (pt[i] == lang[j]) {
        ptm[flag][i % 2] = j;
      }
      if (key[i] == lang[j]) {
        keym[flag][i % 2] = j;
      }
    }
  }
  int ctm[2][2];
  for (i = 0; i < 2; i++) {
    for (j = 0; j < 2; j++) {
      ctm[i][j] = 0;
    }
  }
  printf("\nCipher Text: ");
  for (i = 0; i < 2; i++) {
    for (j = 0; j < 2; j++) {
      for (k = 0; k < 2; k++) {
        ctm[i][j] += keym[i][k] * ptm[k][j];
      }
      ctm[i][j] = ctm[i][j] % len;
      printf("%c", lang[ctm[i][j]]);
    }
  }
  printf("\n\n");
  flag = keym[0][0] * keym[1][1] - keym[0][1] * keym[1][0];
  int inv_num;
  i = -1;
  j = 1;
  int f = flag;
  if (flag < 0) {
    f = -(flag);
  }
  if (!gcd(f, len)) {
    printf("Key Is Not Good, Try Another Key.");
  }
  while (1) {
    if ((flag * i) % len == 1) {
      inv_num = i;
      break;
    }
    i--;
    if ((flag * j) % len == 1) {
      inv_num = j;
      break;
    }
    j++;
  }
  flag = keym[1][1];
  keym[1][1] = keym[0][0];
  keym[0][0] = flag;
  keym[0][1] = -keym[0][1];
  keym[1][0] = -keym[1][0];
  int dtm[2][2];
  printf("\nDecrypted Text: ");
  for (i = 0; i < 2; i++) {
    for (j = 0; j < 2; j++) {
      dtm[i][j] = 0;
      for (k = 0; k < 2; k++) {
        dtm[i][j] += keym[i][k] * ctm[k][j] * inv_num;
      }
      if (dtm[i][j] < 0) {
        flag = len - ((-dtm[i][j]) % len);
        printf("%c", lang[flag]);
      } else {
        printf("%c", lang[dtm[i][j] % len]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x50(%rbp),%rdi
lea    0xe73(%rip),%rsi
mov    $0x3f,%edx
call   1060 <memcpy@plt>
movl   $0x3f,-0x60(%rbp)
lea    0xe9a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x55(%rbp),%rsi
lea    0xe9b(%rip),%rdi
mov    $0x0,%al
call   1070 <scanf@plt>
lea    0xe90(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    11fc <main+0x8c>
mov    $0x0,%al
call   1050 <getche@plt>
mov    %al,%cl
movslq -0x64(%rbp),%rax
mov    %cl,-0x5a(%rbp,%rax,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11d3 <main+0x63>
lea    0xe7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x55(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x4,%rax
je     1232 <main+0xc2>
lea    0xe5c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %edi,%edi
call   1090 <exit@plt>
movl   $0xffffffff,-0x94(%rbp)
ff ff ff
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    1367 <main+0x1f7>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    1273 <main+0x103>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1354 <main+0x1e4>
movslq -0x64(%rbp),%rax
movsbl -0x55(%rbp,%rax,1),%eax
movslq -0x68(%rbp),%rcx
movsbl -0x50(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    12e2 <main+0x172>
mov    -0x68(%rbp),%eax
mov    %eax,-0xd4(%rbp)
movslq -0x94(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xe0(%rbp)
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0xe0(%rbp),%rax
mov    %edx,%ecx
mov    -0xd4(%rbp),%edx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x64(%rbp),%rax
movsbl -0x5a(%rbp,%rax,1),%eax
movslq -0x68(%rbp),%rcx
movsbl -0x50(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    1341 <main+0x1d1>
mov    -0x68(%rbp),%eax
mov    %eax,-0xe4(%rbp)
movslq -0x94(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0xf0(%rbp)
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0xf0(%rbp),%rax
mov    %edx,%ecx
mov    -0xe4(%rbp),%edx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1346 <main+0x1d6>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    127a <main+0x10a>
jmp    1359 <main+0x1e9>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1243 <main+0xd3>
movl   $0x0,-0x64(%rbp)
cmpl   $0x2,-0x64(%rbp)
jge    13c7 <main+0x257>
movl   $0x0,-0x68(%rbp)
cmpl   $0x2,-0x68(%rbp)
jge    13b4 <main+0x244>
movslq -0x64(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    137f <main+0x20f>
jmp    13b9 <main+0x249>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    136e <main+0x1fe>
lea    0xcdd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x2,-0x64(%rbp)
jge    14e6 <main+0x376>
movl   $0x0,-0x68(%rbp)
cmpl   $0x2,-0x68(%rbp)
jge    14d3 <main+0x363>
movl   $0x0,-0x6c(%rbp)
cmpl   $0x2,-0x6c(%rbp)
jge    1462 <main+0x2f2>
movslq -0x64(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x6c(%rbp),%rcx
lea    -0x80(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
movslq -0x64(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13fe <main+0x28e>
movslq -0x64(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x60(%rbp)
movslq -0x64(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movslq -0x64(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movsbl -0x50(%rbp,%rax,1),%esi
lea    0xbfc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ed <main+0x27d>
jmp    14d8 <main+0x368>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13dc <main+0x26c>
lea    0xb90(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x90(%rbp),%eax
imul   -0x84(%rbp),%eax
mov    -0x8c(%rbp),%ecx
imul   -0x88(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
movl   $0xffffffff,-0x64(%rbp)
movl   $0x1,-0x68(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0xb8(%rbp)
cmpl   $0x0,-0x94(%rbp)
jge    154b <main+0x3db>
xor    %eax,%eax
sub    -0x94(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%edi
mov    -0x60(%rbp),%esi
mov    $0x0,%al
call   1080 <gcd@plt>
cmp    $0x0,%eax
jne    1572 <main+0x402>
lea    0xb52(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1577 <main+0x407>
mov    -0x94(%rbp),%eax
imul   -0x64(%rbp),%eax
cltd
idivl  -0x60(%rbp)
cmp    $0x1,%edx
jne    159c <main+0x42c>
mov    -0x64(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    15d8 <main+0x468>
mov    -0x64(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
mov    -0x94(%rbp),%eax
imul   -0x68(%rbp),%eax
cltd
idivl  -0x60(%rbp)
cmp    $0x1,%edx
jne    15ca <main+0x45a>
mov    -0x68(%rbp),%eax
mov    %eax,-0xb4(%rbp)
jmp    15d8 <main+0x468>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1577 <main+0x407>
mov    -0x84(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x90(%rbp)
xor    %eax,%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0x8c(%rbp)
xor    %eax,%eax
sub    -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
lea    0xac0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x64(%rbp)
cmpl   $0x2,-0x64(%rbp)
jge    17a8 <main+0x638>
movl   $0x0,-0x68(%rbp)
cmpl   $0x2,-0x68(%rbp)
jge    1795 <main+0x625>
movslq -0x64(%rbp),%rcx
lea    -0xd0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x6c(%rbp)
cmpl   $0x2,-0x6c(%rbp)
jge    16da <main+0x56a>
movslq -0x64(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x6c(%rbp),%rcx
lea    -0xb0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
imul   -0xb4(%rbp),%edx
movslq -0x64(%rbp),%rcx
lea    -0xd0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    166c <main+0x4fc>
movslq -0x64(%rbp),%rcx
lea    -0xd0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    174f <main+0x5df>
mov    -0x60(%rbp),%eax
mov    %eax,-0xf4(%rbp)
movslq -0x64(%rbp),%rax
lea    -0xd0(%rbp),%rcx
shl    $0x3,%rax
add    %rax,%rcx
movslq -0x68(%rbp),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
cltd
idivl  -0x60(%rbp)
mov    -0xf4(%rbp),%eax
sub    %edx,%eax
mov    %eax,-0x94(%rbp)
movslq -0x94(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%esi
lea    0x977(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1782 <main+0x612>
movslq -0x64(%rbp),%rcx
lea    -0xd0(%rbp),%rax
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cltd
idivl  -0x60(%rbp)
movslq %edx,%rax
movsbl -0x50(%rbp,%rax,1),%esi
lea    0x93f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1787 <main+0x617>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    163e <main+0x4ce>
jmp    179a <main+0x62a>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    162d <main+0x4bd>
xor    %eax,%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
lea    0xeaa(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xeaf(%rip),%rdi
lea    0x1b(%rsp),%r12
mov    %r12,%rsi
xor    %eax,%eax
call   1080 <scanf@plt>
lea    0xe9c(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %eax,%eax
call   1070 <getche@plt>
mov    %eax,%r13d
xor    %eax,%eax
call   1070 <getche@plt>
mov    %eax,%r14d
xor    %eax,%eax
call   1070 <getche@plt>
mov    %eax,0xc(%rsp)
xor    %eax,%eax
call   1070 <getche@plt>
mov    %eax,0x20(%rsp)
lea    0xecf(%rip),%rdi
call   1040 <puts@plt>
mov    %r12,%rdi
call   1050 <strlen@plt>
cmp    $0x4,%rax
jne    1784 <main+0x604>
mov    0x1b(%rsp),%al
xor    %ecx,%ecx
lea    0xdeb(%rip),%r8
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx,%r8,1),%edx
movzbl 0x1(%rcx,%r8,1),%ebx
cmp    %dl,%al
cmove  %ecx,%r15d
cmp    %r13b,%dl
cmove  %ecx,%ebp
lea    0x1(%rcx),%edx
cmp    %bl,%al
cmove  %edx,%r15d
cmp    %r13b,%bl
cmove  %edx,%ebp
movzbl 0x2(%rcx,%r8,1),%edx
lea    0x2(%rcx),%esi
cmp    %dl,%al
cmove  %esi,%r15d
cmp    %r13b,%dl
cmove  %esi,%ebp
add    $0x3,%rcx
cmp    $0x3f,%rcx
jne    1220 <main+0xa0>
mov    0x1c(%rsp),%al
xor    %ecx,%ecx
mov    0xc(%rsp),%r9d
movzbl (%rcx,%r8,1),%edx
movzbl 0x1(%rcx,%r8,1),%ebx
cmp    %dl,%al
cmove  %ecx,%r13d
cmp    %r14b,%dl
cmove  %ecx,%edi
lea    0x1(%rcx),%edx
cmp    %bl,%al
cmove  %edx,%r13d
cmp    %r14b,%bl
cmove  %edx,%edi
movzbl 0x2(%rcx,%r8,1),%edx
lea    0x2(%rcx),%esi
cmp    %dl,%al
cmove  %esi,%r13d
cmp    %r14b,%dl
cmove  %esi,%edi
add    $0x3,%rcx
cmp    $0x3f,%rcx
jne    1270 <main+0xf0>
mov    %ebp,0x10(%rsp)
mov    0x1d(%rsp),%al
xor    %ecx,%ecx
nop
movzbl (%rcx,%r8,1),%edx
movzbl 0x1(%rcx,%r8,1),%ebx
cmp    %dl,%al
cmove  %ecx,%r14d
cmp    %r9b,%dl
cmove  %ecx,%ebp
lea    0x1(%rcx),%edx
cmp    %bl,%al
cmove  %edx,%r14d
cmp    %r9b,%bl
cmove  %edx,%ebp
movzbl 0x2(%rcx,%r8,1),%edx
lea    0x2(%rcx),%esi
cmp    %dl,%al
cmove  %esi,%r14d
cmp    %r9b,%dl
cmove  %esi,%ebp
add    $0x3,%rcx
cmp    $0x3f,%rcx
jne    12c0 <main+0x140>
mov    %edi,0xc(%rsp)
mov    %ebp,0x14(%rsp)
mov    0x1e(%rsp),%al
xor    %ecx,%ecx
mov    0x20(%rsp),%edi
nopw   0x0(%rax,%rax,1)
movzbl (%rcx,%r8,1),%edx
movzbl 0x1(%rcx,%r8,1),%ebx
cmp    %dl,%al
cmove  %ecx,%ebp
cmp    %dil,%dl
cmove  %ecx,%r12d
lea    0x1(%rcx),%edx
cmp    %bl,%al
cmove  %edx,%ebp
cmp    %dil,%bl
cmove  %edx,%r12d
movzbl 0x2(%rcx,%r8,1),%edx
lea    0x2(%rcx),%esi
cmp    %dl,%al
cmove  %esi,%ebp
cmp    %dil,%dl
cmove  %esi,%r12d
add    $0x3,%rcx
cmp    $0x3f,%rcx
jne    1320 <main+0x1a0>
lea    0xd11(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r15d,%eax
mov    0x10(%rsp),%ecx
imul   %ecx,%eax
mov    %ecx,%ebx
mov    %r14d,%ecx
imul   0xc(%rsp),%ecx
add    %eax,%ecx
movslq %ecx,%rax
imul   $0xffffffff82082083,%rax,%rdx
shr    $0x20,%rdx
add    %eax,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
sar    $0x5,%edx
add    %ecx,%edx
mov    %edx,%ecx
shl    $0x6,%ecx
sub    %ecx,%edx
add    %eax,%edx
mov    %rdx,0x20(%rsp)
movslq %edx,%rax
lea    0xc45(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
mov    %r13d,%eax
imul   %ebx,%eax
mov    %ebp,%ecx
imul   0xc(%rsp),%ecx
add    %eax,%ecx
movslq %ecx,%rax
imul   $0xffffffff82082083,%rax,%rdx
shr    $0x20,%rdx
add    %eax,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
sar    $0x5,%edx
add    %ecx,%edx
mov    %edx,%ecx
shl    $0x6,%ecx
sub    %ecx,%edx
add    %eax,%edx
mov    %rdx,0x28(%rsp)
movslq %edx,%rax
lea    0xbfb(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
mov    0x14(%rsp),%ebx
imul   %ebx,%r15d
imul   %r12d,%r14d
add    %r15d,%r14d
movslq %r14d,%rax
imul   $0xffffffff82082083,%rax,%r15
shr    $0x20,%r15
add    %eax,%r15d
mov    %r15d,%ecx
shr    $0x1f,%ecx
sar    $0x5,%r15d
add    %ecx,%r15d
mov    %r15d,%ecx
shl    $0x6,%ecx
sub    %ecx,%r15d
add    %eax,%r15d
movslq %r15d,%rax
lea    0xbaf(%rip),%r14
movsbl (%rax,%r14,1),%edi
call   1030 <putchar@plt>
imul   %ebx,%r13d
imul   %r12d,%ebp
add    %r13d,%ebp
movslq %ebp,%rax
imul   $0xffffffff82082083,%rax,%rdx
shr    $0x20,%rdx
add    %eax,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
sar    $0x5,%edx
add    %ecx,%edx
mov    %edx,%ecx
shl    $0x6,%ecx
sub    %ecx,%edx
add    %eax,%edx
mov    %rdx,0x30(%rsp)
movslq %edx,%rax
movsbl (%rax,%r14,1),%edi
call   1030 <putchar@plt>
lea    0xc1e(%rip),%rdi
call   1040 <puts@plt>
mov    %r12d,%r13d
imul   0x10(%rsp),%r13d
mov    %ebx,%r14d
imul   0xc(%rsp),%r14d
mov    %r13d,%ebp
sub    %r14d,%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
mov    $0x3f,%esi
xor    %eax,%eax
call   1090 <gcd@plt>
test   %eax,%eax
jne    14e4 <main+0x364>
lea    0xbaf(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movslq %ebp,%rax
imul   $0xffffffff82082083,%rax,%rax
shr    $0x20,%rax
add    %ebp,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
sar    $0x5,%eax
add    %ecx,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
add    %ebp,%eax
cmp    $0xffffffff,%eax
je     158d <main+0x40d>
lea    (%r14,%r14,1),%eax
sub    %r13d,%eax
sub    %r13d,%eax
sub    %r13d,%r14d
mov    $0xffffffff,%r13d
mov    $0x1,%ecx
mov    %ebp,%edx
nopw   0x0(%rax,%rax,1)
movslq %edx,%rsi
imul   $0xffffffff82082083,%rsi,%rdi
shr    $0x20,%rdi
add    %esi,%edi
mov    %edi,%ebx
shr    $0x1f,%ebx
sar    $0x5,%edi
add    %ebx,%edi
mov    %edi,%ebx
shl    $0x6,%ebx
sub    %ebx,%edi
add    %esi,%edi
cmp    $0x1,%edi
je     1595 <main+0x415>
add    $0xffffffff,%r13d
add    $0x1,%ecx
cltq
imul   $0xffffffff82082083,%rax,%rsi
shr    $0x20,%rsi
add    %eax,%esi
mov    %esi,%edi
shr    $0x1f,%edi
sar    $0x5,%esi
add    %edi,%esi
mov    %esi,%edi
shl    $0x6,%edi
sub    %edi,%esi
add    %eax,%esi
add    %ebp,%edx
add    %r14d,%eax
cmp    $0x1,%esi
jne    1530 <main+0x3b0>
jmp    1598 <main+0x418>
mov    $0xffffffff,%r13d
jmp    1598 <main+0x418>
mov    %ecx,%r13d
lea    0xb0f(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
imul   %r13d,%r12d
mov    %r12d,%ecx
imul   0x20(%rsp),%ecx
mov    0xc(%rsp),%ebx
imul   %r13d,%ebx
neg    %ebx
mov    %r15d,%eax
imul   %ebx,%eax
add    %ecx,%eax
js     15e9 <main+0x469>
mov    %eax,%ecx
imul   $0x4104105,%rcx,%rdx
shr    $0x20,%rdx
mov    %eax,%ecx
sub    %edx,%ecx
shr    %ecx
add    %edx,%ecx
shr    $0x5,%ecx
mov    %ecx,%edx
shl    $0x6,%edx
sub    %edx,%ecx
add    %eax,%ecx
jmp    160d <main+0x48d>
mov    %eax,%ecx
neg    %ecx
imul   $0x4104105,%rcx,%rdx
shr    $0x20,%rdx
sub    %edx,%ecx
shr    %ecx
add    %edx,%ecx
shr    $0x5,%ecx
mov    %ecx,%edx
shl    $0x6,%edx
sub    %edx,%ecx
sub    %eax,%ecx
xor    $0x3f,%ecx
lea    0x9ec(%rip),%rdx
mov    0x14(%rsp),%ebp
mov    0x28(%rsp),%r14
mov    %ecx,%eax
movsbl (%rax,%rdx,1),%edi
call   1030 <putchar@plt>
imul   %r14d,%r12d
imul   0x30(%rsp),%ebx
add    %r12d,%ebx
js     1659 <main+0x4d9>
mov    %ebx,%eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
mov    %ebx,%eax
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
add    %ebx,%eax
jmp    167d <main+0x4fd>
mov    %ebx,%eax
neg    %eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
sub    %ebx,%eax
xor    $0x3f,%eax
mov    0x10(%rsp),%ebx
mov    %eax,%eax
lea    0x976(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
imul   %r13d,%ebp
neg    %ebp
mov    0x20(%rsp),%rax
imul   %ebp,%eax
imul   %r13d,%ebx
imul   %ebx,%r15d
add    %eax,%r15d
js     16d4 <main+0x554>
mov    %r15d,%eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
mov    %r15d,%eax
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
add    %r15d,%eax
jmp    16fa <main+0x57a>
mov    %r15d,%eax
neg    %eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
sub    %r15d,%eax
xor    $0x3f,%eax
mov    %eax,%eax
lea    0x8fd(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
imul   %ebp,%r14d
imul   0x30(%rsp),%ebx
add    %r14d,%ebx
js     173d <main+0x5bd>
mov    %ebx,%eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
mov    %ebx,%eax
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
add    %ebx,%eax
jmp    1761 <main+0x5e1>
mov    %ebx,%eax
neg    %eax
imul   $0x4104105,%rax,%rcx
shr    $0x20,%rcx
sub    %ecx,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
sub    %ebx,%eax
xor    $0x3f,%eax
mov    %eax,%eax
lea    0x896(%rip),%rcx
movsbl (%rax,%rcx,1),%edi
call   1030 <putchar@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x937(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   10a0 <exit@plt>

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

LLVM IR (-O2):
@__const.main.lang = [63 x i8] c"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "
@.str = [19 x i8] c"Enter Plain Text: \00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [40 x i8] c"Enter Key Of Length 4 Of Prime Numbers:\00"
@.str.5 = [15 x i8] c"\0ACipher Text: \00"
@.str.7 = [34 x i8] c"Key Is Not Good, Try Another Key.\00"
@.str.8 = [18 x i8] c"\0ADecrypted Text: \00"
@str.9 = [2 x i8] c"\0A\00"
@str.10 = [42 x i8] c"Length Of Plain Text Should Be Equal To 4\00"
define i32 @main() {
%1 = alloca [5 x i8]
%2 = getelementptr inbounds [5 x i8], [5 x i8]* %1, i64 0, i64 0
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0))
%4 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %2)
%5 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.2, i64 0, i64 0))
%6 = call i32 (...) @getche()
%7 = trunc i32 %6 to i8
%8 = call i32 (...) @getche()
%9 = trunc i32 %8 to i8
%10 = call i32 (...) @getche()
%11 = trunc i32 %10 to i8
%12 = call i32 (...) @getche()
%13 = trunc i32 %12 to i8
%14 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.9, i64 0, i64 0))
%15 = call i64 @strlen(i8* %2)
%16 = icmp eq i64 %15, 4
br i1 %16, label %17, label %19
17: ; preds = %0
%18 = load i8, i8* %2
br label %171
19: ; preds = %0
%20 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.10, i64 0, i64 0))
unreachable
21: ; preds = %171
%22 = getelementptr inbounds [5 x i8], [5 x i8]* %1, i64 0, i64 1
%23 = load i8, i8* %22
br label %24
24: ; preds = %24, %21
%25 = phi i32 [ undef, %21 ], [ %50, %24 ]
%26 = phi i32 [ undef, %21 ], [ %53, %24 ]
%27 = phi i64 [ 0, %21 ], [ %54, %24 ]
%28 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %27
%29 = load i8, i8* %28
%30 = icmp eq i8 %23, %29
%31 = trunc i64 %27 to i32
%32 = select i1 %30, i32 %31, i32 %25
%33 = icmp eq i8 %29, %9
%34 = trunc i64 %27 to i32
%35 = select i1 %33, i32 %34, i32 %26
%36 = add nuw nsw i64 %27, 1
%37 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %36
%38 = load i8, i8* %37
%39 = icmp eq i8 %23, %38
%40 = trunc i64 %36 to i32
%41 = select i1 %39, i32 %40, i32 %32
%42 = icmp eq i8 %38, %9
%43 = trunc i64 %36 to i32
%44 = select i1 %42, i32 %43, i32 %35
%45 = add nuw nsw i64 %27, 2
%46 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %45
%47 = load i8, i8* %46
%48 = icmp eq i8 %23, %47
%49 = trunc i64 %45 to i32
%50 = select i1 %48, i32 %49, i32 %41
%51 = icmp eq i8 %47, %9
%52 = trunc i64 %45 to i32
%53 = select i1 %51, i32 %52, i32 %44
%54 = add nuw nsw i64 %27, 3
%55 = icmp eq i64 %54, 63
br i1 %55, label %56, label %24
56: ; preds = %24
%57 = getelementptr inbounds [5 x i8], [5 x i8]* %1, i64 0, i64 2
%58 = load i8, i8* %57
br label %59
59: ; preds = %59, %56
%60 = phi i32 [ undef, %56 ], [ %85, %59 ]
%61 = phi i32 [ undef, %56 ], [ %88, %59 ]
%62 = phi i64 [ 0, %56 ], [ %89, %59 ]
%63 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = icmp eq i8 %58, %64
%66 = trunc i64 %62 to i32
%67 = select i1 %65, i32 %66, i32 %60
%68 = icmp eq i8 %64, %11
%69 = trunc i64 %62 to i32
%70 = select i1 %68, i32 %69, i32 %61
%71 = add nuw nsw i64 %62, 1
%72 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = icmp eq i8 %58, %73
%75 = trunc i64 %71 to i32
%76 = select i1 %74, i32 %75, i32 %67
%77 = icmp eq i8 %73, %11
%78 = trunc i64 %71 to i32
%79 = select i1 %77, i32 %78, i32 %70
%80 = add nuw nsw i64 %62, 2
%81 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = icmp eq i8 %58, %82
%84 = trunc i64 %80 to i32
%85 = select i1 %83, i32 %84, i32 %76
%86 = icmp eq i8 %82, %11
%87 = trunc i64 %80 to i32
%88 = select i1 %86, i32 %87, i32 %79
%89 = add nuw nsw i64 %62, 3
%90 = icmp eq i64 %89, 63
br i1 %90, label %91, label %59
91: ; preds = %59
%92 = getelementptr inbounds [5 x i8], [5 x i8]* %1, i64 0, i64 3
%93 = load i8, i8* %92
br label %94
94: ; preds = %94, %91
%95 = phi i32 [ undef, %91 ], [ %120, %94 ]
%96 = phi i32 [ undef, %91 ], [ %123, %94 ]
%97 = phi i64 [ 0, %91 ], [ %124, %94 ]
%98 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %97
%99 = load i8, i8* %98
%100 = icmp eq i8 %93, %99
%101 = trunc i64 %97 to i32
%102 = select i1 %100, i32 %101, i32 %95
%103 = icmp eq i8 %99, %13
%104 = trunc i64 %97 to i32
%105 = select i1 %103, i32 %104, i32 %96
%106 = add nuw nsw i64 %97, 1
%107 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %106
%108 = load i8, i8* %107
%109 = icmp eq i8 %93, %108
%110 = trunc i64 %106 to i32
%111 = select i1 %109, i32 %110, i32 %102
%112 = icmp eq i8 %108, %13
%113 = trunc i64 %106 to i32
%114 = select i1 %112, i32 %113, i32 %105
%115 = add nuw nsw i64 %97, 2
%116 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = icmp eq i8 %93, %117
%119 = trunc i64 %115 to i32
%120 = select i1 %118, i32 %119, i32 %111
%121 = icmp eq i8 %117, %13
%122 = trunc i64 %115 to i32
%123 = select i1 %121, i32 %122, i32 %114
%124 = add nuw nsw i64 %97, 3
%125 = icmp eq i64 %124, 63
br i1 %125, label %126, label %94
126: ; preds = %94
%127 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.5, i64 0, i64 0))
%128 = mul nsw i32 %197, %200
%129 = mul nsw i32 %85, %53
%130 = add nsw i32 %128, %129
%131 = srem i32 %130, 63
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %132
%134 = load i8, i8* %133
%135 = sext i8 %134 to i32
%136 = call i32 @putchar(i32 %135)
%137 = mul nsw i32 %50, %200
%138 = mul nsw i32 %120, %53
%139 = add nsw i32 %137, %138
%140 = srem i32 %139, 63
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %141
%143 = load i8, i8* %142
%144 = sext i8 %143 to i32
%145 = call i32 @putchar(i32 %144)
%146 = mul nsw i32 %197, %88
%147 = mul nsw i32 %85, %123
%148 = add nsw i32 %146, %147
%149 = srem i32 %148, 63
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %150
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = call i32 @putchar(i32 %153)
%155 = mul nsw i32 %50, %88
%156 = mul nsw i32 %120, %123
%157 = add nsw i32 %155, %156
%158 = srem i32 %157, 63
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = sext i8 %161 to i32
%163 = call i32 @putchar(i32 %162)
%164 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.9, i64 0, i64 0))
%165 = mul nsw i32 %123, %200
%166 = mul nsw i32 %88, %53
%167 = sub nsw i32 %165, %166
%168 = call i32 @llvm.abs.i32(i32 %167, i1 true)
%169 = call i32 (i32, i32, ...) bitcast (i32 (...)* @gcd to i32 (i32, i32, ...)*)(i32 %168, i32 63)
%170 = icmp eq i32 %169, 0
br i1 %170, label %203, label %205
171: ; preds = %171, %17
%172 = phi i32 [ undef, %17 ], [ %197, %171 ]
%173 = phi i32 [ undef, %17 ], [ %200, %171 ]
%174 = phi i64 [ 0, %17 ], [ %201, %171 ]
%175 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %174
%176 = load i8, i8* %175
%177 = icmp eq i8 %18, %176
%178 = trunc i64 %174 to i32
%179 = select i1 %177, i32 %178, i32 %172
%180 = icmp eq i8 %176, %7
%181 = trunc i64 %174 to i32
%182 = select i1 %180, i32 %181, i32 %173
%183 = add nuw nsw i64 %174, 1
%184 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %183
%185 = load i8, i8* %184
%186 = icmp eq i8 %18, %185
%187 = trunc i64 %183 to i32
%188 = select i1 %186, i32 %187, i32 %179
%189 = icmp eq i8 %185, %7
%190 = trunc i64 %183 to i32
%191 = select i1 %189, i32 %190, i32 %182
%192 = add nuw nsw i64 %174, 2
%193 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %192
%194 = load i8, i8* %193
%195 = icmp eq i8 %18, %194
%196 = trunc i64 %192 to i32
%197 = select i1 %195, i32 %196, i32 %188
%198 = icmp eq i8 %194, %7
%199 = trunc i64 %192 to i32
%200 = select i1 %198, i32 %199, i32 %191
%201 = add nuw nsw i64 %174, 3
%202 = icmp eq i64 %201, 63
br i1 %202, label %21, label %171
203: ; preds = %126
%204 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.7, i64 0, i64 0))
br label %205
205: ; preds = %203, %126
%206 = srem i32 %167, 63
%207 = icmp eq i32 %206, -1
br i1 %207, label %220, label %208
208: ; preds = %205, %214
%209 = phi i32 [ %216, %214 ], [ 1, %205 ]
%210 = phi i32 [ %215, %214 ], [ -1, %205 ]
%211 = mul nsw i32 %209, %167
%212 = srem i32 %211, 63
%213 = icmp eq i32 %212, 1
br i1 %213, label %220, label %214
214: ; preds = %208
%215 = add nsw i32 %210, -1
%216 = add nuw nsw i32 %209, 1
%217 = mul nsw i32 %215, %167
%218 = srem i32 %217, 63
%219 = icmp eq i32 %218, 1
br i1 %219, label %220, label %208
220: ; preds = %214, %208, %205
%221 = phi i32 [ -1, %205 ], [ %209, %208 ], [ %215, %214 ]
%222 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.8, i64 0, i64 0))
%223 = mul i32 %123, %221
%224 = mul i32 %223, %131
%225 = mul i32 %53, %221
%226 = sub i32 0, %225
%227 = mul i32 %149, %226
%228 = add nsw i32 %227, %224
%229 = icmp slt i32 %228, 0
br i1 %229, label %230, label %234
230: ; preds = %220
%231 = sub i32 0, %228
%232 = urem i32 %231, 63
%233 = xor i32 %232, 63
br label %236
234: ; preds = %220
%235 = urem i32 %228, 63
br label %236
236: ; preds = %230, %234
%237 = phi i32 [ %233, %230 ], [ %235, %234 ]
%238 = zext i32 %237 to i64
%239 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %238
%240 = load i8, i8* %239
%241 = sext i8 %240 to i32
%242 = call i32 @putchar(i32 %241)
%243 = mul i32 %223, %140
%244 = mul i32 %158, %226
%245 = add nsw i32 %244, %243
%246 = icmp slt i32 %245, 0
br i1 %246, label %249, label %247
247: ; preds = %236
%248 = urem i32 %245, 63
br label %253
249: ; preds = %236
%250 = sub i32 0, %245
%251 = urem i32 %250, 63
%252 = xor i32 %251, 63
br label %253
253: ; preds = %249, %247
%254 = phi i32 [ %252, %249 ], [ %248, %247 ]
%255 = zext i32 %254 to i64
%256 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %255
%257 = load i8, i8* %256
%258 = sext i8 %257 to i32
%259 = call i32 @putchar(i32 %258)
%260 = mul i32 %88, %221
%261 = sub i32 0, %260
%262 = mul i32 %131, %261
%263 = mul i32 %200, %221
%264 = mul i32 %263, %149
%265 = add nsw i32 %264, %262
%266 = icmp slt i32 %265, 0
br i1 %266, label %269, label %267
267: ; preds = %253
%268 = urem i32 %265, 63
br label %273
269: ; preds = %253
%270 = sub i32 0, %265
%271 = urem i32 %270, 63
%272 = xor i32 %271, 63
br label %273
273: ; preds = %269, %267
%274 = phi i32 [ %272, %269 ], [ %268, %267 ]
%275 = zext i32 %274 to i64
%276 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %275
%277 = load i8, i8* %276
%278 = sext i8 %277 to i32
%279 = call i32 @putchar(i32 %278)
%280 = mul i32 %140, %261
%281 = mul i32 %263, %158
%282 = add nsw i32 %281, %280
%283 = icmp slt i32 %282, 0
br i1 %283, label %286, label %284
284: ; preds = %273
%285 = urem i32 %282, 63
br label %290
286: ; preds = %273
%287 = sub i32 0, %282
%288 = urem i32 %287, 63
%289 = xor i32 %288, 63
br label %290
290: ; preds = %286, %284
%291 = phi i32 [ %289, %286 ], [ %285, %284 ]
%292 = zext i32 %291 to i64
%293 = getelementptr inbounds [63 x i8], [63 x i8]* @__const.main.lang, i64 0, i64 %292
%294 = load i8, i8* %293
%295 = sext i8 %294 to i32
%296 = call i32 @putchar(i32 %295)
ret i32 0
}