#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 strlen(char *);
char *pack2zone(char *in, char *out) {
  int i;
  int j;
  char src, hight, low;
  int len = strlen(in);
  j = 0;
  for (i = 0; i < len - 1; i++) {
    src = *(in + i);
    hight = 0xF0 | (src >> 4);
    low = 0xF0 | (src);
    *(out + j) = hight;
    j++;
    *(out + j) = low;
    j++;
  }
  *(out + j) = *(in + i);
  return out;
}


x86 assembly (clang, -O0):
<pack2zone>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11b0 <pack2zone+0xa0>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
movsbl -0x19(%rbp),%eax
sar    $0x4,%eax
or     $0xf0,%eax
mov    %al,-0x1a(%rbp)
movsbl -0x19(%rbp),%eax
or     $0xf0,%eax
mov    %al,-0x1b(%rbp)
mov    -0x1a(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1b(%rbp),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    113a <pack2zone+0x2a>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pack2zone>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
call   1030 <strlen@plt>
cmp    $0x2,%eax
jl     11dd <pack2zone+0xcd>
add    $0xffffffff,%eax
mov    %eax,%r10d
cmp    $0x10,%eax
jb     114d <pack2zone+0x3d>
lea    (%r14,%r10,1),%rax
cmp    %rbx,%rax
jbe    11e4 <pack2zone+0xd4>
lea    (%rbx,%r10,2),%rax
cmp    %r14,%rax
jbe    11e4 <pack2zone+0xd4>
xor    %edi,%edi
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r10b
je     1187 <pack2zone+0x77>
mov    (%r14,%rdx,1),%r9b
mov    %r9d,%r8d
shr    $0x4,%r8b
or     $0xf0,%r8b
or     $0xf0,%r9b
mov    %r8b,(%rbx,%rdi,1)
mov    %rdi,%rax
or     $0x1,%rax
mov    %r9b,(%rbx,%rax,1)
add    $0x2,%rdi
or     $0x1,%rdx
add    %r10,%rsi
je     125c <pack2zone+0x14c>
movzbl (%r14,%rdx,1),%ecx
mov    %ecx,%eax
shr    $0x4,%al
or     $0xf0,%al
or     $0xf0,%cl
mov    %al,(%rbx,%rdi,1)
mov    %rdi,%rax
or     $0x1,%rax
mov    %cl,(%rbx,%rax,1)
movzbl 0x1(%r14,%rdx,1),%eax
mov    %eax,%ecx
shr    $0x4,%cl
or     $0xf0,%cl
or     $0xf0,%al
mov    %cl,0x2(%rbx,%rdi,1)
lea    0x2(%rdi),%rcx
or     $0x1,%rcx
mov    %al,(%rbx,%rcx,1)
add    $0x4,%rdi
add    $0x2,%rdx
cmp    %rdx,%r10
jne    1190 <pack2zone+0x80>
jmp    125c <pack2zone+0x14c>
xor    %edi,%edi
xor    %r10d,%r10d
jmp    125f <pack2zone+0x14f>
mov    %r10d,%edx
and    $0xfffffff0,%edx
lea    (%rdx,%rdx,1),%rdi
xor    %esi,%esi
movdqa 0xe08(%rip),%xmm0
movdqa 0xe10(%rip),%xmm1
movq   (%r14,%rsi,1),%xmm2
movq   0x8(%r14,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
psrlw  $0x4,%xmm4
pand   %xmm0,%xmm4
movdqa %xmm3,%xmm5
psrlw  $0x4,%xmm5
pand   %xmm0,%xmm5
por    %xmm1,%xmm4
por    %xmm1,%xmm5
por    %xmm1,%xmm2
punpcklbw %xmm2,%xmm4
por    %xmm1,%xmm3
punpcklbw %xmm3,%xmm5
movdqu %xmm4,(%rbx,%rsi,2)
movdqu %xmm5,0x10(%rbx,%rsi,2)
add    $0x10,%rsi
cmp    %rsi,%rdx
jne    1200 <pack2zone+0xf0>
cmp    %r10,%rdx
jne    1151 <pack2zone+0x41>
and    $0xfffffffe,%edi
mov    (%r14,%r10,1),%al
mov    %al,(%rbx,%rdi,1)
mov    %rbx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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