#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 */
scalar_t__ malloc(int);
void invMessage(int begin_index, int end_index, char *message) {
  char *copy = (char *)malloc(18);
  for (int j = 0; j < 18; j++) {
    copy[j] = message[j];
  }
  int t = 0;
  for (int i = begin_index; i <= end_index; i++) {
    char tmp = copy[end_index - t] >> 4;
    char tmp2 = (copy[end_index - t] & 0x0f) << 4;
    message[i] = tmp + tmp2;
    t++;
  }
}


x86 assembly (clang, -O0):
<invMessage>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    $0x12,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x12,-0x1c(%rbp)
jge    1165 <invMessage+0x55>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1137 <invMessage+0x27>
movl   $0x0,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     11dd <invMessage+0xcd>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,-0x25(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0xf,%eax
shl    $0x4,%eax
mov    %al,-0x26(%rbp)
movsbl -0x25(%rbp),%eax
movsbl -0x26(%rbp),%ecx
add    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <invMessage+0x62>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invMessage>:
push   %rbp
push   %r14
push   %rbx
mov    %rdx,%rbx
mov    %esi,%r14d
mov    %edi,%ebp
mov    $0x12,%edi
call   1030 <malloc@plt>
mov    (%rbx),%cl
mov    %cl,(%rax)
mov    0x1(%rbx),%cl
mov    %cl,0x1(%rax)
mov    0x2(%rbx),%cl
mov    %cl,0x2(%rax)
mov    0x3(%rbx),%cl
mov    %cl,0x3(%rax)
mov    0x4(%rbx),%cl
mov    %cl,0x4(%rax)
mov    0x5(%rbx),%cl
mov    %cl,0x5(%rax)
mov    0x6(%rbx),%cl
mov    %cl,0x6(%rax)
mov    0x7(%rbx),%cl
mov    %cl,0x7(%rax)
mov    0x8(%rbx),%cl
mov    %cl,0x8(%rax)
mov    0x9(%rbx),%cl
mov    %cl,0x9(%rax)
mov    0xa(%rbx),%cl
mov    %cl,0xa(%rax)
mov    0xb(%rbx),%cl
mov    %cl,0xb(%rax)
mov    0xc(%rbx),%cl
mov    %cl,0xc(%rax)
mov    0xd(%rbx),%cl
mov    %cl,0xd(%rax)
mov    0xe(%rbx),%cl
mov    %cl,0xe(%rax)
mov    0xf(%rbx),%cl
mov    %cl,0xf(%rax)
mov    0x10(%rbx),%cl
mov    %cl,0x10(%rax)
mov    0x11(%rbx),%cl
mov    %cl,0x11(%rax)
cmp    %r14d,%ebp
jg     124f <invMessage+0x13f>
movslq %r14d,%r8
movslq %ebp,%r9
sub    %ebp,%r14d
add    $0x1,%r14d
cmp    $0x8,%r14d
jb     11db <invMessage+0xcb>
lea    (%rbx,%r9,1),%rdi
lea    (%rax,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rdi
jae    1254 <invMessage+0x144>
lea    (%r9,%r14,1),%rcx
add    %rbx,%rcx
lea    0x1(%r8),%rsi
sub    %r14,%rsi
add    %rax,%rsi
cmp    %rcx,%rsi
jae    1254 <invMessage+0x144>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
test   $0x1,%r14b
je     120a <invMessage+0xfa>
mov    %r8,%rdi
sub    %rsi,%rdi
mov    (%rax,%rdi,1),%dl
mov    %edx,%edi
sar    $0x4,%dil
shl    $0x4,%dl
add    %dil,%dl
mov    %dl,(%rbx,%r9,1)
or     $0x1,%rsi
add    $0x1,%r9
neg    %r14
cmp    %r14,%rcx
je     124f <invMessage+0x13f>
lea    (%r9,%rbx,1),%rcx
add    $0x1,%rcx
add    %r8,%rax
neg    %rsi
movzbl (%rax,%rsi,1),%edx
mov    %edx,%ebx
sar    $0x4,%bl
shl    $0x4,%dl
add    %bl,%dl
mov    %dl,-0x1(%rcx)
movzbl -0x1(%rax,%rsi,1),%edx
mov    %edx,%ebx
sar    $0x4,%bl
shl    $0x4,%dl
add    %bl,%dl
mov    %dl,(%rcx)
add    $0x2,%rcx
add    $0xfffffffffffffffe,%rsi
cmp    %rsi,%r14
jne    1220 <invMessage+0x110>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x10,%r14d
jae    1261 <invMessage+0x151>
xor    %esi,%esi
jmp    130e <invMessage+0x1fe>
mov    %r14d,%esi
and    $0xfffffff0,%esi
lea    (%r8,%rax,1),%rbp
add    $0xfffffffffffffff1,%rbp
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
movdqa 0xd83(%rip),%xmm1
movdqa 0xd8b(%rip),%xmm2
movdqa 0xd93(%rip),%xmm3
nopl   (%rax)
movdqu 0x0(%rbp),%xmm4
movdqa %xmm4,%xmm5
punpcklbw %xmm0,%xmm5
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
punpckhbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
packuswb %xmm5,%xmm4
movdqa %xmm4,%xmm5
psrlw  $0x4,%xmm5
pand   %xmm1,%xmm5
pxor   %xmm2,%xmm5
psllw  $0x4,%xmm4
pand   %xmm3,%xmm4
por    %xmm5,%xmm4
psubb  %xmm2,%xmm4
movdqu %xmm4,(%rdi,%rcx,1)
add    $0x10,%rcx
add    $0xfffffffffffffff0,%rbp
cmp    %rcx,%rsi
jne    1290 <invMessage+0x180>
cmp    %r14,%rsi
je     124f <invMessage+0x13f>
test   $0x8,%r14b
jne    130e <invMessage+0x1fe>
add    %rsi,%r9
jmp    11dd <invMessage+0xcd>
mov    %rsi,%rbp
mov    %r14d,%esi
and    $0xfffffff8,%esi
add    %rsi,%r9
mov    %r8,%rcx
sub    %rbp,%rcx
add    %rax,%rcx
add    $0xfffffffffffffff9,%rcx
pxor   %xmm0,%xmm0
movdqa 0xccd(%rip),%xmm1
movdqa 0xcd5(%rip),%xmm2
movdqa 0xcdd(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%rcx),%xmm4
punpcklbw %xmm0,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
packuswb %xmm4,%xmm4
movdqa %xmm4,%xmm5
psrlw  $0x4,%xmm5
pand   %xmm1,%xmm5
pxor   %xmm2,%xmm5
psllw  $0x4,%xmm4
pand   %xmm3,%xmm4
por    %xmm5,%xmm4
psubb  %xmm2,%xmm4
movq   %xmm4,(%rdi,%rbp,1)
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rcx
cmp    %rbp,%rsi
jne    1350 <invMessage+0x240>
cmp    %r14,%rsi
jne    11dd <invMessage+0xcd>
jmp    124f <invMessage+0x13f>

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

LLVM IR (-O2):
define void @invMessage(i32 %0, i32 %1, i8* nocapture %2) {
%4 = tail call i64 @malloc(i32 18)
%5 = inttoptr i64 %4 to i8*
%6 = load i8, i8* %2
store i8 %6, i8* %5
%7 = getelementptr inbounds i8, i8* %2, i64 1
%8 = load i8, i8* %7
%9 = getelementptr inbounds i8, i8* %5, i64 1
store i8 %8, i8* %9
%10 = getelementptr inbounds i8, i8* %2, i64 2
%11 = load i8, i8* %10
%12 = getelementptr inbounds i8, i8* %5, i64 2
store i8 %11, i8* %12
%13 = getelementptr inbounds i8, i8* %2, i64 3
%14 = load i8, i8* %13
%15 = getelementptr inbounds i8, i8* %5, i64 3
store i8 %14, i8* %15
%16 = getelementptr inbounds i8, i8* %2, i64 4
%17 = load i8, i8* %16
%18 = getelementptr inbounds i8, i8* %5, i64 4
store i8 %17, i8* %18
%19 = getelementptr inbounds i8, i8* %2, i64 5
%20 = load i8, i8* %19
%21 = getelementptr inbounds i8, i8* %5, i64 5
store i8 %20, i8* %21
%22 = getelementptr inbounds i8, i8* %2, i64 6
%23 = load i8, i8* %22
%24 = getelementptr inbounds i8, i8* %5, i64 6
store i8 %23, i8* %24
%25 = getelementptr inbounds i8, i8* %2, i64 7
%26 = load i8, i8* %25
%27 = getelementptr inbounds i8, i8* %5, i64 7
store i8 %26, i8* %27
%28 = getelementptr inbounds i8, i8* %2, i64 8
%29 = load i8, i8* %28
%30 = getelementptr inbounds i8, i8* %5, i64 8
store i8 %29, i8* %30
%31 = getelementptr inbounds i8, i8* %2, i64 9
%32 = load i8, i8* %31
%33 = getelementptr inbounds i8, i8* %5, i64 9
store i8 %32, i8* %33
%34 = getelementptr inbounds i8, i8* %2, i64 10
%35 = load i8, i8* %34
%36 = getelementptr inbounds i8, i8* %5, i64 10
store i8 %35, i8* %36
%37 = getelementptr inbounds i8, i8* %2, i64 11
%38 = load i8, i8* %37
%39 = getelementptr inbounds i8, i8* %5, i64 11
store i8 %38, i8* %39
%40 = getelementptr inbounds i8, i8* %2, i64 12
%41 = load i8, i8* %40
%42 = getelementptr inbounds i8, i8* %5, i64 12
store i8 %41, i8* %42
%43 = getelementptr inbounds i8, i8* %2, i64 13
%44 = load i8, i8* %43
%45 = getelementptr inbounds i8, i8* %5, i64 13
store i8 %44, i8* %45
%46 = getelementptr inbounds i8, i8* %2, i64 14
%47 = load i8, i8* %46
%48 = getelementptr inbounds i8, i8* %5, i64 14
store i8 %47, i8* %48
%49 = getelementptr inbounds i8, i8* %2, i64 15
%50 = load i8, i8* %49
%51 = getelementptr inbounds i8, i8* %5, i64 15
store i8 %50, i8* %51
%52 = getelementptr inbounds i8, i8* %2, i64 16
%53 = load i8, i8* %52
%54 = getelementptr inbounds i8, i8* %5, i64 16
store i8 %53, i8* %54
%55 = getelementptr inbounds i8, i8* %2, i64 17
%56 = load i8, i8* %55
%57 = getelementptr inbounds i8, i8* %5, i64 17
store i8 %56, i8* %57
%58 = icmp sgt i32 %0, %1
br i1 %58, label %147, label %59
59: ; preds = %3
%60 = sext i32 %1 to i64
%61 = sext i32 %0 to i64
%62 = add i32 %1, 1
%63 = sub i32 %62, %0
%64 = zext i32 %63 to i64
%65 = icmp ult i32 %63, 8
br i1 %65, label %126, label %66
66: ; preds = %59
%67 = getelementptr i8, i8* %2, i64 %61
%68 = add nsw i64 %61, %64
%69 = getelementptr i8, i8* %2, i64 %68
%70 = add nsw i64 %60, 1
%71 = sub nsw i64 %70, %64
%72 = getelementptr i8, i8* %5, i64 %71
%73 = add nsw i64 %60, 1
%74 = getelementptr i8, i8* %5, i64 %73
%75 = icmp ult i8* %67, %74
%76 = icmp ult i8* %72, %69
%77 = and i1 %75, %76
br i1 %77, label %126, label %78
78: ; preds = %66
%79 = icmp ult i32 %63, 16
br i1 %79, label %104, label %80
80: ; preds = %78
%81 = and i64 %64, 4294967280
%82 = getelementptr inbounds i8, i8* %5, i64 -15
br label %83
83: ; preds = %83, %80
%84 = phi i64 [ 0, %80 ], [ %96, %83 ]
%85 = add i64 %84, %61
%86 = sub nsw i64 %60, %84
%87 = getelementptr inbounds i8, i8* %82, i64 %86
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = shufflevector <16 x i8> %89, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%91 = ashr <16 x i8> %90, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%92 = shl <16 x i8> %90, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%93 = add <16 x i8> %91, %92
%94 = getelementptr inbounds i8, i8* %2, i64 %85
%95 = bitcast i8* %94 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %95
%96 = add nuw i64 %84, 16
%97 = icmp eq i64 %96, %81
br i1 %97, label %98, label %83
98: ; preds = %83
%99 = icmp eq i64 %81, %64
br i1 %99, label %147, label %100
100: ; preds = %98
%101 = add nsw i64 %81, %61
%102 = and i64 %64, 8
%103 = icmp eq i64 %102, 0
br i1 %103, label %126, label %104
104: ; preds = %78, %100
%105 = phi i64 [ %81, %100 ], [ 0, %78 ]
%106 = and i64 %64, 4294967288
%107 = add nsw i64 %106, %61
%108 = getelementptr inbounds i8, i8* %5, i64 -7
br label %109
109: ; preds = %109, %104
%110 = phi i64 [ %105, %104 ], [ %122, %109 ]
%111 = add i64 %110, %61
%112 = sub nsw i64 %60, %110
%113 = getelementptr inbounds i8, i8* %108, i64 %112
%114 = bitcast i8* %113 to <8 x i8>*
%115 = load <8 x i8>, <8 x i8>* %114
%116 = shufflevector <8 x i8> %115, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%117 = ashr <8 x i8> %116, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%118 = shl <8 x i8> %116, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%119 = add <8 x i8> %117, %118
%120 = getelementptr inbounds i8, i8* %2, i64 %111
%121 = bitcast i8* %120 to <8 x i8>*
store <8 x i8> %119, <8 x i8>* %121
%122 = add nuw i64 %110, 8
%123 = icmp eq i64 %122, %106
br i1 %123, label %124, label %109
124: ; preds = %109
%125 = icmp eq i64 %106, %64
br i1 %125, label %147, label %126
126: ; preds = %66, %59, %100, %124
%127 = phi i64 [ %61, %59 ], [ %61, %66 ], [ %101, %100 ], [ %107, %124 ]
%128 = phi i64 [ 0, %59 ], [ 0, %66 ], [ %81, %100 ], [ %106, %124 ]
%129 = xor i64 %128, -1
%130 = and i64 %64, 1
%131 = icmp eq i64 %130, 0
br i1 %131, label %142, label %132
132: ; preds = %126
%133 = sub nsw i64 %60, %128
%134 = getelementptr inbounds i8, i8* %5, i64 %133
%135 = load i8, i8* %134
%136 = ashr i8 %135, 4
%137 = shl i8 %135, 4
%138 = add i8 %136, %137
%139 = getelementptr inbounds i8, i8* %2, i64 %127
store i8 %138, i8* %139
%140 = or i64 %128, 1
%141 = add nsw i64 %127, 1
br label %142
142: ; preds = %132, %126
%143 = phi i64 [ %127, %126 ], [ %141, %132 ]
%144 = phi i64 [ %128, %126 ], [ %140, %132 ]
%145 = sub nsw i64 0, %64
%146 = icmp eq i64 %129, %145
br i1 %146, label %147, label %148
147: ; preds = %142, %148, %98, %124, %3
ret void
148: ; preds = %142, %148
%149 = phi i64 [ %168, %148 ], [ %143, %142 ]
%150 = phi i64 [ %167, %148 ], [ %144, %142 ]
%151 = sub nsw i64 %60, %150
%152 = getelementptr inbounds i8, i8* %5, i64 %151
%153 = load i8, i8* %152
%154 = ashr i8 %153, 4
%155 = shl i8 %153, 4
%156 = add i8 %154, %155
%157 = getelementptr inbounds i8, i8* %2, i64 %149
store i8 %156, i8* %157
%158 = xor i64 %150, -1
%159 = add nsw i64 %149, 1
%160 = add i64 %158, %60
%161 = getelementptr inbounds i8, i8* %5, i64 %160
%162 = load i8, i8* %161
%163 = ashr i8 %162, 4
%164 = shl i8 %162, 4
%165 = add i8 %163, %164
%166 = getelementptr inbounds i8, i8* %2, i64 %159
store i8 %165, i8* %166
%167 = add nuw nsw i64 %150, 2
%168 = add nsw i64 %149, 2
%169 = icmp eq i64 %167, %64
br i1 %169, label %147, label %148
}