char *manchester_encode(char *dest, char *src, int len) {
  int bitnum = 0;
  int pos = 0;
  unsigned char tmp = 0;
  for (int j = 0; j < len; j++) {
    unsigned char byte = src[j];
    for (int i = 0; i < 8; i++) {
      tmp <<= 2;
      if (byte & 0x80) {
        tmp |= 0x2;
      } else {
        tmp |= 0x1;
      }
      bitnum += 2;
      if (bitnum == 8) {
        dest[pos++] = tmp;
        bitnum = 0;
        tmp = 0;
      }
      byte <<= 1;
    }
  }
  return dest;
}


x86 assembly (clang, -O0):
<manchester_encode>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movb   $0x0,-0x1d(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e9 <manchester_encode+0xe9>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x8,-0x2c(%rbp)
jge    11d6 <manchester_encode+0xd6>
movzbl -0x1d(%rbp),%eax
shl    $0x2,%eax
mov    %al,-0x1d(%rbp)
movzbl -0x25(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     117e <manchester_encode+0x7e>
movzbl -0x1d(%rbp),%eax
or     $0x2,%eax
mov    %al,-0x1d(%rbp)
jmp    1188 <manchester_encode+0x88>
movzbl -0x1d(%rbp),%eax
or     $0x1,%eax
mov    %al,-0x1d(%rbp)
mov    -0x18(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x8,-0x18(%rbp)
jne    11be <manchester_encode+0xbe>
mov    -0x1d(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x18(%rbp)
movb   $0x0,-0x1d(%rbp)
movzbl -0x25(%rbp),%eax
shl    $0x1,%eax
mov    %al,-0x25(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1149 <manchester_encode+0x49>
jmp    11db <manchester_encode+0xdb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1128 <manchester_encode+0x28>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<manchester_encode>:
push   %rbx
mov    %rdi,%rax
test   %edx,%edx
jle    11c0 <manchester_encode+0xc0>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     112e <manchester_encode+0x2e>
lea    (%rsi,%r9,1),%rcx
cmp    %rax,%rcx
jbe    11c2 <manchester_encode+0xc2>
lea    (%rax,%r9,2),%rcx
cmp    %rsi,%rcx
jbe    11c2 <manchester_encode+0xc2>
xor    %edx,%edx
xor    %r8d,%r8d
add    %rdx,%rsi
sub    %rdx,%r9
mov    %r8d,%ecx
lea    (%rcx,%rax,1),%r10
add    $0x1,%r10
xor    %r11d,%r11d
mov    $0x40,%r8d
nopl   (%rax)
movzbl (%rsi,%r11,1),%ebx
test   %bl,%bl
mov    $0x80,%edi
cmovns %r8d,%edi
mov    %ebx,%ecx
and    $0x40,%cl
shr    $0x2,%cl
or     %dil,%cl
mov    %ebx,%edx
and    $0x20,%dl
shr    $0x3,%dl
or     %cl,%dl
mov    %ebx,%ecx
and    $0x10,%cl
cmp    $0x1,%cl
sbb    $0x0,%dl
add    $0x16,%dl
mov    %dl,-0x1(%r10,%r11,2)
test   $0x8,%bl
mov    $0x80,%ecx
cmove  %r8d,%ecx
mov    %ebx,%edx
and    $0x4,%dl
shl    $0x2,%dl
or     %cl,%dl
mov    %ebx,%ecx
and    $0x2,%cl
add    %cl,%cl
or     %dl,%cl
and    $0x1,%bl
cmp    $0x1,%bl
sbb    $0x0,%cl
add    $0x16,%cl
mov    %cl,(%r10,%r11,2)
add    $0x1,%r11
cmp    %r11,%r9
jne    1150 <manchester_encode+0x50>
pop    %rbx
ret
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    (%rdx,%rdx,1),%r8d
xor    %edi,%edi
pcmpeqd %xmm8,%xmm8
movdqa 0xe24(%rip),%xmm10
movdqa 0xe2b(%rip),%xmm11
pxor   %xmm3,%xmm3
movdqa 0xe2e(%rip),%xmm12
movdqa 0xe35(%rip),%xmm13
movdqa 0xe3c(%rip),%xmm14
movdqa 0xe44(%rip),%xmm7
movdqa 0xe4c(%rip),%xmm0
movdqa 0xe53(%rip),%xmm9
nopl   (%rax)
movq   (%rsi,%rdi,1),%xmm2
movdqa %xmm2,%xmm1
pcmpgtb %xmm8,%xmm1
movdqa %xmm1,%xmm4
pandn  %xmm10,%xmm4
pand   %xmm11,%xmm1
por    %xmm4,%xmm1
movdqa %xmm2,%xmm4
pand   %xmm11,%xmm4
pcmpeqb %xmm3,%xmm4
movdqa %xmm4,%xmm5
pandn  %xmm12,%xmm5
pand   %xmm13,%xmm4
por    %xmm5,%xmm4
por    %xmm1,%xmm4
movdqa %xmm2,%xmm5
pand   %xmm12,%xmm5
pcmpeqb %xmm3,%xmm5
movdqa %xmm5,%xmm1
pandn  %xmm14,%xmm1
pand   %xmm7,%xmm5
por    %xmm1,%xmm5
movdqa %xmm2,%xmm1
pand   %xmm13,%xmm1
pcmpeqb %xmm3,%xmm1
paddb  %xmm0,%xmm1
por    %xmm5,%xmm1
por    %xmm4,%xmm1
movdqa %xmm2,%xmm4
pand   %xmm14,%xmm4
pcmpeqb %xmm3,%xmm4
movdqa %xmm4,%xmm5
pandn  %xmm10,%xmm5
pand   %xmm11,%xmm4
por    %xmm5,%xmm4
movdqa %xmm2,%xmm5
pand   %xmm7,%xmm5
pcmpeqb %xmm3,%xmm5
movdqa %xmm5,%xmm6
pandn  %xmm12,%xmm6
pand   %xmm13,%xmm5
por    %xmm6,%xmm5
por    %xmm4,%xmm5
movdqa %xmm2,%xmm4
pand   %xmm0,%xmm4
pcmpeqb %xmm3,%xmm4
movdqa %xmm4,%xmm6
pandn  %xmm14,%xmm6
pand   %xmm7,%xmm4
por    %xmm6,%xmm4
pand   %xmm9,%xmm2
pcmpeqb %xmm3,%xmm2
paddb  %xmm0,%xmm2
por    %xmm4,%xmm2
por    %xmm5,%xmm2
punpcklbw %xmm2,%xmm1
movdqu %xmm1,(%rax,%rdi,2)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    1220 <manchester_encode+0x120>
cmp    %r9,%rdx
jne    1133 <manchester_encode+0x33>
jmp    11c0 <manchester_encode+0xc0>

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

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