void expand(unsigned char *arg1, unsigned char *arg2) {
  arg2[0] = ((((arg1[0] / 4) & 6) | (arg1[0] & 0xF9)) / 2) | arg1[3] << 7;
  arg2[1] = (((arg1[1] & 0x87) | (arg1[1] >> 2)) >> 3) |
            (((arg1[0] << 2) | (arg1[0] & 1)) << 3);
  arg2[2] = (((arg1[1] & 0xF8) << 2) | (arg1[1] & 0x1F)) << 1 | arg1[2] >> 7;
  arg2[3] = ((arg1[2] >> 2 & 6) | (arg1[2] & 0xF9)) >> 1 | arg1[1] << 7;
  arg2[4] = (((arg1[3] & 0x87) | (arg1[3] >> 2)) >> 3) |
            (((arg1[2] << 2) | (arg1[2] & 1)) << 3);
  arg2[5] = (((arg1[3] & 0xF8) << 2 | (arg1[3] & 0x1F)) << 1) | (arg1[0] >> 7);
}


x86 assembly (clang, -O0):
<expand>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
and    $0x6,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
and    $0xf9,%ecx
or     %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
shl    $0x7,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0x87,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
sar    $0x2,%ecx
or     %ecx,%eax
sar    $0x3,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
shl    $0x2,%ecx
mov    -0x8(%rbp),%rdx
movzbl (%rdx),%edx
and    $0x1,%edx
or     %edx,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xf8,%eax
shl    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0x1f,%ecx
or     %ecx,%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
sar    $0x2,%eax
and    $0x6,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0xf9,%ecx
or     %ecx,%eax
sar    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x7,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0x87,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
sar    $0x2,%ecx
or     %ecx,%eax
sar    $0x3,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x2,%ecx
mov    -0x8(%rbp),%rdx
movzbl 0x2(%rdx),%edx
and    $0x1,%edx
or     %edx,%ecx
shl    $0x3,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xf8,%eax
shl    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
and    $0x1f,%ecx
or     %ecx,%eax
shl    $0x1,%eax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x5(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<expand>:
mov    (%rdi),%al
mov    0x3(%rdi),%cl
mov    %eax,%edx
shr    $0x2,%dl
and    $0x6,%dl
and    $0xf8,%al
or     %dl,%al
shr    %al
shl    $0x7,%cl
or     %al,%cl
mov    %cl,(%rsi)
mov    (%rdi),%al
mov    0x1(%rdi),%cl
mov    %ecx,%edx
shr    $0x5,%dl
shr    $0x3,%cl
and    $0x10,%cl
or     %dl,%cl
mov    %eax,%edx
shl    $0x5,%dl
shl    $0x3,%al
and    $0x8,%al
or     %dl,%al
or     %cl,%al
mov    %al,0x1(%rsi)
mov    0x1(%rdi),%al
mov    0x2(%rdi),%cl
lea    0x0(,%rax,4),%edx
and    $0x60,%dl
and    $0x1f,%al
or     %dl,%al
add    %al,%al
shr    $0x7,%cl
or     %al,%cl
mov    %cl,0x2(%rsi)
mov    0x1(%rdi),%al
mov    0x2(%rdi),%cl
mov    %ecx,%edx
shr    $0x2,%dl
and    $0x6,%dl
and    $0xf8,%cl
or     %dl,%cl
shr    %cl
shl    $0x7,%al
or     %cl,%al
mov    %al,0x3(%rsi)
mov    0x2(%rdi),%al
mov    0x3(%rdi),%cl
mov    %ecx,%edx
shr    $0x5,%dl
shr    $0x3,%cl
and    $0x10,%cl
or     %dl,%cl
mov    %eax,%edx
shl    $0x5,%dl
shl    $0x3,%al
and    $0x8,%al
or     %dl,%al
or     %cl,%al
mov    %al,0x4(%rsi)
mov    (%rdi),%al
mov    0x3(%rdi),%cl
lea    0x0(,%rcx,4),%edx
and    $0x60,%dl
and    $0x1f,%cl
or     %dl,%cl
add    %cl,%cl
shr    $0x7,%al
or     %cl,%al
mov    %al,0x5(%rsi)
ret

LLVM IR (-O0):
define void @expand(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
store i8* %0, i8** %3
store i8* %1, i8** %4
%5 = load i8*, i8** %3
%6 = getelementptr inbounds i8, i8* %5, i64 0
%7 = load i8, i8* %6
%8 = zext i8 %7 to i32
%9 = sdiv i32 %8, 4
%10 = and i32 %9, 6
%11 = load i8*, i8** %3
%12 = getelementptr inbounds i8, i8* %11, i64 0
%13 = load i8, i8* %12
%14 = zext i8 %13 to i32
%15 = and i32 %14, 249
%16 = or i32 %10, %15
%17 = sdiv i32 %16, 2
%18 = load i8*, i8** %3
%19 = getelementptr inbounds i8, i8* %18, i64 3
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = shl i32 %21, 7
%23 = or i32 %17, %22
%24 = trunc i32 %23 to i8
%25 = load i8*, i8** %4
%26 = getelementptr inbounds i8, i8* %25, i64 0
store i8 %24, i8* %26
%27 = load i8*, i8** %3
%28 = getelementptr inbounds i8, i8* %27, i64 1
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = and i32 %30, 135
%32 = load i8*, i8** %3
%33 = getelementptr inbounds i8, i8* %32, i64 1
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = ashr i32 %35, 2
%37 = or i32 %31, %36
%38 = ashr i32 %37, 3
%39 = load i8*, i8** %3
%40 = getelementptr inbounds i8, i8* %39, i64 0
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = shl i32 %42, 2
%44 = load i8*, i8** %3
%45 = getelementptr inbounds i8, i8* %44, i64 0
%46 = load i8, i8* %45
%47 = zext i8 %46 to i32
%48 = and i32 %47, 1
%49 = or i32 %43, %48
%50 = shl i32 %49, 3
%51 = or i32 %38, %50
%52 = trunc i32 %51 to i8
%53 = load i8*, i8** %4
%54 = getelementptr inbounds i8, i8* %53, i64 1
store i8 %52, i8* %54
%55 = load i8*, i8** %3
%56 = getelementptr inbounds i8, i8* %55, i64 1
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = and i32 %58, 248
%60 = shl i32 %59, 2
%61 = load i8*, i8** %3
%62 = getelementptr inbounds i8, i8* %61, i64 1
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = and i32 %64, 31
%66 = or i32 %60, %65
%67 = shl i32 %66, 1
%68 = load i8*, i8** %3
%69 = getelementptr inbounds i8, i8* %68, i64 2
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = ashr i32 %71, 7
%73 = or i32 %67, %72
%74 = trunc i32 %73 to i8
%75 = load i8*, i8** %4
%76 = getelementptr inbounds i8, i8* %75, i64 2
store i8 %74, i8* %76
%77 = load i8*, i8** %3
%78 = getelementptr inbounds i8, i8* %77, i64 2
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
%81 = ashr i32 %80, 2
%82 = and i32 %81, 6
%83 = load i8*, i8** %3
%84 = getelementptr inbounds i8, i8* %83, i64 2
%85 = load i8, i8* %84
%86 = zext i8 %85 to i32
%87 = and i32 %86, 249
%88 = or i32 %82, %87
%89 = ashr i32 %88, 1
%90 = load i8*, i8** %3
%91 = getelementptr inbounds i8, i8* %90, i64 1
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = shl i32 %93, 7
%95 = or i32 %89, %94
%96 = trunc i32 %95 to i8
%97 = load i8*, i8** %4
%98 = getelementptr inbounds i8, i8* %97, i64 3
store i8 %96, i8* %98
%99 = load i8*, i8** %3
%100 = getelementptr inbounds i8, i8* %99, i64 3
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = and i32 %102, 135
%104 = load i8*, i8** %3
%105 = getelementptr inbounds i8, i8* %104, i64 3
%106 = load i8, i8* %105
%107 = zext i8 %106 to i32
%108 = ashr i32 %107, 2
%109 = or i32 %103, %108
%110 = ashr i32 %109, 3
%111 = load i8*, i8** %3
%112 = getelementptr inbounds i8, i8* %111, i64 2
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = shl i32 %114, 2
%116 = load i8*, i8** %3
%117 = getelementptr inbounds i8, i8* %116, i64 2
%118 = load i8, i8* %117
%119 = zext i8 %118 to i32
%120 = and i32 %119, 1
%121 = or i32 %115, %120
%122 = shl i32 %121, 3
%123 = or i32 %110, %122
%124 = trunc i32 %123 to i8
%125 = load i8*, i8** %4
%126 = getelementptr inbounds i8, i8* %125, i64 4
store i8 %124, i8* %126
%127 = load i8*, i8** %3
%128 = getelementptr inbounds i8, i8* %127, i64 3
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = and i32 %130, 248
%132 = shl i32 %131, 2
%133 = load i8*, i8** %3
%134 = getelementptr inbounds i8, i8* %133, i64 3
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = and i32 %136, 31
%138 = or i32 %132, %137
%139 = shl i32 %138, 1
%140 = load i8*, i8** %3
%141 = getelementptr inbounds i8, i8* %140, i64 0
%142 = load i8, i8* %141
%143 = zext i8 %142 to i32
%144 = ashr i32 %143, 7
%145 = or i32 %139, %144
%146 = trunc i32 %145 to i8
%147 = load i8*, i8** %4
%148 = getelementptr inbounds i8, i8* %147, i64 5
store i8 %146, i8* %148
ret void
}

LLVM IR (-O2):
define void @expand(i8* nocapture %0, i8* nocapture writeonly %1) {
%3 = load i8, i8* %0
%4 = lshr i8 %3, 2
%5 = and i8 %4, 6
%6 = and i8 %3, -8
%7 = or i8 %5, %6
%8 = getelementptr inbounds i8, i8* %0, i64 3
%9 = load i8, i8* %8
%10 = tail call i8 @llvm.fshl.i8(i8 %9, i8 %7, i8 7)
store i8 %10, i8* %1
%11 = getelementptr inbounds i8, i8* %0, i64 1
%12 = load i8, i8* %11
%13 = lshr i8 %12, 5
%14 = lshr i8 %12, 3
%15 = and i8 %14, 16
%16 = or i8 %13, %15
%17 = load i8, i8* %0
%18 = shl i8 %17, 5
%19 = shl i8 %17, 3
%20 = and i8 %19, 8
%21 = or i8 %20, %18
%22 = or i8 %21, %16
%23 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %22, i8* %23
%24 = load i8, i8* %11
%25 = shl i8 %24, 2
%26 = and i8 %25, 96
%27 = and i8 %24, 31
%28 = or i8 %26, %27
%29 = getelementptr inbounds i8, i8* %0, i64 2
%30 = load i8, i8* %29
%31 = tail call i8 @llvm.fshl.i8(i8 %28, i8 %30, i8 1)
%32 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %31, i8* %32
%33 = load i8, i8* %29
%34 = lshr i8 %33, 2
%35 = and i8 %34, 6
%36 = and i8 %33, -8
%37 = or i8 %35, %36
%38 = load i8, i8* %11
%39 = tail call i8 @llvm.fshl.i8(i8 %38, i8 %37, i8 7)
%40 = getelementptr inbounds i8, i8* %1, i64 3
store i8 %39, i8* %40
%41 = load i8, i8* %8
%42 = lshr i8 %41, 5
%43 = lshr i8 %41, 3
%44 = and i8 %43, 16
%45 = or i8 %42, %44
%46 = load i8, i8* %29
%47 = shl i8 %46, 5
%48 = shl i8 %46, 3
%49 = and i8 %48, 8
%50 = or i8 %49, %47
%51 = or i8 %50, %45
%52 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %51, i8* %52
%53 = load i8, i8* %8
%54 = shl i8 %53, 2
%55 = and i8 %54, 96
%56 = and i8 %53, 31
%57 = or i8 %55, %56
%58 = load i8, i8* %0
%59 = tail call i8 @llvm.fshl.i8(i8 %57, i8 %58, i8 1)
%60 = getelementptr inbounds i8, i8* %1, i64 5
store i8 %59, i8* %60
ret void
}