#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 */
struct sockaddr_alg {
  char *salg_type;
  char *salg_name;
  int /*<<< orphan*/ salg_family;
};
struct sockaddr {
  int dummy;
};
struct msghdr {
  char *msg_control;
  int msg_controllen;
  int msg_iovlen;
  struct iovec *msg_iov;
};
struct iovec {
  char *iov_base;
  int iov_len;
};
struct cmsghdr {
  int dummy;
};
struct af_alg_iv {
  int dummy;
};
typedef int /*<<< orphan*/ sa;
typedef int /*<<< orphan*/ cbuf;

/* Variables and functions */
int /*<<< orphan*/ AF_ALG;
int /*<<< orphan*/ ALG_SET_KEY;
int CMSG_SPACE(int);
int /*<<< orphan*/ SOCK_SEQPACKET;
int accept(int, int /*<<< orphan*/ *, int /*<<< orphan*/);
int /*<<< orphan*/ bind(int, struct sockaddr *, int);
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ read(int, char *, int);
int /*<<< orphan*/ sendmsg(int, struct msghdr *, int /*<<< orphan*/);
int /*<<< orphan*/ setsockopt(int, int, int /*<<< orphan*/, char *, int);
int socket(int /*<<< orphan*/, int /*<<< orphan*/, int /*<<< orphan*/);
int main(void) {
  int opfd;
  int tfmfd;
  struct sockaddr_alg sa = {
      .salg_family = AF_ALG, .salg_type = "skcipher", .salg_name = "cbc(aes)"};
  struct msghdr msg = {};
  struct cmsghdr *cmsg;
  char cbuf[CMSG_SPACE(4) + CMSG_SPACE(20)];
  char buf[16] = {0};
  struct af_alg_iv *iv;
  struct iovec iov;
  int i;
  tfmfd = socket(AF_ALG, SOCK_SEQPACKET, 0);
  bind(tfmfd, (struct sockaddr *)&sa, sizeof(sa));
  setsockopt(tfmfd, 279, ALG_SET_KEY,
             "\x06\xa9\x21\x40\x36\xb8\xa1\x5b\x51\x2e\x03\xd5\x34\x12\x00\x06",
             16);
  opfd = accept(tfmfd, NULL, 0);
  msg.msg_control = cbuf;
  msg.msg_controllen = sizeof(cbuf);
  iov.iov_base = "Single block msg";
  iov.iov_len = 16;
  msg.msg_iov = &iov;
  msg.msg_iovlen = 1;
  sendmsg(opfd, &msg, 0);
  read(opfd, buf, 16);
  for (i = 0; i < 16; i++) {
    printf("%02x", (unsigned char)buf[i]);
  }
  printf("\n");
  close(opfd);
  close(tfmfd);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe47(%rip),%rax
mov    %rax,-0x28(%rbp)
lea    0xe45(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0x2e01(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x18(%rbp)
xorps  %xmm0,%xmm0
movaps %xmm0,-0x40(%rbp)
movq   $0x0,-0x30(%rbp)
mov    $0x4,%edi
call   1090 <CMSG_SPACE@plt>
mov    %eax,-0xa4(%rbp)
mov    $0x14,%edi
call   1090 <CMSG_SPACE@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
add    %ecx,%eax
mov    %rax,-0x98(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1060 <memset@plt>
mov    0x2d85(%rip),%rax
mov    (%rax),%edi
mov    0x2d84(%rip),%rax
mov    (%rax),%esi
xor    %edx,%edx
call   10c0 <socket@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%edi
lea    -0x28(%rbp),%rsi
mov    $0x18,%edx
call   10a0 <bind@plt>
mov    -0xc(%rbp),%edi
mov    0x2d6d(%rip),%rax
mov    (%rax),%edx
mov    $0x117,%esi
lea    0xda1(%rip),%rcx
mov    $0x10,%r8d
call   1040 <setsockopt@plt>
mov    -0xc(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   10b0 <accept@plt>
mov    -0xa0(%rbp),%rcx
mov    %eax,%edx
mov    -0x98(%rbp),%rax
mov    %edx,-0x8(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %eax,-0x38(%rbp)
lea    0xd4f(%rip),%rax
mov    %rax,-0x88(%rbp)
movl   $0x10,-0x80(%rbp)
lea    -0x88(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x8(%rbp),%edi
lea    -0x40(%rbp),%rsi
xor    %edx,%edx
call   1030 <sendmsg@plt>
mov    -0x8(%rbp),%edi
lea    -0x70(%rbp),%rsi
mov    $0x10,%edx
call   1080 <read@plt>
movl   $0x0,-0x8c(%rbp)
cmpl   $0x10,-0x8c(%rbp)
jge    1347 <main+0x1a7>
movslq -0x8c(%rbp),%rax
movzbl -0x70(%rbp,%rax,1),%esi
lea    0xcf7(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    130c <main+0x16c>
lea    0xcda(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%edi
call   1070 <close@plt>
mov    -0xc(%rbp),%edi
call   1070 <close@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
lea    0xe48(%rip),%rax
mov    %rax,-0x80(%rbp)
lea    0xe46(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    0x2e02(%rip),%r15
mov    (%r15),%eax
mov    %eax,-0x70(%rbp)
mov    $0x4,%edi
call   1090 <CMSG_SPACE@plt>
mov    %eax,%r14d
mov    $0x14,%edi
call   1090 <CMSG_SPACE@plt>
mov    %eax,%r13d
mov    %rsp,%r12
add    %r14d,%r13d
lea    0xf(%r13),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rbx
sub    %rax,%rbx
mov    %rbx,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,-0x40(%rbp)
mov    (%r15),%edi
mov    0x2dc2(%rip),%rax
mov    (%rax),%esi
xor    %edx,%edx
call   10c0 <socket@plt>
mov    %eax,%r15d
lea    -0x80(%rbp),%rsi
mov    %eax,%edi
mov    $0x18,%edx
call   10a0 <bind@plt>
mov    0x2daf(%rip),%rax
mov    (%rax),%edx
lea    0xde6(%rip),%rcx
mov    %r15d,%edi
mov    $0x117,%esi
mov    $0x10,%r8d
call   1050 <setsockopt@plt>
mov    %r15d,%edi
xor    %esi,%esi
xor    %edx,%edx
call   10b0 <accept@plt>
mov    %eax,%r14d
mov    %rbx,-0x58(%rbp)
mov    %r13d,-0x50(%rbp)
lea    0xd9f(%rip),%rax
mov    %rax,-0x68(%rbp)
movl   $0x10,-0x60(%rbp)
lea    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
lea    -0x58(%rbp),%rsi
mov    %r14d,%edi
xor    %edx,%edx
call   1040 <sendmsg@plt>
lea    -0x40(%rbp),%rsi
mov    %r14d,%edi
mov    $0x10,%edx
call   1080 <read@plt>
movzbl -0x40(%rbp),%esi
lea    0xd6c(%rip),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3f(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3e(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3d(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3c(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3b(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x3a(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x39(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x38(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x37(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x36(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x35(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x34(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x33(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x32(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl -0x31(%rbp),%esi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14d,%edi
call   1070 <close@plt>
mov    %r15d,%edi
call   1070 <close@plt>
mov    %r12,%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.sockaddr_alg = type { i8*, i8*, i32 }
%struct.msghdr = type { i8*, i32, i32, %struct.iovec* }
%struct.iovec = type { i8*, i32 }
%struct.cmsghdr = type { i32 }
%struct.af_alg_iv = type { i32 }
%struct.sockaddr = type { i32 }
@.str = [9 x i8] c"skcipher\00"
@.str.1 = [9 x i8] c"cbc(aes)\00"
@AF_ALG = global i32 0
@SOCK_SEQPACKET = global i32 0
@ALG_SET_KEY = global i32 0
@.str.2 = [17 x i8] c"\06\A9!@6\B8\A1[Q.\03\D54\12\00\06\00"
@.str.3 = [17 x i8] c"Single block msg\00"
@.str.4 = [5 x i8] c"%02x\00"
@.str.5 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca %struct.sockaddr_alg
%5 = alloca %struct.msghdr
%6 = alloca %struct.cmsghdr*
%7 = alloca i8*
%8 = alloca i64
%9 = alloca [16 x i8]
%10 = alloca %struct.af_alg_iv*
%11 = alloca %struct.iovec
%12 = alloca i32
store i32 0, i32* %1
%13 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %4, i32 0, i32 0
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8** %13
%14 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %4, i32 0, i32 1
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0), i8** %14
%15 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %4, i32 0, i32 2
%16 = load i32, i32* @AF_ALG
store i32 %16, i32* %15
%17 = bitcast %struct.msghdr* %5 to i8*
%18 = call i32 @CMSG_SPACE(i32 4)
%19 = call i32 @CMSG_SPACE(i32 20)
%20 = add nsw i32 %18, %19
%21 = zext i32 %20 to i64
%22 = call i8* @llvm.stacksave()
store i8* %22, i8** %7
%23 = alloca i8, i64 %21
store i64 %21, i64* %8
%24 = bitcast [16 x i8]* %9 to i8*
%25 = load i32, i32* @AF_ALG
%26 = load i32, i32* @SOCK_SEQPACKET
%27 = call i32 @socket(i32 %25, i32 %26, i32 0)
store i32 %27, i32* %3
%28 = load i32, i32* %3
%29 = bitcast %struct.sockaddr_alg* %4 to %struct.sockaddr*
%30 = call i32 @bind(i32 %28, %struct.sockaddr* %29, i32 24)
%31 = load i32, i32* %3
%32 = load i32, i32* @ALG_SET_KEY
%33 = call i32 @setsockopt(i32 %31, i32 279, i32 %32, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i32 16)
%34 = load i32, i32* %3
%35 = call i32 @accept(i32 %34, i32* null, i32 0)
store i32 %35, i32* %2
%36 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %5, i32 0, i32 0
store i8* %23, i8** %36
%37 = trunc i64 %21 to i32
%38 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %5, i32 0, i32 1
store i32 %37, i32* %38
%39 = getelementptr inbounds %struct.iovec, %struct.iovec* %11, i32 0, i32 0
store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i8** %39
%40 = getelementptr inbounds %struct.iovec, %struct.iovec* %11, i32 0, i32 1
store i32 16, i32* %40
%41 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %5, i32 0, i32 3
store %struct.iovec* %11, %struct.iovec** %41
%42 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %5, i32 0, i32 2
store i32 1, i32* %42
%43 = load i32, i32* %2
%44 = call i32 @sendmsg(i32 %43, %struct.msghdr* %5, i32 0)
%45 = load i32, i32* %2
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 0
%47 = call i32 @read(i32 %45, i8* %46, i32 16)
store i32 0, i32* %12
br label %48
48: ; preds = %58, %0
%49 = load i32, i32* %12
%50 = icmp slt i32 %49, 16
br i1 %50, label %51, label %61
51: ; preds = %48
%52 = load i32, i32* %12
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 %53
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %56)
br label %58
58: ; preds = %51
%59 = load i32, i32* %12
%60 = add nsw i32 %59, 1
store i32 %60, i32* %12
br label %48
61: ; preds = %48
%62 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%63 = load i32, i32* %2
%64 = call i32 @close(i32 %63)
%65 = load i32, i32* %3
%66 = call i32 @close(i32 %65)
store i32 0, i32* %1
%67 = load i8*, i8** %7
%68 = load i32, i32* %1
ret i32 %68
}

LLVM IR (-O2):
%struct.sockaddr_alg = type { i8*, i8*, i32 }
%struct.msghdr = type { i8*, i32, i32, %struct.iovec* }
%struct.iovec = type { i8*, i32 }
%struct.cmsghdr = type { i32 }
%struct.af_alg_iv = type { i32 }
%struct.sockaddr = type { i32 }
@.str = [9 x i8] c"skcipher\00"
@.str.1 = [9 x i8] c"cbc(aes)\00"
@AF_ALG = global i32 0
@SOCK_SEQPACKET = global i32 0
@ALG_SET_KEY = global i32 0
@.str.2 = [17 x i8] c"\06\A9!@6\B8\A1[Q.\03\D54\12\00\06\00"
@.str.3 = [17 x i8] c"Single block msg\00"
@.str.4 = [5 x i8] c"%02x\00"
define i32 @main() {
%1 = alloca %struct.sockaddr_alg
%2 = alloca %struct.msghdr
%3 = alloca [16 x i8]
%4 = alloca %struct.iovec
%5 = bitcast %struct.sockaddr_alg* %1 to i8*
%6 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %1, i64 0, i32 0
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), i8** %6
%7 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %1, i64 0, i32 1
store i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0), i8** %7
%8 = getelementptr inbounds %struct.sockaddr_alg, %struct.sockaddr_alg* %1, i64 0, i32 2
%9 = load i32, i32* @AF_ALG
store i32 %9, i32* %8
%10 = bitcast %struct.msghdr* %2 to i8*
%11 = tail call i32 @CMSG_SPACE(i32 4)
%12 = tail call i32 @CMSG_SPACE(i32 20)
%13 = add nsw i32 %12, %11
%14 = zext i32 %13 to i64
%15 = tail call i8* @llvm.stacksave()
%16 = alloca i8, i64 %14
%17 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 0
%18 = bitcast %struct.iovec* %4 to i8*
%19 = load i32, i32* @AF_ALG
%20 = load i32, i32* @SOCK_SEQPACKET
%21 = tail call i32 @socket(i32 %19, i32 %20, i32 0)
%22 = bitcast %struct.sockaddr_alg* %1 to %struct.sockaddr*
%23 = call i32 @bind(i32 %21, %struct.sockaddr* %22, i32 24)
%24 = load i32, i32* @ALG_SET_KEY
%25 = call i32 @setsockopt(i32 %21, i32 279, i32 %24, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.2, i64 0, i64 0), i32 16)
%26 = call i32 @accept(i32 %21, i32* null, i32 0)
%27 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %2, i64 0, i32 0
store i8* %16, i8** %27
%28 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %2, i64 0, i32 1
store i32 %13, i32* %28
%29 = getelementptr inbounds %struct.iovec, %struct.iovec* %4, i64 0, i32 0
store i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i8** %29
%30 = getelementptr inbounds %struct.iovec, %struct.iovec* %4, i64 0, i32 1
store i32 16, i32* %30
%31 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %2, i64 0, i32 3
store %struct.iovec* %4, %struct.iovec** %31
%32 = getelementptr inbounds %struct.msghdr, %struct.msghdr* %2, i64 0, i32 2
store i32 1, i32* %32
%33 = call i32 @sendmsg(i32 %26, %struct.msghdr* %2, i32 0)
%34 = call i32 @read(i32 %26, i8* %17, i32 16)
%35 = load i8, i8* %17
%36 = zext i8 %35 to i32
%37 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %36)
%38 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 1
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %40)
%42 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 2
%43 = load i8, i8* %42
%44 = zext i8 %43 to i32
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %44)
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 3
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %48)
%50 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 4
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %52)
%54 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 5
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %56)
%58 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 6
%59 = load i8, i8* %58
%60 = zext i8 %59 to i32
%61 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %60)
%62 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 7
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %64)
%66 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 8
%67 = load i8, i8* %66
%68 = zext i8 %67 to i32
%69 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %68)
%70 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 9
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %72)
%74 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 10
%75 = load i8, i8* %74
%76 = zext i8 %75 to i32
%77 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %76)
%78 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 11
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %80)
%82 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 12
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %84)
%86 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 13
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %88)
%90 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 14
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %92)
%94 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 15
%95 = load i8, i8* %94
%96 = zext i8 %95 to i32
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0), i32 %96)
%98 = call i32 @putchar(i32 10)
%99 = call i32 @close(i32 %26)
%100 = call i32 @close(i32 %21)
ret i32 0
}