#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 */
typedef int /*<<< orphan*/ tblfP;
typedef int /*<<< orphan*/ tblEBitSelection;

/* Variables and functions */
unsigned char McbGetSBoxNibble(unsigned char, int);
int /*<<< orphan*/ McbMapTrueBits(unsigned char *, int, unsigned char const *,
                                  unsigned char *);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
void McbMapThroughSBox(const unsigned char Right[4],
                       const unsigned char SubKey[6],
                       unsigned char output32[4]) {
  static unsigned char tblEBitSelection[48] = {
      31, 0,  1,  2,  3,  4,  3,  4,  5,  6,  7,  8,  7,  8,  9,  10,
      11, 12, 11, 12, 13, 14, 15, 16, 15, 16, 17, 18, 19, 20, 19, 20,
      21, 22, 23, 24, 23, 24, 25, 26, 27, 28, 27, 28, 29, 30, 31, 0};
  static unsigned char tblfP[32] = {15, 6, 19, 20, 28, 11, 27, 16, 0,  14, 22,
                                    25, 4, 17, 30, 9,  1,  7,  23, 13, 31, 26,
                                    2,  8, 18, 12, 29, 5,  21, 10, 3,  24};
  unsigned char output48[6];
  unsigned char sbox32[4];
  unsigned char nSboxIndex;
  int n;
  memset(sbox32, 0, 4);
  memset(output48, 0, 6);
  McbMapTrueBits(tblEBitSelection, sizeof(tblEBitSelection), Right, output48);
  for (n = 0; n < 6; n++) {
    output48[n] ^= SubKey[n];
  }
  nSboxIndex = (output48[0] & 0xFC) >> 2;
  sbox32[0] |= McbGetSBoxNibble(nSboxIndex, 0) << 4;
  nSboxIndex = ((output48[0] & 0x03) << 4) | ((output48[1] & 0xFC) >> 4);
  sbox32[0] |= McbGetSBoxNibble(nSboxIndex, 1);
  nSboxIndex = ((output48[1] & 0x0F) << 2) | ((output48[2] & 0xC0) >> 6);
  sbox32[1] |= McbGetSBoxNibble(nSboxIndex, 2) << 4;
  nSboxIndex = (output48[2] & 0x3F);
  sbox32[1] |= McbGetSBoxNibble(nSboxIndex, 3);
  nSboxIndex = (output48[3] & 0xFC) >> 2;
  sbox32[2] |= McbGetSBoxNibble(nSboxIndex, 4) << 4;
  nSboxIndex = ((output48[3] & 0x03) << 4) | ((output48[4] & 0xFC) >> 4);
  sbox32[2] |= McbGetSBoxNibble(nSboxIndex, 5);
  nSboxIndex = ((output48[4] & 0x0F) << 2) | ((output48[5] & 0xC0) >> 6);
  sbox32[3] |= McbGetSBoxNibble(nSboxIndex, 6) << 4;
  nSboxIndex = (output48[5] & 0x3F);
  sbox32[3] |= McbGetSBoxNibble(nSboxIndex, 7);
  memset(output32, 0, 4);
  McbMapTrueBits(tblfP, sizeof(tblfP), sbox32, output32);
}


