void nand_trans_result(unsigned char reg2, unsigned char reg3,
                       unsigned char *ecc_code) {
  unsigned char a, b, i, tmp1, tmp2;
  a = b = 0x80;
  tmp1 = tmp2 = 0;
  for (i = 0; i < 4; i++) {
    if (reg3 & a)
      tmp1 |= b;
    b >>= 1;
    if (reg2 & a)
      tmp1 |= b;
    b >>= 1;
    a >>= 1;
  }
  b = 0x80;
  for (i = 0; i < 4; i++) {
    if (reg3 & a)
      tmp2 |= b;
    b >>= 1;
    if (reg2 & a)
      tmp2 |= b;
    b >>= 1;
    a >>= 1;
  }
  ecc_code[0] = tmp1;
  ecc_code[1] = tmp2;
}


x86 assembly (clang, -O0):
<nand_trans_result>:
push   %rbp
mov    %rsp,%rbp
mov    %sil,%al
mov    %dil,%cl
mov    %cl,-0x1(%rbp)
mov    %al,-0x2(%rbp)
mov    %rdx,-0x10(%rbp)
movb   $0x80,-0x12(%rbp)
movb   $0x80,-0x11(%rbp)
movb   $0x0,-0x15(%rbp)
movb   $0x0,-0x14(%rbp)
movb   $0x0,-0x13(%rbp)
movzbl -0x13(%rbp),%eax
cmp    $0x4,%eax
jge    11a0 <nand_trans_result+0xa0>
movzbl -0x2(%rbp),%eax
movzbl -0x11(%rbp),%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1155 <nand_trans_result+0x55>
movzbl -0x12(%rbp),%ecx
movzbl -0x14(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x14(%rbp)
movzbl -0x12(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x12(%rbp)
movzbl -0x1(%rbp),%eax
movzbl -0x11(%rbp),%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     117f <nand_trans_result+0x7f>
movzbl -0x12(%rbp),%ecx
movzbl -0x14(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x14(%rbp)
movzbl -0x12(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x12(%rbp)
movzbl -0x11(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x11(%rbp)
mov    -0x13(%rbp),%al
add    $0x1,%al
mov    %al,-0x13(%rbp)
jmp    1128 <nand_trans_result+0x28>
movb   $0x80,-0x12(%rbp)
movb   $0x0,-0x13(%rbp)
movzbl -0x13(%rbp),%eax
cmp    $0x4,%eax
jge    1220 <nand_trans_result+0x120>
movzbl -0x2(%rbp),%eax
movzbl -0x11(%rbp),%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     11d5 <nand_trans_result+0xd5>
movzbl -0x12(%rbp),%ecx
movzbl -0x15(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x15(%rbp)
movzbl -0x12(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x12(%rbp)
movzbl -0x1(%rbp),%eax
movzbl -0x11(%rbp),%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     11ff <nand_trans_result+0xff>
movzbl -0x12(%rbp),%ecx
movzbl -0x15(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x15(%rbp)
movzbl -0x12(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x12(%rbp)
movzbl -0x11(%rbp),%eax
sar    $0x1,%eax
mov    %al,-0x11(%rbp)
mov    -0x13(%rbp),%al
add    $0x1,%al
mov    %al,-0x13(%rbp)
jmp    11a8 <nand_trans_result+0xa8>
mov    -0x14(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x15(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x1(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<nand_trans_result>:
push   %rbp
push   %r14
push   %rbx
mov    %edi,%r8d
shr    %r8b
and    $0x40,%r8b
mov    %esi,%r9d
shr    %r9b
and    $0x20,%r9b
mov    %edi,%r10d
shr    $0x2,%r10b
and    $0x10,%r10b
mov    %esi,%r11d
shr    $0x2,%r11b
and    $0x8,%r11b
mov    %edi,%r14d
shr    $0x3,%r14b
and    $0x4,%r14b
mov    %esi,%ecx
shr    $0x3,%cl
and    $0x2,%cl
mov    %edi,%ebx
shr    $0x4,%bl
and    $0x1,%bl
mov    %esi,%eax
shl    $0x4,%al
and    $0x80,%al
lea    0x0(,%rdi,8),%ebp
and    $0x40,%bpl
or     %al,%bpl
lea    0x0(,%rsi,8),%eax
and    $0x20,%al
or     %bpl,%al
lea    0x0(,%rdi,4),%ebp
and    $0x10,%bpl
or     %al,%bpl
lea    0x0(,%rsi,4),%eax
and    $0x8,%al
or     %bpl,%al
lea    (%rdi,%rdi,1),%ebp
and    $0x4,%bpl
or     %al,%bpl
lea    (%rsi,%rsi,1),%eax
and    $0x2,%al
or     %bpl,%al
and    $0x1,%dil
or     %al,%dil
and    $0x80,%sil
or     %r8b,%sil
or     %r9b,%sil
or     %r10b,%sil
or     %r11b,%sil
or     %r14b,%sil
or     %cl,%sil
or     %bl,%sil
mov    %sil,(%rdx)
mov    %dil,0x1(%rdx)
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @nand_trans_result(i8 zeroext %0, i8 zeroext %1, i8* %2) {
%4 = alloca i8
%5 = alloca i8
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca i8
%11 = alloca i8
store i8 %0, i8* %4
store i8 %1, i8* %5
store i8* %2, i8** %6
store i8 -128, i8* %8
store i8 -128, i8* %7
store i8 0, i8* %11
store i8 0, i8* %10
store i8 0, i8* %9
br label %12
12: ; preds = %57, %3
%13 = load i8, i8* %9
%14 = zext i8 %13 to i32
%15 = icmp slt i32 %14, 4
br i1 %15, label %16, label %60
16: ; preds = %12
%17 = load i8, i8* %5
%18 = zext i8 %17 to i32
%19 = load i8, i8* %7
%20 = zext i8 %19 to i32
%21 = and i32 %18, %20
%22 = icmp ne i32 %21, 0
br i1 %22, label %23, label %30
23: ; preds = %16
%24 = load i8, i8* %8
%25 = zext i8 %24 to i32
%26 = load i8, i8* %10
%27 = zext i8 %26 to i32
%28 = or i32 %27, %25
%29 = trunc i32 %28 to i8
store i8 %29, i8* %10
br label %30
30: ; preds = %23, %16
%31 = load i8, i8* %8
%32 = zext i8 %31 to i32
%33 = ashr i32 %32, 1
%34 = trunc i32 %33 to i8
store i8 %34, i8* %8
%35 = load i8, i8* %4
%36 = zext i8 %35 to i32
%37 = load i8, i8* %7
%38 = zext i8 %37 to i32
%39 = and i32 %36, %38
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %48
41: ; preds = %30
%42 = load i8, i8* %8
%43 = zext i8 %42 to i32
%44 = load i8, i8* %10
%45 = zext i8 %44 to i32
%46 = or i32 %45, %43
%47 = trunc i32 %46 to i8
store i8 %47, i8* %10
br label %48
48: ; preds = %41, %30
%49 = load i8, i8* %8
%50 = zext i8 %49 to i32
%51 = ashr i32 %50, 1
%52 = trunc i32 %51 to i8
store i8 %52, i8* %8
%53 = load i8, i8* %7
%54 = zext i8 %53 to i32
%55 = ashr i32 %54, 1
%56 = trunc i32 %55 to i8
store i8 %56, i8* %7
br label %57
57: ; preds = %48
%58 = load i8, i8* %9
%59 = add i8 %58, 1
store i8 %59, i8* %9
br label %12
60: ; preds = %12
store i8 -128, i8* %8
store i8 0, i8* %9
br label %61
61: ; preds = %106, %60
%62 = load i8, i8* %9
%63 = zext i8 %62 to i32
%64 = icmp slt i32 %63, 4
br i1 %64, label %65, label %109
65: ; preds = %61
%66 = load i8, i8* %5
%67 = zext i8 %66 to i32
%68 = load i8, i8* %7
%69 = zext i8 %68 to i32
%70 = and i32 %67, %69
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %79
72: ; preds = %65
%73 = load i8, i8* %8
%74 = zext i8 %73 to i32
%75 = load i8, i8* %11
%76 = zext i8 %75 to i32
%77 = or i32 %76, %74
%78 = trunc i32 %77 to i8
store i8 %78, i8* %11
br label %79
79: ; preds = %72, %65
%80 = load i8, i8* %8
%81 = zext i8 %80 to i32
%82 = ashr i32 %81, 1
%83 = trunc i32 %82 to i8
store i8 %83, i8* %8
%84 = load i8, i8* %4
%85 = zext i8 %84 to i32
%86 = load i8, i8* %7
%87 = zext i8 %86 to i32
%88 = and i32 %85, %87
%89 = icmp ne i32 %88, 0
br i1 %89, label %90, label %97
90: ; preds = %79
%91 = load i8, i8* %8
%92 = zext i8 %91 to i32
%93 = load i8, i8* %11
%94 = zext i8 %93 to i32
%95 = or i32 %94, %92
%96 = trunc i32 %95 to i8
store i8 %96, i8* %11
br label %97
97: ; preds = %90, %79
%98 = load i8, i8* %8
%99 = zext i8 %98 to i32
%100 = ashr i32 %99, 1
%101 = trunc i32 %100 to i8
store i8 %101, i8* %8
%102 = load i8, i8* %7
%103 = zext i8 %102 to i32
%104 = ashr i32 %103, 1
%105 = trunc i32 %104 to i8
store i8 %105, i8* %7
br label %106
106: ; preds = %97
%107 = load i8, i8* %9
%108 = add i8 %107, 1
store i8 %108, i8* %9
br label %61
109: ; preds = %61
%110 = load i8, i8* %10
%111 = load i8*, i8** %6
%112 = getelementptr inbounds i8, i8* %111, i64 0
store i8 %110, i8* %112
%113 = load i8, i8* %11
%114 = load i8*, i8** %6
%115 = getelementptr inbounds i8, i8* %114, i64 1
store i8 %113, i8* %115
ret void
}

LLVM IR (-O2):
define void @nand_trans_result(i8 zeroext %0, i8 zeroext %1, i8* nocapture writeonly %2) {
%4 = lshr i8 %0, 1
%5 = and i8 %4, 64
%6 = lshr i8 %1, 1
%7 = and i8 %6, 32
%8 = lshr i8 %0, 2
%9 = and i8 %8, 16
%10 = lshr i8 %1, 2
%11 = and i8 %10, 8
%12 = lshr i8 %0, 3
%13 = and i8 %12, 4
%14 = lshr i8 %1, 3
%15 = and i8 %14, 2
%16 = lshr i8 %0, 4
%17 = and i8 %16, 1
%18 = shl i8 %1, 4
%19 = and i8 %18, -128
%20 = shl i8 %0, 3
%21 = and i8 %20, 64
%22 = or i8 %19, %21
%23 = shl i8 %1, 3
%24 = and i8 %23, 32
%25 = or i8 %22, %24
%26 = shl i8 %0, 2
%27 = and i8 %26, 16
%28 = or i8 %25, %27
%29 = shl i8 %1, 2
%30 = and i8 %29, 8
%31 = or i8 %28, %30
%32 = shl i8 %0, 1
%33 = and i8 %32, 4
%34 = or i8 %31, %33
%35 = shl i8 %1, 1
%36 = and i8 %35, 2
%37 = or i8 %34, %36
%38 = and i8 %0, 1
%39 = or i8 %37, %38
%40 = and i8 %1, -128
%41 = or i8 %40, %5
%42 = or i8 %41, %7
%43 = or i8 %42, %9
%44 = or i8 %43, %11
%45 = or i8 %44, %13
%46 = or i8 %45, %15
%47 = or i8 %46, %17
store i8 %47, i8* %2
%48 = getelementptr inbounds i8, i8* %2, i64 1
store i8 %39, i8* %48
ret void
}