#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*/ strcpy(char *, char *);
int strlen(char *);
void revcomp(char string[]) {
  int a = strlen(string);
  int b, c;
  char base;
  char newstring[a + 1];
  for (b = 0; b < a; b++) {
    newstring[b] = string[a - 1 - b];
  }
  for (c = 0; c < a; c++) {
    base = newstring[c];
    switch (base) {
    case 'A':
      base = 'T';
      break;
    case 'C':
      base = 'G';
      break;
    case 'G':
      base = 'C';
      break;
    case 'T':
      base = 'A';
      break;
    }
    newstring[c] = base;
  }
  newstring[a] = '\0';
  strcpy(string, newstring);
}


x86 assembly (clang, -O0):
<revcomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11a0 <revcomp+0x80>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x10(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,1),%dl
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1168 <revcomp+0x48>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1226 <revcomp+0x106>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x15(%rbp)
movsbl -0x15(%rbp),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x13,%eax
ja     120a <revcomp+0xea>
mov    -0x38(%rbp),%rax
lea    0xe1e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x54,-0x15(%rbp)
jmp    120a <revcomp+0xea>
movb   $0x47,-0x15(%rbp)
jmp    120a <revcomp+0xea>
movb   $0x43,-0x15(%rbp)
jmp    120a <revcomp+0xea>
movb   $0x41,-0x15(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x15(%rbp),%dl
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11a7 <revcomp+0x87>
mov    -0x30(%rbp),%rsi
movslq -0xc(%rbp),%rax
movb   $0x0,(%rsi,%rax,1)
mov    -0x8(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<revcomp>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
mov    %rdi,%r14
call   1040 <strlen@plt>
lea    0x1(%rax),%ecx
mov    %rsp,%rsi
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rsi
mov    %rsi,%rsp
test   %eax,%eax
jle    1404 <revcomp+0x2e4>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    115a <revcomp+0x3a>
xor    %edx,%edx
jmp    1287 <revcomp+0x167>
lea    -0x1(%r8),%rdi
lea    -0x1(%rax),%ecx
mov    %ecx,%ebx
sub    %edi,%ebx
xor    %edx,%edx
cmp    %ecx,%ebx
jg     1287 <revcomp+0x167>
shr    $0x20,%rdi
jne    1287 <revcomp+0x167>
cmp    $0x20,%eax
jae    1185 <revcomp+0x65>
xor    %edx,%edx
jmp    1237 <revcomp+0x117>
mov    %r8d,%edx
and    $0xffffffe0,%edx
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movdqu -0x1f(%r14,%rcx,1),%xmm1
movdqu -0xf(%r14,%rcx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,(%rsi,%rdi,1)
movdqa %xmm1,0x10(%rsi,%rdi,1)
add    $0x20,%rdi
add    $0xffffffe0,%ecx
cmp    %rdi,%rdx
jne    11a0 <revcomp+0x80>
cmp    %r8,%rdx
je     12f6 <revcomp+0x1d6>
test   $0x18,%r8b
je     1287 <revcomp+0x167>
mov    %rdx,%rcx
mov    %r8d,%edx
and    $0xfffffff8,%edx
mov    %ecx,%edi
not    %edi
add    %eax,%edi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movslq %edi,%rdi
movq   -0x7(%r14,%rdi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi,%rcx,1)
add    $0x8,%rcx
add    $0xfffffff8,%edi
cmp    %rcx,%rdx
jne    1250 <revcomp+0x130>
cmp    %r8,%rdx
je     12f6 <revcomp+0x1d6>
mov    %rdx,%rcx
not    %rcx
test   $0x1,%r8b
je     12a7 <revcomp+0x187>
mov    %edx,%edi
not    %edi
add    %eax,%edi
movslq %edi,%rdi
mov    (%r14,%rdi,1),%bl
mov    %bl,(%rsi,%rdx,1)
or     $0x1,%rdx
add    %r8,%rcx
je     12f6 <revcomp+0x1d6>
mov    %r8,%r9
sub    %rdx,%r9
mov    %edx,%edi
not    %edi
add    %eax,%edi
add    %rsi,%rdx
add    $0x1,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %edi,%rdi
movzbl (%r14,%rdi,1),%ecx
mov    %cl,-0x1(%rdx,%rbx,1)
lea    -0x1(%rdi),%ecx
movslq %ecx,%rcx
movzbl (%r14,%rcx,1),%ecx
mov    %cl,(%rdx,%rbx,1)
add    $0x2,%rbx
add    $0xfffffffe,%edi
cmp    %rbx,%r9
jne    12d0 <revcomp+0x1b0>
test   %eax,%eax
jle    1404 <revcomp+0x2e4>
cmp    $0x1,%eax
jne    1338 <revcomp+0x218>
xor    %edx,%edx
test   $0x1,%r8b
je     1404 <revcomp+0x2e4>
movsbl (%rsi,%rdx,1),%ecx
mov    %ecx,%edi
add    $0xffffffbf,%edi
cmp    $0x13,%edi
ja     1401 <revcomp+0x2e1>
lea    0xd78(%rip),%rbx
movslq (%rbx,%rdi,4),%rdi
add    %rbx,%rdi
jmp    *%rdi
mov    $0x54,%cl
jmp    1401 <revcomp+0x2e1>
mov    %r8d,%edi
and    $0xfffffffe,%edi
xor    %edx,%edx
lea    0xd09(%rip),%r9
lea    0xcb2(%rip),%r10
jmp    136d <revcomp+0x24d>
mov    $0x54,%cl
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %cl,0x1(%rsi,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%rdi
je     1305 <revcomp+0x1e5>
movsbl (%rsi,%rdx,1),%ecx
mov    %ecx,%ebx
add    $0xffffffbf,%ebx
cmp    $0x13,%ebx
ja     13c0 <revcomp+0x2a0>
movslq (%r10,%rbx,4),%rbx
add    %r10,%rbx
jmp    *%rbx
mov    $0x54,%cl
jmp    13c0 <revcomp+0x2a0>
nopl   0x0(%rax,%rax,1)
mov    $0x47,%cl
jmp    13c0 <revcomp+0x2a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x43,%cl
jmp    13c0 <revcomp+0x2a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x41,%cl
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %cl,(%rsi,%rdx,1)
movsbl 0x1(%rsi,%rdx,1),%ecx
mov    %ecx,%ebx
add    $0xffffffbf,%ebx
cmp    $0x13,%ebx
ja     1360 <revcomp+0x240>
movslq (%r9,%rbx,4),%rbx
add    %r9,%rbx
jmp    *%rbx
mov    $0x47,%cl
jmp    1360 <revcomp+0x240>
nop
mov    $0x43,%cl
jmp    1360 <revcomp+0x240>
nopw   0x0(%rax,%rax,1)
mov    $0x41,%cl
jmp    1360 <revcomp+0x240>
mov    $0x47,%cl
jmp    1401 <revcomp+0x2e1>
mov    $0x43,%cl
jmp    1401 <revcomp+0x2e1>
mov    $0x41,%cl
mov    %cl,(%rsi,%rdx,1)
cltq
movb   $0x0,(%rsi,%rax,1)
mov    %r14,%rdi
call   1030 <strcpy@plt>
lea    -0x10(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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