#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 */

/* Variables and functions */
int /*<<< orphan*/ jit_assert(int);
int encode_vfp_double(int mov, int inv, unsigned lo, unsigned hi) {
  int code, mode, imm, mask;
  if (!0)
    return -1;
  if (hi != lo) {
    if (mov && !inv) {
      for (mode = 0, mask = 0xff; mode < 4; mask <<= 8, mode++) {
        imm = lo & mask;
        if (imm != mask && imm != 0)
          goto fail;
        imm = hi & mask;
        if (imm != mask && imm != 0)
          goto fail;
      }
      mode = 0xe20;
      imm = (((hi & 0x80000000) >> 24) | ((hi & 0x00800000) >> 17) |
             ((hi & 0x00008000) >> 10) | ((hi & 0x00000080) >> 3) |
             ((lo & 0x80000000) >> 28) | ((lo & 0x00800000) >> 21) |
             ((lo & 0x00008000) >> 14) | ((lo & 0x00000080) >> 7));
      goto success;
    }
    goto fail;
  }
  for (mode = 0, mask = 0xff; mode < 4; mask <<= 8, mode++) {
    if ((lo & mask) == lo) {
      imm = lo >> (mode << 3);
      mode <<= 9;
      goto success;
    }
  }
  for (mode = 0, mask = 0xff; mode < 2; mask <<= 8, mode++) {
    if ((lo & mask) && ((lo & (mask << 16)) >> 16) == (lo & mask)) {
      imm = lo >> (mode << 3);
      mode = 0x800 | (mode << 9);
      goto success;
    }
  }
  if (mov) {
    for (mode = 0, mask = 0xff; mode < 2; mask = (mask << 8) | 0xff, mode++) {
      if ((lo & mask) == mask && !((lo & ~mask) >> 8) &&
          (imm = lo >> (8 + (mode << 8)))) {
        mode = 0xc00 | (mode << 8);
        goto success;
      }
    }
    if (!inv) {
      if ((lo & 0x7ffff) == 0 && (((lo & 0x7e000000) == 0x3e000000) ||
                                  ((lo & 0x7e000000) == 0x40000000))) {
        mode = 0xf00;
        imm = ((lo >> 24) & 0x80) | ((lo >> 19) & 0x7f);
        goto success;
      }
    }
  }
fail:
  return (-1);
success:
  code = inv ? 0x02800030 : 0x02800010;
  switch ((mode & 0xf00) >> 8) {
  case 0x0:
  case 0x2:
  case 0x4:
  case 0x6:
  case 0x8:
  case 0xa:
    if (inv)
      mode |= 0x20;
    if (!mov)
      mode |= 0x100;
    break;
  case 0x1:
  case 0x3:
  case 0x5:
  case 0x7:
    jit_assert(!inv);
  case 0x9:
  case 0xb:
    jit_assert(!mov);
    break;
  case 0xc:
  case 0xd:
    jit_assert(inv);
  case 0xe:
    jit_assert(mode & 0x20);
    jit_assert(mov && !inv);
    break;
  default:
    jit_assert(!(mode & 0x20));
    break;
  }
  imm = ((imm & 0x80) << 17) | ((imm & 0x70) << 12) | (imm & 0x0f);
  code |= mode | imm;
  if (0) {
    if (code & 0x1000000)
      code |= 0xff000000;
    else
      code |= 0xef000000;
  } else
    code |= 0xf0000000;
  return (code);
}


x86 assembly (clang, -O0):
<encode_vfp_double>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<encode_vfp_double>:
mov    $0xffffffff,%eax
ret

