signed int everflourish_find_code(unsigned int x) {
  unsigned int bits[16] = {0xf, 0xa, 0x7, 0xe, 0xf, 0xd, 0x9, 0x1,
                           0x1, 0x2, 0x4, 0x8, 0x3, 0x6, 0xc, 0xb};
  unsigned int bit = 1;
  unsigned int res = 0x5;
  int i;
  unsigned int lo, hi;
  if ((x & 0x3) == 3) {
    lo = x & 0x00ff;
    hi = x & 0xff00;
    lo += 4;
    if (lo > 0x100)
      lo = 0x12;
    x = lo | hi;
  }
  for (i = 0; i < 16; i++) {
    if (x & bit) {
      res = res ^ bits[i];
    }
    bit = bit << 1;
  }
  return res;
}


x86 assembly (clang, -O0):
<everflourish_find_code>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
lea    -0x50(%rbp),%rdi
lea    0xeda(%rip),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
movl   $0x1,-0x54(%rbp)
movl   $0x5,-0x58(%rbp)
mov    -0x4(%rbp),%eax
and    $0x3,%eax
cmp    $0x3,%eax
jne    1189 <everflourish_find_code+0x79>
mov    -0x4(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0x60(%rbp)
mov    -0x4(%rbp),%eax
and    $0xff00,%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x100,-0x60(%rbp)
jbe    1180 <everflourish_find_code+0x70>
movl   $0x12,-0x60(%rbp)
mov    -0x60(%rbp),%eax
or     -0x64(%rbp),%eax
mov    %eax,-0x4(%rbp)
movl   $0x0,-0x5c(%rbp)
cmpl   $0x10,-0x5c(%rbp)
jge    11ce <everflourish_find_code+0xbe>
mov    -0x4(%rbp),%eax
and    -0x54(%rbp),%eax
cmp    $0x0,%eax
je     11b7 <everflourish_find_code+0xa7>
mov    -0x58(%rbp),%eax
movslq -0x5c(%rbp),%rcx
xor    -0x50(%rbp,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1190 <everflourish_find_code+0x80>
mov    -0x58(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<everflourish_find_code>:
mov    %edi,%eax
not    %eax
test   $0x3,%al
jne    1124 <everflourish_find_code+0x24>
movzbl %dil,%eax
and    $0xff00,%edi
lea    0x4(%rax),%ecx
cmp    $0xfd,%eax
mov    $0x12,%eax
cmovb  %ecx,%eax
or     %eax,%edi
mov    %edi,%eax
and    $0x1,%eax
lea    (%rax,%rax,4),%eax
add    $0x5,%eax
mov    %eax,%ecx
xor    $0xa,%ecx
test   $0x2,%dil
cmove  %eax,%ecx
mov    %ecx,%eax
xor    $0x7,%eax
test   $0x4,%dil
cmove  %ecx,%eax
mov    %eax,%ecx
xor    $0xe,%ecx
test   $0x8,%dil
cmove  %eax,%ecx
mov    %ecx,%eax
xor    $0xf,%eax
test   $0x10,%dil
cmove  %ecx,%eax
mov    %eax,%edx
xor    $0xd,%edx
test   $0x20,%dil
cmove  %eax,%edx
mov    %edx,%eax
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xe82(%rip),%xmm1
pand   %xmm0,%xmm1
pand   0xe86(%rip),%xmm0
xor    $0x9,%eax
pxor   %xmm2,%xmm2
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
packssdw %xmm0,%xmm1
packsswb %xmm1,%xmm1
pmovmskb %xmm1,%ecx
test   $0x80,%cl
cmovne %edx,%eax
mov    %edi,%edx
shr    $0x7,%edx
and    $0x1,%edx
shr    $0x8,%edi
and    $0x1,%edi
xor    %edx,%edi
xor    %eax,%edi
mov    %edi,%eax
xor    $0x2,%eax
test   $0x40,%cl
cmovne %edi,%eax
mov    %eax,%edx
xor    $0x4,%edx
test   $0x20,%cl
cmovne %eax,%edx
mov    %edx,%eax
xor    $0x8,%eax
test   $0x10,%cl
cmovne %edx,%eax
mov    %eax,%edx
xor    $0x3,%edx
test   $0x8,%cl
cmovne %eax,%edx
mov    %edx,%eax
xor    $0x6,%eax
test   $0x4,%cl
cmovne %edx,%eax
mov    %eax,%edx
xor    $0xc,%edx
test   $0x2,%cl
cmovne %eax,%edx
mov    %edx,%eax
xor    $0xb,%eax
test   $0x1,%cl
cmovne %edx,%eax
ret

LLVM IR (-O0):
@__const.everflourish_find_code.bits = [16 x i32] [i32 15, i32 10, i32 7, i32 14, i32 15, i32 13, i32 9, i32 1, i32 1, i32 2, i32 4, i32 8, i32 3, i32 6, i32 12, i32 11]
define i32 @everflourish_find_code(i32 %0) {
%2 = alloca i32
%3 = alloca [16 x i32]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32 %0, i32* %2
%9 = bitcast [16 x i32]* %3 to i8*
store i32 1, i32* %4
store i32 5, i32* %5
%10 = load i32, i32* %2
%11 = and i32 %10, 3
%12 = icmp eq i32 %11, 3
br i1 %12, label %13, label %27
13: ; preds = %1
%14 = load i32, i32* %2
%15 = and i32 %14, 255
store i32 %15, i32* %7
%16 = load i32, i32* %2
%17 = and i32 %16, 65280
store i32 %17, i32* %8
%18 = load i32, i32* %7
%19 = add i32 %18, 4
store i32 %19, i32* %7
%20 = load i32, i32* %7
%21 = icmp ugt i32 %20, 256
br i1 %21, label %22, label %23
22: ; preds = %13
store i32 18, i32* %7
br label %23
23: ; preds = %22, %13
%24 = load i32, i32* %7
%25 = load i32, i32* %8
%26 = or i32 %24, %25
store i32 %26, i32* %2
br label %27
27: ; preds = %23, %1
store i32 0, i32* %6
br label %28
28: ; preds = %46, %27
%29 = load i32, i32* %6
%30 = icmp slt i32 %29, 16
br i1 %30, label %31, label %49
31: ; preds = %28
%32 = load i32, i32* %2
%33 = load i32, i32* %4
%34 = and i32 %32, %33
%35 = icmp ne i32 %34, 0
br i1 %35, label %36, label %43
36: ; preds = %31
%37 = load i32, i32* %5
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [16 x i32], [16 x i32]* %3, i64 0, i64 %39
%41 = load i32, i32* %40
%42 = xor i32 %37, %41
store i32 %42, i32* %5
br label %43
43: ; preds = %36, %31
%44 = load i32, i32* %4
%45 = shl i32 %44, 1
store i32 %45, i32* %4
br label %46
46: ; preds = %43
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
br label %28
49: ; preds = %28
%50 = load i32, i32* %5
ret i32 %50
}

LLVM IR (-O2):
define i32 @everflourish_find_code(i32 %0) {
%2 = and i32 %0, 3
%3 = icmp eq i32 %2, 3
br i1 %3, label %4, label %11
4: ; preds = %1
%5 = and i32 %0, 255
%6 = and i32 %0, 65280
%7 = add nuw nsw i32 %5, 4
%8 = icmp ugt i32 %5, 252
%9 = select i1 %8, i32 18, i32 %7
%10 = or i32 %9, %6
br label %11
11: ; preds = %4, %1
%12 = phi i32 [ %10, %4 ], [ %0, %1 ]
%13 = and i32 %12, 1
%14 = icmp eq i32 %13, 0
%15 = select i1 %14, i32 5, i32 10
%16 = and i32 %12, 2
%17 = icmp eq i32 %16, 0
%18 = xor i32 %15, 10
%19 = select i1 %17, i32 %15, i32 %18
%20 = and i32 %12, 4
%21 = icmp eq i32 %20, 0
%22 = xor i32 %19, 7
%23 = select i1 %21, i32 %19, i32 %22
%24 = and i32 %12, 8
%25 = icmp eq i32 %24, 0
%26 = xor i32 %23, 14
%27 = select i1 %25, i32 %23, i32 %26
%28 = and i32 %12, 16
%29 = icmp eq i32 %28, 0
%30 = xor i32 %27, 15
%31 = select i1 %29, i32 %27, i32 %30
%32 = and i32 %12, 32
%33 = icmp eq i32 %32, 0
%34 = xor i32 %31, 13
%35 = select i1 %33, i32 %31, i32 %34
%36 = xor i32 %35, 9
%37 = insertelement <8 x i32> poison, i32 %12, i64 0
%38 = shufflevector <8 x i32> %37, <8 x i32> poison, <8 x i32> zeroinitializer
%39 = and <8 x i32> %38, <i32 32768, i32 16384, i32 8192, i32 4096, i32 2048, i32 1024, i32 512, i32 64>
%40 = icmp eq <8 x i32> %39, zeroinitializer
%41 = extractelement <8 x i1> %40, i64 7
%42 = select i1 %41, i32 %35, i32 %36
%43 = lshr i32 %12, 7
%44 = and i32 %43, 1
%45 = xor i32 %42, %44
%46 = lshr i32 %12, 8
%47 = and i32 %46, 1
%48 = xor i32 %45, %47
%49 = xor i32 %48, 2
%50 = extractelement <8 x i1> %40, i64 6
%51 = select i1 %50, i32 %48, i32 %49
%52 = xor i32 %51, 4
%53 = extractelement <8 x i1> %40, i64 5
%54 = select i1 %53, i32 %51, i32 %52
%55 = xor i32 %54, 8
%56 = extractelement <8 x i1> %40, i64 4
%57 = select i1 %56, i32 %54, i32 %55
%58 = xor i32 %57, 3
%59 = extractelement <8 x i1> %40, i64 3
%60 = select i1 %59, i32 %57, i32 %58
%61 = xor i32 %60, 6
%62 = extractelement <8 x i1> %40, i64 2
%63 = select i1 %62, i32 %60, i32 %61
%64 = xor i32 %63, 12
%65 = extractelement <8 x i1> %40, i64 1
%66 = select i1 %65, i32 %63, i32 %64
%67 = xor i32 %66, 11
%68 = extractelement <8 x i1> %40, i64 0
%69 = select i1 %68, i32 %66, i32 %67
ret i32 %69
}