x86 assembly (clang, -O0):
<McbMapThroughSBox>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x22(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    -0x1e(%rbp),%rdi
xor    %esi,%esi
mov    $0x6,%edx
call   1030 <memset@plt>
mov    -0x8(%rbp),%rdx
lea    -0x1e(%rbp),%rcx
lea    0x2ecd(%rip),%rdi
mov    $0x30,%esi
call   1040 <McbMapTrueBits@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x6,-0x28(%rbp)
jge    11b7 <McbMapThroughSBox+0x87>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x28(%rbp),%rax
movzbl -0x1e(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x1e(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1184 <McbMapThroughSBox+0x54>
movzbl -0x1e(%rbp),%eax
and    $0xfc,%eax
sar    $0x2,%eax
mov    %al,-0x23(%rbp)
xor    %esi,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
shl    $0x4,%ecx
movzbl -0x22(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x1e(%rbp),%eax
and    $0x3,%eax
shl    $0x4,%eax
movzbl -0x1d(%rbp),%ecx
and    $0xfc,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,-0x23(%rbp)
mov    $0x1,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
movzbl -0x22(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x22(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xf,%eax
shl    $0x2,%eax
movzbl -0x1c(%rbp),%ecx
and    $0xc0,%ecx
sar    $0x6,%ecx
or     %ecx,%eax
mov    %al,-0x23(%rbp)
mov    $0x2,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
shl    $0x4,%ecx
movzbl -0x21(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x21(%rbp)
movzbl -0x1c(%rbp),%eax
and    $0x3f,%eax
mov    %al,-0x23(%rbp)
mov    $0x3,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
movzbl -0x21(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x21(%rbp)
movzbl -0x1b(%rbp),%eax
and    $0xfc,%eax
sar    $0x2,%eax
mov    %al,-0x23(%rbp)
mov    $0x4,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
shl    $0x4,%ecx
movzbl -0x20(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x20(%rbp)
movzbl -0x1b(%rbp),%eax
and    $0x3,%eax
shl    $0x4,%eax
movzbl -0x1a(%rbp),%ecx
and    $0xfc,%ecx
sar    $0x4,%ecx
or     %ecx,%eax
mov    %al,-0x23(%rbp)
mov    $0x5,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
movzbl -0x20(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x20(%rbp)
movzbl -0x1a(%rbp),%eax
and    $0xf,%eax
shl    $0x2,%eax
movzbl -0x19(%rbp),%ecx
and    $0xc0,%ecx
sar    $0x6,%ecx
or     %ecx,%eax
mov    %al,-0x23(%rbp)
mov    $0x6,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
shl    $0x4,%ecx
movzbl -0x1f(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x1f(%rbp)
movzbl -0x19(%rbp),%eax
and    $0x3f,%eax
mov    %al,-0x23(%rbp)
mov    $0x7,%esi
movzbl -0x23(%rbp),%edi
call   1050 <McbGetSBoxNibble@plt>
movzbl %al,%ecx
movzbl -0x1f(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x1f(%rbp)
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    -0x22(%rbp),%rdx
mov    -0x18(%rbp),%rcx
lea    0x2d1f(%rip),%rdi
mov    $0x20,%esi
call   1040 <McbMapTrueBits@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<McbMapThroughSBox>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r12
lea    0xc(%rsp),%r14
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    0x6(%rsp),%r13
mov    %r13,%rdi
xor    %esi,%esi
mov    $0x6,%edx
call   1030 <memset@plt>
lea    0x2ecb(%rip),%rdi
mov    $0x30,%esi
mov    %r12,%rdx
mov    %r13,%rcx
call   1040 <McbMapTrueBits@plt>
mov    0x6(%rsp),%al
xor    (%rbx),%al
mov    %al,0x6(%rsp)
mov    0x1(%rbx),%cl
xor    %cl,0x7(%rsp)
mov    0x2(%rbx),%cl
xor    %cl,0x8(%rsp)
mov    0x3(%rbx),%cl
xor    %cl,0x9(%rsp)
mov    0x4(%rbx),%cl
xor    %cl,0xa(%rsp)
mov    0x5(%rbx),%cl
xor    %cl,0xb(%rsp)
shr    $0x2,%al
movzbl %al,%edi
xor    %esi,%esi
call   1050 <McbGetSBoxNibble@plt>
shl    $0x4,%al
or     %al,0xc(%rsp)
mov    0x6(%rsp),%al
mov    0x7(%rsp),%cl
shr    $0x4,%cl
shl    $0x4,%al
or     %cl,%al
and    $0x3f,%al
movzbl %al,%edi
mov    $0x1,%esi
call   1050 <McbGetSBoxNibble@plt>
or     %al,0xc(%rsp)
mov    0x7(%rsp),%al
mov    0x8(%rsp),%cl
shr    $0x6,%cl
shl    $0x2,%al
or     %cl,%al
and    $0x3f,%al
movzbl %al,%edi
mov    $0x2,%esi
call   1050 <McbGetSBoxNibble@plt>
shl    $0x4,%al
or     %al,0xd(%rsp)
movzbl 0x8(%rsp),%edi
and    $0x3f,%edi
mov    $0x3,%esi
call   1050 <McbGetSBoxNibble@plt>
or     %al,0xd(%rsp)
mov    0x9(%rsp),%al
shr    $0x2,%al
movzbl %al,%edi
mov    $0x4,%esi
call   1050 <McbGetSBoxNibble@plt>
shl    $0x4,%al
or     %al,0xe(%rsp)
mov    0x9(%rsp),%al
mov    0xa(%rsp),%cl
shr    $0x4,%cl
shl    $0x4,%al
or     %cl,%al
and    $0x3f,%al
movzbl %al,%edi
mov    $0x5,%esi
call   1050 <McbGetSBoxNibble@plt>
or     %al,0xe(%rsp)
mov    0xa(%rsp),%al
mov    0xb(%rsp),%cl
shr    $0x6,%cl
shl    $0x2,%al
or     %cl,%al
and    $0x3f,%al
movzbl %al,%edi
mov    $0x6,%esi
call   1050 <McbGetSBoxNibble@plt>
shl    $0x4,%al
or     %al,0xf(%rsp)
movzbl 0xb(%rsp),%edi
and    $0x3f,%edi
mov    $0x7,%esi
call   1050 <McbGetSBoxNibble@plt>
or     %al,0xf(%rsp)
mov    %r15,%rdi
xor    %esi,%esi
mov    $0x4,%edx
call   1030 <memset@plt>
lea    0x2dbb(%rip),%rdi
mov    $0x20,%esi
mov    %r14,%rdx
mov    %r15,%rcx
call   1040 <McbMapTrueBits@plt>
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@McbMapThroughSBox.tblEBitSelection = internal global [48 x i8] c"\1F\00\01\02\03\04\03\04\05\06\07\08\07\08\09\0A\0B\0C\0B\0C\0D\0E\0F\10\0F\10\11\12\13\14\13\14\15\16\17\18\17\18\19\1A\1B\1C\1B\1C\1D\1E\1F\00"
@McbMapThroughSBox.tblfP = internal global [32 x i8] c"\0F\06\13\14\1C\0B\1B\10\00\0E\16\19\04\11\1E\09\01\07\17\0D\1F\1A\02\08\12\0C\1D\05\15\0A\03\18"
define void @McbMapThroughSBox(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca [6 x i8]
%8 = alloca [4 x i8]
%9 = alloca i8
%10 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%11 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 0
%12 = call i32 @memset(i8* %11, i32 0, i32 4)
%13 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 0
%14 = call i32 @memset(i8* %13, i32 0, i32 6)
%15 = load i8*, i8** %4
%16 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 0
%17 = call i32 @McbMapTrueBits(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @McbMapThroughSBox.tblEBitSelection, i64 0, i64 0), i32 48, i8* %15, i8* %16)
store i32 0, i32* %10
br label %18
18: ; preds = %35, %3
%19 = load i32, i32* %10
%20 = icmp slt i32 %19, 6
br i1 %20, label %21, label %38
21: ; preds = %18
%22 = load i8*, i8** %5
%23 = load i32, i32* %10
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
%26 = load i8, i8* %25
%27 = zext i8 %26 to i32
%28 = load i32, i32* %10
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = zext i8 %31 to i32
%33 = xor i32 %32, %27
%34 = trunc i32 %33 to i8
store i8 %34, i8* %30
br label %35
35: ; preds = %21
%36 = load i32, i32* %10
%37 = add nsw i32 %36, 1
store i32 %37, i32* %10
br label %18
38: ; preds = %18
%39 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 0
%40 = load i8, i8* %39
%41 = zext i8 %40 to i32
%42 = and i32 %41, 252
%43 = ashr i32 %42, 2
%44 = trunc i32 %43 to i8
store i8 %44, i8* %9
%45 = load i8, i8* %9
%46 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %45, i32 0)
%47 = zext i8 %46 to i32
%48 = shl i32 %47, 4
%49 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 0
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = or i32 %51, %48
%53 = trunc i32 %52 to i8
store i8 %53, i8* %49
%54 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 0
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = and i32 %56, 3
%58 = shl i32 %57, 4
%59 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 1
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = and i32 %61, 252
%63 = ashr i32 %62, 4
%64 = or i32 %58, %63
%65 = trunc i32 %64 to i8
store i8 %65, i8* %9
%66 = load i8, i8* %9
%67 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %66, i32 1)
%68 = zext i8 %67 to i32
%69 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 0
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = or i32 %71, %68
%73 = trunc i32 %72 to i8
store i8 %73, i8* %69
%74 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 1
%75 = load i8, i8* %74
%76 = zext i8 %75 to i32
%77 = and i32 %76, 15
%78 = shl i32 %77, 2
%79 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 2
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
%82 = and i32 %81, 192
%83 = ashr i32 %82, 6
%84 = or i32 %78, %83
%85 = trunc i32 %84 to i8
store i8 %85, i8* %9
%86 = load i8, i8* %9
%87 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %86, i32 2)
%88 = zext i8 %87 to i32
%89 = shl i32 %88, 4
%90 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 1
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = or i32 %92, %89
%94 = trunc i32 %93 to i8
store i8 %94, i8* %90
%95 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 2
%96 = load i8, i8* %95
%97 = zext i8 %96 to i32
%98 = and i32 %97, 63
%99 = trunc i32 %98 to i8
store i8 %99, i8* %9
%100 = load i8, i8* %9
%101 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %100, i32 3)
%102 = zext i8 %101 to i32
%103 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 1
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = or i32 %105, %102
%107 = trunc i32 %106 to i8
store i8 %107, i8* %103
%108 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 3
%109 = load i8, i8* %108
%110 = zext i8 %109 to i32
%111 = and i32 %110, 252
%112 = ashr i32 %111, 2
%113 = trunc i32 %112 to i8
store i8 %113, i8* %9
%114 = load i8, i8* %9
%115 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %114, i32 4)
%116 = zext i8 %115 to i32
%117 = shl i32 %116, 4
%118 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 2
%119 = load i8, i8* %118
%120 = zext i8 %119 to i32
%121 = or i32 %120, %117
%122 = trunc i32 %121 to i8
store i8 %122, i8* %118
%123 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 3
%124 = load i8, i8* %123
%125 = zext i8 %124 to i32
%126 = and i32 %125, 3
%127 = shl i32 %126, 4
%128 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 4
%129 = load i8, i8* %128
%130 = zext i8 %129 to i32
%131 = and i32 %130, 252
%132 = ashr i32 %131, 4
%133 = or i32 %127, %132
%134 = trunc i32 %133 to i8
store i8 %134, i8* %9
%135 = load i8, i8* %9
%136 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %135, i32 5)
%137 = zext i8 %136 to i32
%138 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 2
%139 = load i8, i8* %138
%140 = zext i8 %139 to i32
%141 = or i32 %140, %137
%142 = trunc i32 %141 to i8
store i8 %142, i8* %138
%143 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 4
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = and i32 %145, 15
%147 = shl i32 %146, 2
%148 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 5
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = and i32 %150, 192
%152 = ashr i32 %151, 6
%153 = or i32 %147, %152
%154 = trunc i32 %153 to i8
store i8 %154, i8* %9
%155 = load i8, i8* %9
%156 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %155, i32 6)
%157 = zext i8 %156 to i32
%158 = shl i32 %157, 4
%159 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 3
%160 = load i8, i8* %159
%161 = zext i8 %160 to i32
%162 = or i32 %161, %158
%163 = trunc i32 %162 to i8
store i8 %163, i8* %159
%164 = getelementptr inbounds [6 x i8], [6 x i8]* %7, i64 0, i64 5
%165 = load i8, i8* %164
%166 = zext i8 %165 to i32
%167 = and i32 %166, 63
%168 = trunc i32 %167 to i8
store i8 %168, i8* %9
%169 = load i8, i8* %9
%170 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %169, i32 7)
%171 = zext i8 %170 to i32
%172 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 3
%173 = load i8, i8* %172
%174 = zext i8 %173 to i32
%175 = or i32 %174, %171
%176 = trunc i32 %175 to i8
store i8 %176, i8* %172
%177 = load i8*, i8** %6
%178 = call i32 @memset(i8* %177, i32 0, i32 4)
%179 = getelementptr inbounds [4 x i8], [4 x i8]* %8, i64 0, i64 0
%180 = load i8*, i8** %6
%181 = call i32 @McbMapTrueBits(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @McbMapThroughSBox.tblfP, i64 0, i64 0), i32 32, i8* %179, i8* %180)
ret void
}

LLVM IR (-O2):
@McbMapThroughSBox.tblEBitSelection = internal global [48 x i8] c"\1F\00\01\02\03\04\03\04\05\06\07\08\07\08\09\0A\0B\0C\0B\0C\0D\0E\0F\10\0F\10\11\12\13\14\13\14\15\16\17\18\17\18\19\1A\1B\1C\1B\1C\1D\1E\1F\00"
@McbMapThroughSBox.tblfP = internal global [32 x i8] c"\0F\06\13\14\1C\0B\1B\10\00\0E\16\19\04\11\1E\09\01\07\17\0D\1F\1A\02\08\12\0C\1D\05\15\0A\03\18"
define void @McbMapThroughSBox(i8* %0, i8* nocapture %1, i8* %2) {
%4 = alloca [6 x i8]
%5 = alloca [4 x i8]
%6 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 0
%7 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 0
%8 = call i32 @memset(i8* %7, i32 0, i32 4)
%9 = call i32 @memset(i8* %6, i32 0, i32 6)
%10 = call i32 @McbMapTrueBits(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @McbMapThroughSBox.tblEBitSelection, i64 0, i64 0), i32 48, i8* %0, i8* %6)
%11 = load i8, i8* %1
%12 = load i8, i8* %6
%13 = xor i8 %12, %11
store i8 %13, i8* %6
%14 = getelementptr inbounds i8, i8* %1, i64 1
%15 = load i8, i8* %14
%16 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 1
%17 = load i8, i8* %16
%18 = xor i8 %17, %15
store i8 %18, i8* %16
%19 = getelementptr inbounds i8, i8* %1, i64 2
%20 = load i8, i8* %19
%21 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 2
%22 = load i8, i8* %21
%23 = xor i8 %22, %20
store i8 %23, i8* %21
%24 = getelementptr inbounds i8, i8* %1, i64 3
%25 = load i8, i8* %24
%26 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 3
%27 = load i8, i8* %26
%28 = xor i8 %27, %25
store i8 %28, i8* %26
%29 = getelementptr inbounds i8, i8* %1, i64 4
%30 = load i8, i8* %29
%31 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 4
%32 = load i8, i8* %31
%33 = xor i8 %32, %30
store i8 %33, i8* %31
%34 = getelementptr inbounds i8, i8* %1, i64 5
%35 = load i8, i8* %34
%36 = getelementptr inbounds [6 x i8], [6 x i8]* %4, i64 0, i64 5
%37 = load i8, i8* %36
%38 = xor i8 %37, %35
store i8 %38, i8* %36
%39 = lshr i8 %13, 2
%40 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %39, i32 0)
%41 = shl i8 %40, 4
%42 = load i8, i8* %7
%43 = or i8 %41, %42
store i8 %43, i8* %7
%44 = load i8, i8* %6
%45 = shl i8 %44, 4
%46 = and i8 %45, 48
%47 = load i8, i8* %16
%48 = lshr i8 %47, 4
%49 = or i8 %46, %48
%50 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %49, i32 1)
%51 = load i8, i8* %7
%52 = or i8 %51, %50
store i8 %52, i8* %7
%53 = load i8, i8* %16
%54 = shl i8 %53, 2
%55 = and i8 %54, 60
%56 = load i8, i8* %21
%57 = lshr i8 %56, 6
%58 = or i8 %55, %57
%59 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %58, i32 2)
%60 = shl i8 %59, 4
%61 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 1
%62 = load i8, i8* %61
%63 = or i8 %60, %62
store i8 %63, i8* %61
%64 = load i8, i8* %21
%65 = and i8 %64, 63
%66 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %65, i32 3)
%67 = load i8, i8* %61
%68 = or i8 %67, %66
store i8 %68, i8* %61
%69 = load i8, i8* %26
%70 = lshr i8 %69, 2
%71 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %70, i32 4)
%72 = shl i8 %71, 4
%73 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 2
%74 = load i8, i8* %73
%75 = or i8 %72, %74
store i8 %75, i8* %73
%76 = load i8, i8* %26
%77 = shl i8 %76, 4
%78 = and i8 %77, 48
%79 = load i8, i8* %31
%80 = lshr i8 %79, 4
%81 = or i8 %78, %80
%82 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %81, i32 5)
%83 = load i8, i8* %73
%84 = or i8 %83, %82
store i8 %84, i8* %73
%85 = load i8, i8* %31
%86 = shl i8 %85, 2
%87 = and i8 %86, 60
%88 = load i8, i8* %36
%89 = lshr i8 %88, 6
%90 = or i8 %87, %89
%91 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %90, i32 6)
%92 = shl i8 %91, 4
%93 = getelementptr inbounds [4 x i8], [4 x i8]* %5, i64 0, i64 3
%94 = load i8, i8* %93
%95 = or i8 %92, %94
store i8 %95, i8* %93
%96 = load i8, i8* %36
%97 = and i8 %96, 63
%98 = call zeroext i8 @McbGetSBoxNibble(i8 zeroext %97, i32 7)
%99 = load i8, i8* %93
%100 = or i8 %99, %98
store i8 %100, i8* %93
%101 = call i32 @memset(i8* %2, i32 0, i32 4)
%102 = call i32 @McbMapTrueBits(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @McbMapThroughSBox.tblfP, i64 0, i64 0), i32 32, i8* %7, i8* %2)
ret void
}