LLVM IR (-O0):
define i32 @encode_vfp_double(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 -1, i32* %5
br label %91
14: ; No predecessors!
store i32 -1, i32* %5
br label %91
15: ; No predecessors!
%16 = load i32, i32* %7
%17 = icmp ne i32 %16, 0
%18 = zext i1 %17 to i64
%19 = select i1 %17, i32 41943088, i32 41943056
store i32 %19, i32* %10
%20 = load i32, i32* %11
%21 = and i32 %20, 3840
%22 = ashr i32 %21, 8
switch i32 %22, label %65 [
i32 0, label %23
i32 2, label %23
i32 4, label %23
i32 6, label %23
i32 8, label %23
i32 10, label %23
i32 1, label %36
i32 3, label %36
i32 5, label %36
i32 7, label %36
i32 9, label %42
i32 11, label %42
i32 12, label %48
i32 13, label %48
i32 14, label %51
]
23: ; preds = %15, %15, %15, %15, %15, %15
%24 = load i32, i32* %7
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %29
26: ; preds = %23
%27 = load i32, i32* %11
%28 = or i32 %27, 32
store i32 %28, i32* %11
br label %29
29: ; preds = %26, %23
%30 = load i32, i32* %6
%31 = icmp ne i32 %30, 0
br i1 %31, label %35, label %32
32: ; preds = %29
%33 = load i32, i32* %11
%34 = or i32 %33, 256
store i32 %34, i32* %11
br label %35
35: ; preds = %32, %29
br label %72
36: ; preds = %15, %15, %15, %15
%37 = load i32, i32* %7
%38 = icmp ne i32 %37, 0
%39 = xor i1 %38, true
%40 = zext i1 %39 to i32
%41 = call i32 @jit_assert(i32 %40)
br label %42
42: ; preds = %15, %15, %36
%43 = load i32, i32* %6
%44 = icmp ne i32 %43, 0
%45 = xor i1 %44, true
%46 = zext i1 %45 to i32
%47 = call i32 @jit_assert(i32 %46)
br label %72
48: ; preds = %15, %15
%49 = load i32, i32* %7
%50 = call i32 @jit_assert(i32 %49)
br label %51
51: ; preds = %15, %48
%52 = load i32, i32* %11
%53 = and i32 %52, 32
%54 = call i32 @jit_assert(i32 %53)
%55 = load i32, i32* %6
%56 = icmp ne i32 %55, 0
br i1 %56, label %57, label %61
57: ; preds = %51
%58 = load i32, i32* %7
%59 = icmp ne i32 %58, 0
%60 = xor i1 %59, true
br label %61
61: ; preds = %57, %51
%62 = phi i1 [ false, %51 ], [ %60, %57 ]
%63 = zext i1 %62 to i32
%64 = call i32 @jit_assert(i32 %63)
br label %72
65: ; preds = %15
%66 = load i32, i32* %11
%67 = and i32 %66, 32
%68 = icmp ne i32 %67, 0
%69 = xor i1 %68, true
%70 = zext i1 %69 to i32
%71 = call i32 @jit_assert(i32 %70)
br label %72
72: ; preds = %65, %61, %42, %35
%73 = load i32, i32* %12
%74 = and i32 %73, 128
%75 = shl i32 %74, 17
%76 = load i32, i32* %12
%77 = and i32 %76, 112
%78 = shl i32 %77, 12
%79 = or i32 %75, %78
%80 = load i32, i32* %12
%81 = and i32 %80, 15
%82 = or i32 %79, %81
store i32 %82, i32* %12
%83 = load i32, i32* %11
%84 = load i32, i32* %12
%85 = or i32 %83, %84
%86 = load i32, i32* %10
%87 = or i32 %86, %85
store i32 %87, i32* %10
%88 = load i32, i32* %10
%89 = or i32 %88, -268435456
store i32 %89, i32* %10
%90 = load i32, i32* %10
store i32 %90, i32* %5
br label %91
91: ; preds = %72, %14, %4
%92 = load i32, i32* %5
ret i32 %92
}

LLVM IR (-O2):
define i32 @encode_vfp_double(i32 %0, i32 %1, i32 %2, i32 %3) {
ret i32 -1
}