#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*/ des_decipher(unsigned char *, unsigned char *,
                                unsigned char *);
int /*<<< orphan*/ des_encipher(unsigned char *, unsigned char *,
                                unsigned char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ stdout;
int main(int argc, char **argv) {
  unsigned char destmp[8], desptx[8], desctx[8], deskey[8];
  int i;
  fprintf(stdout, "Enciphering with DES\n");
  destmp[0] = 0xa9;
  destmp[1] = 0x10;
  destmp[2] = 0x11;
  destmp[3] = 0x38;
  destmp[4] = 0x93;
  destmp[5] = 0xca;
  destmp[6] = 0xb4;
  destmp[7] = 0xa1;
  deskey[0] = 0x01;
  deskey[1] = 0x1f;
  deskey[2] = 0x01;
  deskey[3] = 0x1f;
  deskey[4] = 0x01;
  deskey[5] = 0x0e;
  deskey[6] = 0x01;
  deskey[7] = 0x0e;
  fprintf(stdout, "Before enciphering\n");
  fprintf(stdout, "destmp: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          destmp[0], destmp[1], destmp[2], destmp[3], destmp[4], destmp[5],
          destmp[6], destmp[7]);
  fprintf(stdout, "deskey: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          deskey[0], deskey[1], deskey[2], deskey[3], deskey[4], deskey[5],
          deskey[6], deskey[7]);
  des_encipher(destmp, desctx, deskey);
  fprintf(stdout, "After enciphering\n");
  fprintf(stdout, "destmp: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          destmp[0], destmp[1], destmp[2], destmp[3], destmp[4], destmp[5],
          destmp[6], destmp[7]);
  fprintf(stdout, "desctx: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          desctx[0], desctx[1], desctx[2], desctx[3], desctx[4], desctx[5],
          desctx[6], desctx[7]);
  fprintf(stdout, "Before deciphering\n");
  fprintf(stdout, "desctx: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          desctx[0], desctx[1], desctx[2], desctx[3], desctx[4], desctx[5],
          desctx[6], desctx[7]);
  fprintf(stdout, "deskey: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          deskey[0], deskey[1], deskey[2], deskey[3], deskey[4], deskey[5],
          deskey[6], deskey[7]);
  des_decipher(desctx, desptx, deskey);
  fprintf(stdout, "After deciphering\n");
  fprintf(stdout, "desctx: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          desctx[0], desctx[1], desctx[2], desctx[3], desctx[4], desctx[5],
          desctx[6], desctx[7]);
  fprintf(stdout, "desptx: %02x %02x %02x %02x %02x %02x %02x %02x\n",
          desptx[0], desptx[1], desptx[2], desptx[3], desptx[4], desptx[5],
          desptx[6], desptx[7]);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x58,%rsp
movl   $0x0,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    0x2e92(%rip),%rax
mov    (%rax),%edi
lea    0xea9(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
movb   $0xa9,-0x20(%rbp)
movb   $0x10,-0x1f(%rbp)
movb   $0x11,-0x1e(%rbp)
movb   $0x38,-0x1d(%rbp)
movb   $0x93,-0x1c(%rbp)
movb   $0xca,-0x1b(%rbp)
movb   $0xb4,-0x1a(%rbp)
movb   $0xa1,-0x19(%rbp)
movb   $0x1,-0x38(%rbp)
movb   $0x1f,-0x37(%rbp)
movb   $0x1,-0x36(%rbp)
movb   $0x1f,-0x35(%rbp)
movb   $0x1,-0x34(%rbp)
movb   $0xe,-0x33(%rbp)
movb   $0x1,-0x32(%rbp)
movb   $0xe,-0x31(%rbp)
mov    0x2e3b(%rip),%rax
mov    (%rax),%edi
lea    0xe68(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2e24(%rip),%rax
mov    (%rax),%edi
movzbl -0x20(%rbp),%edx
movzbl -0x1f(%rbp),%ecx
movzbl -0x1e(%rbp),%r8d
movzbl -0x1d(%rbp),%r9d
movzbl -0x1c(%rbp),%ebx
movzbl -0x1b(%rbp),%r11d
movzbl -0x1a(%rbp),%r10d
movzbl -0x19(%rbp),%eax
lea    0xe41(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2dd8(%rip),%rax
mov    (%rax),%edi
movzbl -0x38(%rbp),%edx
movzbl -0x37(%rbp),%ecx
movzbl -0x36(%rbp),%r8d
movzbl -0x35(%rbp),%r9d
movzbl -0x34(%rbp),%ebx
movzbl -0x33(%rbp),%r11d
movzbl -0x32(%rbp),%r10d
movzbl -0x31(%rbp),%eax
lea    0xe26(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
lea    -0x20(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1040 <des_encipher@plt>
mov    0x2d7b(%rip),%rax
mov    (%rax),%edi
lea    0xe1e(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d64(%rip),%rax
mov    (%rax),%edi
movzbl -0x20(%rbp),%edx
movzbl -0x1f(%rbp),%ecx
movzbl -0x1e(%rbp),%r8d
movzbl -0x1d(%rbp),%r9d
movzbl -0x1c(%rbp),%ebx
movzbl -0x1b(%rbp),%r11d
movzbl -0x1a(%rbp),%r10d
movzbl -0x19(%rbp),%eax
lea    0xd81(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d18(%rip),%rax
mov    (%rax),%edi
movzbl -0x30(%rbp),%edx
movzbl -0x2f(%rbp),%ecx
movzbl -0x2e(%rbp),%r8d
movzbl -0x2d(%rbp),%r9d
movzbl -0x2c(%rbp),%ebx
movzbl -0x2b(%rbp),%r11d
movzbl -0x2a(%rbp),%r10d
movzbl -0x29(%rbp),%eax
lea    0xdaa(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ccc(%rip),%rax
mov    (%rax),%edi
lea    0xdb3(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2cb5(%rip),%rax
mov    (%rax),%edi
movzbl -0x30(%rbp),%edx
movzbl -0x2f(%rbp),%ecx
movzbl -0x2e(%rbp),%r8d
movzbl -0x2d(%rbp),%r9d
movzbl -0x2c(%rbp),%ebx
movzbl -0x2b(%rbp),%r11d
movzbl -0x2a(%rbp),%r10d
movzbl -0x29(%rbp),%eax
lea    0xd47(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2c69(%rip),%rax
mov    (%rax),%edi
movzbl -0x38(%rbp),%edx
movzbl -0x37(%rbp),%ecx
movzbl -0x36(%rbp),%r8d
movzbl -0x35(%rbp),%r9d
movzbl -0x34(%rbp),%ebx
movzbl -0x33(%rbp),%r11d
movzbl -0x32(%rbp),%r10d
movzbl -0x31(%rbp),%eax
lea    0xcb7(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
lea    -0x30(%rbp),%rdi
lea    -0x28(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1050 <des_decipher@plt>
mov    0x2c0c(%rip),%rax
mov    (%rax),%edi
lea    0xd07(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2bf5(%rip),%rax
mov    (%rax),%edi
movzbl -0x30(%rbp),%edx
movzbl -0x2f(%rbp),%ecx
movzbl -0x2e(%rbp),%r8d
movzbl -0x2d(%rbp),%r9d
movzbl -0x2c(%rbp),%ebx
movzbl -0x2b(%rbp),%r11d
movzbl -0x2a(%rbp),%r10d
movzbl -0x29(%rbp),%eax
lea    0xc87(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2ba9(%rip),%rax
mov    (%rax),%edi
movzbl -0x28(%rbp),%edx
movzbl -0x27(%rbp),%ecx
movzbl -0x26(%rbp),%r8d
movzbl -0x25(%rbp),%r9d
movzbl -0x24(%rbp),%ebx
movzbl -0x23(%rbp),%r11d
movzbl -0x22(%rbp),%r10d
movzbl -0x21(%rbp),%eax
lea    0xc93(%rip),%rsi
mov    %ebx,(%rsp)
mov    %r11d,0x8(%rsp)
mov    %r10d,0x10(%rsp)
mov    %eax,0x18(%rsp)
mov    $0x0,%al
call   1030 <fprintf@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    0x2e9b(%rip),%r14
mov    (%r14),%edi
lea    0xeb1(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
movabs $0xa1b4ca93381110a9,%rax
ca b4 a1
mov    %rax,0x18(%rsp)
movabs $0xe010e011f011f01,%rax
0e 01 0e
mov    %rax,0x10(%rsp)
mov    (%r14),%edi
lea    0xe98(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
lea    0xe9b(%rip),%r13
mov    %r13,%rsi
mov    $0xa9,%edx
mov    $0x10,%ecx
mov    $0x11,%r8d
mov    $0x38,%r9d
xor    %eax,%eax
push   $0xa1
push   $0xb4
push   $0xca
push   $0x93
call   1030 <fprintf@plt>
add    $0x20,%rsp
mov    (%r14),%edi
lea    0xe8a(%rip),%r12
mov    %r12,%rsi
mov    $0x1,%edx
mov    $0x1f,%ecx
mov    $0x1,%r8d
mov    $0x1f,%r9d
xor    %eax,%eax
push   $0xe
push   $0x1
push   $0xe
push   $0x1
call   1030 <fprintf@plt>
add    $0x20,%rsp
lea    0x18(%rsp),%rdi
lea    0x8(%rsp),%r15
lea    0x10(%rsp),%rdx
mov    %r15,%rsi
call   1040 <des_encipher@plt>
mov    (%r14),%edi
lea    0xe6e(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
movzbl 0x18(%rsp),%edx
movzbl 0x19(%rsp),%ecx
movzbl 0x1a(%rsp),%r8d
movzbl 0x1b(%rsp),%r9d
movzbl 0x1c(%rsp),%r10d
movzbl 0x1d(%rsp),%r11d
movzbl 0x1e(%rsp),%ebx
movzbl 0x1f(%rsp),%ebp
mov    %r13,%rsi
xor    %eax,%eax
push   %rbp
push   %rbx
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
mov    (%r14),%edi
movzbl 0x8(%rsp),%edx
movzbl 0x9(%rsp),%ecx
movzbl 0xa(%rsp),%r8d
movzbl 0xb(%rsp),%r9d
movzbl 0xc(%rsp),%r10d
movzbl 0xd(%rsp),%r11d
movzbl 0xe(%rsp),%ebp
movzbl 0xf(%rsp),%ebx
lea    0xe01(%rip),%r13
mov    %r13,%rsi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
mov    (%r14),%edi
lea    0xe14(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
movzbl 0x8(%rsp),%edx
movzbl 0x9(%rsp),%ecx
movzbl 0xa(%rsp),%r8d
movzbl 0xb(%rsp),%r9d
movzbl 0xc(%rsp),%r10d
movzbl 0xd(%rsp),%r11d
movzbl 0xe(%rsp),%ebp
movzbl 0xf(%rsp),%ebx
mov    %r13,%rsi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
mov    (%r14),%edi
movzbl 0x10(%rsp),%edx
movzbl 0x11(%rsp),%ecx
movzbl 0x12(%rsp),%r8d
movzbl 0x13(%rsp),%r9d
movzbl 0x14(%rsp),%r10d
movzbl 0x15(%rsp),%r11d
movzbl 0x16(%rsp),%ebp
movzbl 0x17(%rsp),%ebx
mov    %r12,%rsi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
lea    0x20(%rsp),%rsi
mov    %r15,%rdi
lea    0x10(%rsp),%rdx
call   1050 <des_decipher@plt>
mov    (%r14),%edi
lea    0xd7f(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r14),%edi
movzbl 0x8(%rsp),%edx
movzbl 0x9(%rsp),%ecx
movzbl 0xa(%rsp),%r8d
movzbl 0xb(%rsp),%r9d
movzbl 0xc(%rsp),%r10d
movzbl 0xd(%rsp),%r11d
movzbl 0xe(%rsp),%ebp
movzbl 0xf(%rsp),%ebx
mov    %r13,%rsi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
mov    (%r14),%edi
movzbl 0x20(%rsp),%edx
movzbl 0x21(%rsp),%ecx
movzbl 0x22(%rsp),%r8d
movzbl 0x23(%rsp),%r9d
movzbl 0x24(%rsp),%r10d
movzbl 0x25(%rsp),%r11d
movzbl 0x26(%rsp),%ebp
movzbl 0x27(%rsp),%ebx
lea    0xd12(%rip),%rsi
xor    %eax,%eax
push   %rbx
push   %rbp
push   %r11
push   %r10
call   1030 <fprintf@plt>
add    $0x20,%rsp
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stdout = global i32 0
@.str = [22 x i8] c"Enciphering with DES\0A\00"
@.str.1 = [20 x i8] c"Before enciphering\0A\00"
@.str.2 = [49 x i8] c"destmp: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.3 = [49 x i8] c"deskey: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.4 = [19 x i8] c"After enciphering\0A\00"
@.str.5 = [49 x i8] c"desctx: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.6 = [20 x i8] c"Before deciphering\0A\00"
@.str.7 = [19 x i8] c"After deciphering\0A\00"
@.str.8 = [49 x i8] c"desptx: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [8 x i8]
%7 = alloca [8 x i8]
%8 = alloca [8 x i8]
%9 = alloca [8 x i8]
%10 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%11 = load i32, i32* @stdout
%12 = call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
%13 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
store i8 -87, i8* %13
%14 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 1
store i8 16, i8* %14
%15 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
store i8 17, i8* %15
%16 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
store i8 56, i8* %16
%17 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
store i8 -109, i8* %17
%18 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
store i8 -54, i8* %18
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
store i8 -76, i8* %19
%20 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
store i8 -95, i8* %20
%21 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
store i8 1, i8* %21
%22 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 1
store i8 31, i8* %22
%23 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 2
store i8 1, i8* %23
%24 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 3
store i8 31, i8* %24
%25 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 4
store i8 1, i8* %25
%26 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 5
store i8 14, i8* %26
%27 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 6
store i8 1, i8* %27
%28 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 7
store i8 14, i8* %28
%29 = load i32, i32* @stdout
%30 = call i32 (i32, i8*, ...) @fprintf(i32 %29, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0))
%31 = load i32, i32* @stdout
%32 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
%33 = load i8, i8* %32
%34 = zext i8 %33 to i32
%35 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 1
%36 = load i8, i8* %35
%37 = zext i8 %36 to i32
%38 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = call i32 (i32, i8*, ...) @fprintf(i32 %31, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0), i32 %34, i32 %37, i32 %40, i32 %43, i32 %46, i32 %49, i32 %52, i32 %55)
%57 = load i32, i32* @stdout
%58 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 1
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 2
%65 = load i8, i8* %64
%66 = zext i8 %65 to i32
%67 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 3
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 4
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 5
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 6
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 7
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = call i32 (i32, i8*, ...) @fprintf(i32 %57, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.3, i64 0, i64 0), i32 %60, i32 %63, i32 %66, i32 %69, i32 %72, i32 %75, i32 %78, i32 %81)
%83 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
%84 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 0
%85 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%86 = call i32 @des_encipher(i8* %83, i8* %84, i8* %85)
%87 = load i32, i32* @stdout
%88 = call i32 (i32, i8*, ...) @fprintf(i32 %87, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0))
%89 = load i32, i32* @stdout
%90 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 1
%94 = load i8, i8* %93
%95 = zext i8 %94 to i32
%96 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%97 = load i8, i8* %96
%98 = zext i8 %97 to i32
%99 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%100 = load i8, i8* %99
%101 = zext i8 %100 to i32
%102 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%103 = load i8, i8* %102
%104 = zext i8 %103 to i32
%105 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%106 = load i8, i8* %105
%107 = zext i8 %106 to i32
%108 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = call i32 (i32, i8*, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0), i32 %92, i32 %95, i32 %98, i32 %101, i32 %104, i32 %107, i32 %110, i32 %113)
%115 = load i32, i32* @stdout
%116 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 0
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 1
%120 = load i8, i8* %119
%121 = zext i8 %120 to i32
%122 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 2
%123 = load i8, i8* %122
%124 = zext i8 %123 to i32
%125 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 3
%126 = load i8, i8* %125
%127 = zext i8 %126 to i32
%128 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 4
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 5
%132 = load i8, i8* %131
%133 = zext i8 %132 to i32
%134 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 6
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 7
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = call i32 (i32, i8*, ...) @fprintf(i32 %115, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %118, i32 %121, i32 %124, i32 %127, i32 %130, i32 %133, i32 %136, i32 %139)
%141 = load i32, i32* @stdout
%142 = call i32 (i32, i8*, ...) @fprintf(i32 %141, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.6, i64 0, i64 0))
%143 = load i32, i32* @stdout
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 0
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 1
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 2
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 3
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 4
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 5
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 6
%163 = load i8, i8* %162
%164 = zext i8 %163 to i32
%165 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 7
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = call i32 (i32, i8*, ...) @fprintf(i32 %143, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %146, i32 %149, i32 %152, i32 %155, i32 %158, i32 %161, i32 %164, i32 %167)
%169 = load i32, i32* @stdout
%170 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 1
%174 = load i8, i8* %173
%175 = zext i8 %174 to i32
%176 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 2
%177 = load i8, i8* %176
%178 = zext i8 %177 to i32
%179 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 3
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 4
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 5
%186 = load i8, i8* %185
%187 = zext i8 %186 to i32
%188 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 6
%189 = load i8, i8* %188
%190 = zext i8 %189 to i32
%191 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 7
%192 = load i8, i8* %191
%193 = zext i8 %192 to i32
%194 = call i32 (i32, i8*, ...) @fprintf(i32 %169, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.3, i64 0, i64 0), i32 %172, i32 %175, i32 %178, i32 %181, i32 %184, i32 %187, i32 %190, i32 %193)
%195 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 0
%196 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%197 = getelementptr inbounds [8 x i8], [8 x i8]* %9, i64 0, i64 0
%198 = call i32 @des_decipher(i8* %195, i8* %196, i8* %197)
%199 = load i32, i32* @stdout
%200 = call i32 (i32, i8*, ...) @fprintf(i32 %199, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.7, i64 0, i64 0))
%201 = load i32, i32* @stdout
%202 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 0
%203 = load i8, i8* %202
%204 = zext i8 %203 to i32
%205 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 1
%206 = load i8, i8* %205
%207 = zext i8 %206 to i32
%208 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 2
%209 = load i8, i8* %208
%210 = zext i8 %209 to i32
%211 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 3
%212 = load i8, i8* %211
%213 = zext i8 %212 to i32
%214 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 4
%215 = load i8, i8* %214
%216 = zext i8 %215 to i32
%217 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 5
%218 = load i8, i8* %217
%219 = zext i8 %218 to i32
%220 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 6
%221 = load i8, i8* %220
%222 = zext i8 %221 to i32
%223 = getelementptr inbounds [8 x i8], [8 x i8]* %8, i64 0, i64 7
%224 = load i8, i8* %223
%225 = zext i8 %224 to i32
%226 = call i32 (i32, i8*, ...) @fprintf(i32 %201, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %204, i32 %207, i32 %210, i32 %213, i32 %216, i32 %219, i32 %222, i32 %225)
%227 = load i32, i32* @stdout
%228 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%229 = load i8, i8* %228
%230 = zext i8 %229 to i32
%231 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%232 = load i8, i8* %231
%233 = zext i8 %232 to i32
%234 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%235 = load i8, i8* %234
%236 = zext i8 %235 to i32
%237 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%244 = load i8, i8* %243
%245 = zext i8 %244 to i32
%246 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%247 = load i8, i8* %246
%248 = zext i8 %247 to i32
%249 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
%250 = load i8, i8* %249
%251 = zext i8 %250 to i32
%252 = call i32 (i32, i8*, ...) @fprintf(i32 %227, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.8, i64 0, i64 0), i32 %230, i32 %233, i32 %236, i32 %239, i32 %242, i32 %245, i32 %248, i32 %251)
ret i32 0
}

LLVM IR (-O2):
@stdout = global i32 0
@.str = [22 x i8] c"Enciphering with DES\0A\00"
@.str.1 = [20 x i8] c"Before enciphering\0A\00"
@.str.2 = [49 x i8] c"destmp: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.3 = [49 x i8] c"deskey: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.4 = [19 x i8] c"After enciphering\0A\00"
@.str.5 = [49 x i8] c"desctx: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
@.str.6 = [20 x i8] c"Before deciphering\0A\00"
@.str.7 = [19 x i8] c"After deciphering\0A\00"
@.str.8 = [49 x i8] c"desptx: %02x %02x %02x %02x %02x %02x %02x %02x\0A\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [8 x i8]
%4 = alloca [8 x i8]
%5 = alloca [8 x i8]
%6 = alloca [8 x i8]
%7 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 0
%8 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 0
%9 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 0
%10 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
%11 = load i32, i32* @stdout
%12 = tail call i32 (i32, i8*, ...) @fprintf(i32 %11, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str, i64 0, i64 0))
store i8 -87, i8* %7
%13 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 1
store i8 16, i8* %13
%14 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 2
store i8 17, i8* %14
%15 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 3
store i8 56, i8* %15
%16 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 4
store i8 -109, i8* %16
%17 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 5
store i8 -54, i8* %17
%18 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 6
store i8 -76, i8* %18
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %3, i64 0, i64 7
store i8 -95, i8* %19
store i8 1, i8* %10
%20 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 1
store i8 31, i8* %20
%21 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
store i8 1, i8* %21
%22 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
store i8 31, i8* %22
%23 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
store i8 1, i8* %23
%24 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
store i8 14, i8* %24
%25 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
store i8 1, i8* %25
%26 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
store i8 14, i8* %26
%27 = load i32, i32* @stdout
%28 = tail call i32 (i32, i8*, ...) @fprintf(i32 %27, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0))
%29 = load i32, i32* @stdout
%30 = tail call i32 (i32, i8*, ...) @fprintf(i32 %29, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0), i32 169, i32 16, i32 17, i32 56, i32 147, i32 202, i32 180, i32 161)
%31 = load i32, i32* @stdout
%32 = tail call i32 (i32, i8*, ...) @fprintf(i32 %31, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.3, i64 0, i64 0), i32 1, i32 31, i32 1, i32 31, i32 1, i32 14, i32 1, i32 14)
%33 = call i32 @des_encipher(i8* %7, i8* %9, i8* %10)
%34 = load i32, i32* @stdout
%35 = call i32 (i32, i8*, ...) @fprintf(i32 %34, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.4, i64 0, i64 0))
%36 = load i32, i32* @stdout
%37 = load i8, i8* %7
%38 = zext i8 %37 to i32
%39 = load i8, i8* %13
%40 = zext i8 %39 to i32
%41 = load i8, i8* %14
%42 = zext i8 %41 to i32
%43 = load i8, i8* %15
%44 = zext i8 %43 to i32
%45 = load i8, i8* %16
%46 = zext i8 %45 to i32
%47 = load i8, i8* %17
%48 = zext i8 %47 to i32
%49 = load i8, i8* %18
%50 = zext i8 %49 to i32
%51 = load i8, i8* %19
%52 = zext i8 %51 to i32
%53 = call i32 (i32, i8*, ...) @fprintf(i32 %36, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.2, i64 0, i64 0), i32 %38, i32 %40, i32 %42, i32 %44, i32 %46, i32 %48, i32 %50, i32 %52)
%54 = load i32, i32* @stdout
%55 = load i8, i8* %9
%56 = zext i8 %55 to i32
%57 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 1
%58 = load i8, i8* %57
%59 = zext i8 %58 to i32
%60 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 2
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 3
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 4
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 5
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 6
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = getelementptr inbounds [8 x i8], [8 x i8]* %5, i64 0, i64 7
%76 = load i8, i8* %75
%77 = zext i8 %76 to i32
%78 = call i32 (i32, i8*, ...) @fprintf(i32 %54, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %56, i32 %59, i32 %62, i32 %65, i32 %68, i32 %71, i32 %74, i32 %77)
%79 = load i32, i32* @stdout
%80 = call i32 (i32, i8*, ...) @fprintf(i32 %79, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.6, i64 0, i64 0))
%81 = load i32, i32* @stdout
%82 = load i8, i8* %9
%83 = zext i8 %82 to i32
%84 = load i8, i8* %57
%85 = zext i8 %84 to i32
%86 = load i8, i8* %60
%87 = zext i8 %86 to i32
%88 = load i8, i8* %63
%89 = zext i8 %88 to i32
%90 = load i8, i8* %66
%91 = zext i8 %90 to i32
%92 = load i8, i8* %69
%93 = zext i8 %92 to i32
%94 = load i8, i8* %72
%95 = zext i8 %94 to i32
%96 = load i8, i8* %75
%97 = zext i8 %96 to i32
%98 = call i32 (i32, i8*, ...) @fprintf(i32 %81, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %83, i32 %85, i32 %87, i32 %89, i32 %91, i32 %93, i32 %95, i32 %97)
%99 = load i32, i32* @stdout
%100 = load i8, i8* %10
%101 = zext i8 %100 to i32
%102 = load i8, i8* %20
%103 = zext i8 %102 to i32
%104 = load i8, i8* %21
%105 = zext i8 %104 to i32
%106 = load i8, i8* %22
%107 = zext i8 %106 to i32
%108 = load i8, i8* %23
%109 = zext i8 %108 to i32
%110 = load i8, i8* %24
%111 = zext i8 %110 to i32
%112 = load i8, i8* %25
%113 = zext i8 %112 to i32
%114 = load i8, i8* %26
%115 = zext i8 %114 to i32
%116 = call i32 (i32, i8*, ...) @fprintf(i32 %99, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.3, i64 0, i64 0), i32 %101, i32 %103, i32 %105, i32 %107, i32 %109, i32 %111, i32 %113, i32 %115)
%117 = call i32 @des_decipher(i8* %9, i8* %8, i8* %10)
%118 = load i32, i32* @stdout
%119 = call i32 (i32, i8*, ...) @fprintf(i32 %118, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.7, i64 0, i64 0))
%120 = load i32, i32* @stdout
%121 = load i8, i8* %9
%122 = zext i8 %121 to i32
%123 = load i8, i8* %57
%124 = zext i8 %123 to i32
%125 = load i8, i8* %60
%126 = zext i8 %125 to i32
%127 = load i8, i8* %63
%128 = zext i8 %127 to i32
%129 = load i8, i8* %66
%130 = zext i8 %129 to i32
%131 = load i8, i8* %69
%132 = zext i8 %131 to i32
%133 = load i8, i8* %72
%134 = zext i8 %133 to i32
%135 = load i8, i8* %75
%136 = zext i8 %135 to i32
%137 = call i32 (i32, i8*, ...) @fprintf(i32 %120, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.5, i64 0, i64 0), i32 %122, i32 %124, i32 %126, i32 %128, i32 %130, i32 %132, i32 %134, i32 %136)
%138 = load i32, i32* @stdout
%139 = load i8, i8* %8
%140 = zext i8 %139 to i32
%141 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 1
%142 = load i8, i8* %141
%143 = zext i8 %142 to i32
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 2
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 3
%148 = load i8, i8* %147
%149 = zext i8 %148 to i32
%150 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 4
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 5
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 6
%157 = load i8, i8* %156
%158 = zext i8 %157 to i32
%159 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 7
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = call i32 (i32, i8*, ...) @fprintf(i32 %138, i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.8, i64 0, i64 0), i32 %140, i32 %143, i32 %146, i32 %149, i32 %152, i32 %155, i32 %158, i32 %161)
ret i32 0
}