void EncodeRegBits(int regnum, char *modbyte, int nshift) {
  switch (regnum) {
  case 129:
  case 130:
  case 154:
  case 161:
  case 137:
  case 146:
    break;
  case 136:
  case 142:
  case 157:
  case 141:
  case 138:
  case 147:
    *modbyte |= (1 << nshift);
    break;
  case 145:
  case 153:
  case 159:
  case 167:
  case 139:
  case 148:
    *modbyte |= (2 << nshift);
    break;
  case 132:
  case 134:
  case 156:
  case 152:
  case 140:
  case 149:
    *modbyte |= (3 << nshift);
    break;
  case 128:
  case 166:
  case 162:
    *modbyte |= (4 << nshift);
    break;
  case 135:
  case 133:
  case 155:
  case 163:
    *modbyte |= (5 << nshift);
    break;
  case 143:
  case 165:
  case 160:
  case 164:
  case 168:
  case 150:
    *modbyte |= (6 << nshift);
    break;
  case 131:
  case 144:
  case 158:
  case 169:
  case 151:
    *modbyte |= (7 << nshift);
    break;
  default:;
  }
}


x86 assembly (clang, -O0):
<EncodeRegBits>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x4(%rbp),%eax
add    $0xffffff80,%eax
mov    %eax,%ecx
mov    %rcx,-0x20(%rbp)
sub    $0x29,%eax
ja     11f2 <EncodeRegBits+0xf2>
mov    -0x20(%rbp),%rax
lea    0xed2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x2,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x3,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x4,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x5,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x6,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
mov    -0x14(%rbp),%ecx
mov    $0x7,%edx
shl    %cl,%edx
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
or     %edx,%ecx
mov    %cl,(%rax)
jmp    11f7 <EncodeRegBits+0xf7>
jmp    11f7 <EncodeRegBits+0xf7>
pop    %rbp
ret

x86 assembly (clang, -O2):
<EncodeRegBits>:
add    $0xffffff80,%edi
cmp    $0x29,%edi
ja     112b <EncodeRegBits+0x2b>
movabs $0x3fdfbfbfdf9,%rax
bt     %rdi,%rax
jae    112b <EncodeRegBits+0x2b>
movslq %edi,%rax
lea    0xede(%rip),%rcx
mov    (%rcx,%rax,4),%eax
mov    %edx,%ecx
shl    %cl,%eax
or     %al,(%rsi)
ret

LLVM IR (-O0):
define void @EncodeRegBits(i32 %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
store i32 %0, i32* %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%7 = load i32, i32* %4
switch i32 %7, label %65 [
i32 129, label %8
i32 130, label %8
i32 154, label %8
i32 161, label %8
i32 137, label %8
i32 146, label %8
i32 136, label %9
i32 142, label %9
i32 157, label %9
i32 141, label %9
i32 138, label %9
i32 147, label %9
i32 145, label %17
i32 153, label %17
i32 159, label %17
i32 167, label %17
i32 139, label %17
i32 148, label %17
i32 132, label %25
i32 134, label %25
i32 156, label %25
i32 152, label %25
i32 140, label %25
i32 149, label %25
i32 128, label %33
i32 166, label %33
i32 162, label %33
i32 135, label %41
i32 133, label %41
i32 155, label %41
i32 163, label %41
i32 143, label %49
i32 165, label %49
i32 160, label %49
i32 164, label %49
i32 168, label %49
i32 150, label %49
i32 131, label %57
i32 144, label %57
i32 158, label %57
i32 169, label %57
i32 151, label %57
]
8: ; preds = %3, %3, %3, %3, %3, %3
br label %66
9: ; preds = %3, %3, %3, %3, %3, %3
%10 = load i32, i32* %6
%11 = shl i32 1, %10
%12 = load i8*, i8** %5
%13 = load i8, i8* %12
%14 = sext i8 %13 to i32
%15 = or i32 %14, %11
%16 = trunc i32 %15 to i8
store i8 %16, i8* %12
br label %66
17: ; preds = %3, %3, %3, %3, %3, %3
%18 = load i32, i32* %6
%19 = shl i32 2, %18
%20 = load i8*, i8** %5
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = or i32 %22, %19
%24 = trunc i32 %23 to i8
store i8 %24, i8* %20
br label %66
25: ; preds = %3, %3, %3, %3, %3, %3
%26 = load i32, i32* %6
%27 = shl i32 3, %26
%28 = load i8*, i8** %5
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = or i32 %30, %27
%32 = trunc i32 %31 to i8
store i8 %32, i8* %28
br label %66
33: ; preds = %3, %3, %3
%34 = load i32, i32* %6
%35 = shl i32 4, %34
%36 = load i8*, i8** %5
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = or i32 %38, %35
%40 = trunc i32 %39 to i8
store i8 %40, i8* %36
br label %66
41: ; preds = %3, %3, %3, %3
%42 = load i32, i32* %6
%43 = shl i32 5, %42
%44 = load i8*, i8** %5
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
%47 = or i32 %46, %43
%48 = trunc i32 %47 to i8
store i8 %48, i8* %44
br label %66
49: ; preds = %3, %3, %3, %3, %3, %3
%50 = load i32, i32* %6
%51 = shl i32 6, %50
%52 = load i8*, i8** %5
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = or i32 %54, %51
%56 = trunc i32 %55 to i8
store i8 %56, i8* %52
br label %66
57: ; preds = %3, %3, %3, %3, %3
%58 = load i32, i32* %6
%59 = shl i32 7, %58
%60 = load i8*, i8** %5
%61 = load i8, i8* %60
%62 = sext i8 %61 to i32
%63 = or i32 %62, %59
%64 = trunc i32 %63 to i8
store i8 %64, i8* %60
br label %66
65: ; preds = %3
br label %66
66: ; preds = %65, %57, %49, %41, %33, %25, %17, %9, %8
ret void
}

LLVM IR (-O2):
@switch.table.EncodeRegBits = [42 x i32] [i32 4, i32 7, i32 7, i32 7, i32 3, i32 5, i32 3, i32 5, i32 1, i32 7, i32 1, i32 2, i32 3, i32 1, i32 1, i32 6, i32 7, i32 2, i32 7, i32 1, i32 2, i32 3, i32 6, i32 7, i32 3, i32 2, i32 7, i32 5, i32 3, i32 1, i32 7, i32 2, i32 6, i32 7, i32 4, i32 5, i32 6, i32 6, i32 4, i32 2, i32 6, i32 7]
define void @EncodeRegBits(i32 %0, i8* nocapture %1, i32 %2) {
%4 = add i32 %0, -128
%5 = icmp ult i32 %4, 42
br i1 %5, label %6, label %19
6: ; preds = %3
%7 = zext i32 %4 to i64
%8 = lshr i64 4389389204985, %7
%9 = and i64 %8, 1
%10 = icmp eq i64 %9, 0
br i1 %10, label %19, label %11
11: ; preds = %6
%12 = sext i32 %4 to i64
%13 = getelementptr inbounds [42 x i32], [42 x i32]* @switch.table.EncodeRegBits, i64 0, i64 %12
%14 = load i32, i32* %13
%15 = shl i32 %14, %2
%16 = load i8, i8* %1
%17 = trunc i32 %15 to i8
%18 = or i8 %16, %17
store i8 %18, i8* %1
br label %19
19: ; preds = %6, %3, %11
ret void
}