char *perl_explode(buf)
char *buf;
{
  char *return_buf;
  int cntr;
  return_buf = (char *)malloc(sizeof(char) * ((strlen(buf) * 2) + 1));
  for (cntr = 0; (cntr / 2) < strlen(buf); cntr += 2) {
    return_buf[cntr] = buf[cntr / 2];
    return_buf[cntr + 1] = ' ';
  }
  return_buf[cntr - 1] = '\0';
  return (return_buf);
}


x86 assembly (clang, -O0):
<perl_explode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,%rdi
shl    $0x1,%rdi
add    $0x1,%rdi
shl    $0x0,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
cmp    %rcx,%rax
jae    11c7 <perl_explode+0xa7>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x14(%rbp)
jmp    1154 <perl_explode+0x34>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x10(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<perl_explode>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %rax,%r14
lea    (%rax,%rax,1),%rdi
add    $0x1,%rdi
call   1040 <malloc@plt>
test   %r14,%r14
je     118b <perl_explode+0x6b>
cmp    $0x10,%r14
jae    119e <perl_explode+0x7e>
xor    %edx,%edx
xor    %ecx,%ecx
lea    -0x2(%rdx),%rsi
add    $0x2,%rdx
shr    %rdx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rbx,%rcx,1),%ecx
mov    %cl,0x2(%rax,%rsi,1)
movb   $0x20,0x3(%rax,%rsi,1)
mov    %edx,%ecx
and    $0x7fffffff,%ecx
add    $0x2,%rsi
add    $0x1,%rdx
cmp    %rcx,%r14
ja     1160 <perl_explode+0x40>
movslq %esi,%rcx
or     $0x1,%rcx
jmp    1192 <perl_explode+0x72>
mov    $0xffffffffffffffff,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
lea    -0x1(%r14),%rsi
mov    %esi,%ecx
not    %ecx
xor    %edx,%edx
test   $0x7fffffff,%ecx
je     1149 <perl_explode+0x29>
mov    $0x0,%ecx
cmp    $0x7fffffff,%rsi
ja     114b <perl_explode+0x2b>
mov    %r14,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1287 <perl_explode+0x167>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xe12(%rip),%xmm0
xchg   %ax,%ax
movq   (%rbx,%rdx,1),%xmm1
movq   0x8(%rbx,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,(%rax,%rdx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x10(%rax,%rdx,2)
movq   0x10(%rbx,%rdx,1),%xmm1
movq   0x18(%rbx,%rdx,1),%xmm2
punpcklbw %xmm0,%xmm1
movdqu %xmm1,0x20(%rax,%rdx,2)
punpcklbw %xmm0,%xmm2
movdqu %xmm2,0x30(%rax,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rdi
jne    11f0 <perl_explode+0xd0>
test   $0x1,%sil
je     126c <perl_explode+0x14c>
lea    (%rdx,%rdx,1),%rsi
movq   (%rbx,%rdx,1),%xmm0
movq   0x8(%rbx,%rdx,1),%xmm1
or     $0x11,%rsi
movdqa 0xda7(%rip),%xmm2
punpcklbw %xmm2,%xmm0
movdqu %xmm0,(%rax,%rdx,2)
punpcklbw %xmm2,%xmm1
movdqu %xmm1,-0x1(%rax,%rsi,1)
cmp    %rcx,%r14
jne    127e <perl_explode+0x15e>
lea    (%rcx,%rcx,1),%rsi
add    $0xfffffffffffffffe,%rsi
jmp    1182 <perl_explode+0x62>
lea    (%rcx,%rcx,1),%rdx
jmp    114b <perl_explode+0x2b>
xor    %edx,%edx
test   $0x1,%sil
jne    123e <perl_explode+0x11e>
jmp    126c <perl_explode+0x14c>

LLVM IR (-O0):
define i8* @perl_explode(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i32
store i8* %0, i8** %2
%5 = load i8*, i8** %2
%6 = call i64 @strlen(i8* %5)
%7 = mul i64 %6, 2
%8 = add i64 %7, 1
%9 = mul i64 1, %8
%10 = call i8* @malloc(i64 %9)
store i8* %10, i8** %3
store i32 0, i32* %4
br label %11
11: ; preds = %34, %1
%12 = load i32, i32* %4
%13 = sdiv i32 %12, 2
%14 = sext i32 %13 to i64
%15 = load i8*, i8** %2
%16 = call i64 @strlen(i8* %15)
%17 = icmp ult i64 %14, %16
br i1 %17, label %18, label %37
18: ; preds = %11
%19 = load i8*, i8** %2
%20 = load i32, i32* %4
%21 = sdiv i32 %20, 2
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %19, i64 %22
%24 = load i8, i8* %23
%25 = load i8*, i8** %3
%26 = load i32, i32* %4
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
store i8 %24, i8* %28
%29 = load i8*, i8** %3
%30 = load i32, i32* %4
%31 = add nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i8, i8* %29, i64 %32
store i8 32, i8* %33
br label %34
34: ; preds = %18
%35 = load i32, i32* %4
%36 = add nsw i32 %35, 2
store i32 %36, i32* %4
br label %11
37: ; preds = %11
%38 = load i8*, i8** %3
%39 = load i32, i32* %4
%40 = sub nsw i32 %39, 1
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds i8, i8* %38, i64 %41
store i8 0, i8* %42
%43 = load i8*, i8** %3
ret i8* %43
}

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