;;; TOOL: run-wasm2c
;;; ARGS0: --debug-names
;;; ARGS*: --enable-tail-call
(type $i32_f32 (func (param i32 f32)))
(import "spectest" "print_i32_f32" (func $print_i32_f32 (type $i32_f32)))
(table $tab funcref (elem $print_i32_f32))
(func (export "tailcaller")
  (return_call_indirect (type $i32_f32)
    (i32.const 1) (f32.const 2.0) (i32.const 0)))
(func $infiniteloop (param i32 f64) (result i32 f64)
  (return_call $infiniteloop (local.get 0) (local.get 1)))
(;; STDOUT ;;;
/* Automatically generated by wasm2c */
#ifndef WASM_H_GENERATED_
#define WASM_H_GENERATED_

#include "wasm-rt.h"

#include <stdint.h>

#ifndef WASM_RT_CORE_TYPES_DEFINED
#define WASM_RT_CORE_TYPES_DEFINED
typedef uint8_t u8;
typedef int8_t s8;
typedef uint16_t u16;
typedef int16_t s16;
typedef uint32_t u32;
typedef int32_t s32;
typedef uint64_t u64;
typedef int64_t s64;
typedef float f32;
typedef double f64;
#endif

#ifdef __cplusplus
extern "C" {
#endif

struct w2c_spectest;

typedef struct w2c_test {
  struct w2c_spectest* w2c_spectest_instance;
  wasm_rt_funcref_table_t w2c_tab;
} w2c_test;

void wasm2c_test_instantiate(w2c_test*, struct w2c_spectest*);
void wasm2c_test_free(w2c_test*);
wasm_rt_func_type_t wasm2c_test_get_func_type(uint32_t param_count, uint32_t result_count, ...);

#ifndef wasm_multi_id
#define wasm_multi_id wasm_multi_id
struct wasm_multi_id {
  u32 i0;
  f64 d1;
};
#endif  /* wasm_multi_id */

/* import: 'spectest' 'print_i32_f32' */
void w2c_spectest_print_i32_f32(struct w2c_spectest*, u32, f32);
void wasm_tailcall_w2c_spectest_print_i32_f32(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

/* export: 'tailcaller' */
void w2c_test_tailcaller(w2c_test*);

/* export for tail-call of 'tailcaller' */
void wasm_tailcall_w2c_test_tailcaller(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

#ifdef __cplusplus
}
#endif

#endif  /* WASM_H_GENERATED_ */
/* Automatically generated by wasm2c */
#include <assert.h>
#include <math.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
#if defined(__MINGW32__)
#include <malloc.h>
#elif defined(_MSC_VER)
#include <intrin.h>
#include <malloc.h>
#define alloca _alloca
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
#include <stdlib.h>
#else
#include <alloca.h>
#endif

#include "wasm.h"

// Computes a pointer to an object of the given size in a little-endian memory.
//
// On a little-endian host, this is just &mem->data[addr] - the object's size is
// unused. On a big-endian host, it's &mem->data[mem->size - addr - n], where n
// is the object's size.
//
// Note that mem may be evaluated multiple times.
//
// Parameters:
// mem - The memory.
// addr - The address.
// n - The size of the object.
//
// Result:
// A pointer for an object of size n.
#if WABT_BIG_ENDIAN
#define MEM_ADDR(mem, addr, n) ((mem)->data_end - (addr) - (n))
#else
#define MEM_ADDR(mem, addr, n) &((mem)->data[addr])
#endif

// We can only use Segue for this module if it uses a single unshared imported
// or exported memory
#if WASM_RT_USE_SEGUE && IS_SINGLE_UNSHARED_MEMORY
#define WASM_RT_USE_SEGUE_FOR_THIS_MODULE 1
#else
#define WASM_RT_USE_SEGUE_FOR_THIS_MODULE 0
#endif

#if WASM_RT_USE_SEGUE_FOR_THIS_MODULE
// POSIX uses FS for TLS, GS is free
static inline void* wasm_rt_segue_read_base() {
  if (wasm_rt_fsgsbase_inst_supported) {
    return (void*)__builtin_ia32_rdgsbase64();
  } else {
    return wasm_rt_syscall_get_segue_base();
  }
}
static inline void wasm_rt_segue_write_base(void* base) {
#if WASM_RT_SEGUE_FREE_SEGMENT
  if (wasm_rt_last_segment_val == base) {
    return;
  }

  wasm_rt_last_segment_val = base;
#endif

  if (wasm_rt_fsgsbase_inst_supported) {
    __builtin_ia32_wrgsbase64((uintptr_t)base);
  } else {
    wasm_rt_syscall_set_segue_base(base);
  }
}
#define MEM_ADDR_MEMOP(mem, addr, n) ((uint8_t __seg_gs*)(uintptr_t)addr)
#else
#define MEM_ADDR_MEMOP(mem, addr, n) MEM_ADDR(mem, addr, n)
#endif

#define TRAP(x) (wasm_rt_trap(WASM_RT_TRAP_##x), 0)

#if WASM_RT_STACK_DEPTH_COUNT
#define FUNC_PROLOGUE                                            \
  if (++wasm_rt_call_stack_depth > WASM_RT_MAX_CALL_STACK_DEPTH) \
    TRAP(EXHAUSTION);

#define FUNC_EPILOGUE --wasm_rt_call_stack_depth
#else
#define FUNC_PROLOGUE

#define FUNC_EPILOGUE
#endif

#define UNREACHABLE TRAP(UNREACHABLE)

static inline bool func_types_eq(const wasm_rt_func_type_t a,
                                 const wasm_rt_func_type_t b) {
  return (a == b) || LIKELY(a && b && !memcmp(a, b, 32));
}

#define CHECK_CALL_INDIRECT(table, ft, x)                \
  (LIKELY((x) < table.size && table.data[x].func &&      \
          func_types_eq(ft, table.data[x].func_type)) || \
   TRAP(CALL_INDIRECT))

#define DO_CALL_INDIRECT(table, t, x, ...) ((t)table.data[x].func)(__VA_ARGS__)

#define CALL_INDIRECT(table, t, ft, x, ...) \
  (CHECK_CALL_INDIRECT(table, ft, x),       \
   DO_CALL_INDIRECT(table, t, x, __VA_ARGS__))

static inline bool add_overflow(uint64_t a, uint64_t b, uint64_t* resptr) {
#if __has_builtin(__builtin_add_overflow)
  return __builtin_add_overflow(a, b, resptr);
#elif defined(_MSC_VER)
  return _addcarry_u64(0, a, b, resptr);
#else
#error "Missing implementation of __builtin_add_overflow or _addcarry_u64"
#endif
}

#define RANGE_CHECK(mem, offset, len)              \
  do {                                             \
    uint64_t res;                                  \
    if (UNLIKELY(add_overflow(offset, len, &res))) \
      TRAP(OOB);                                   \
    if (UNLIKELY(res > (mem)->size))               \
      TRAP(OOB);                                   \
  } while (0);

#if WASM_RT_USE_SEGUE_FOR_THIS_MODULE && WASM_RT_SANITY_CHECKS
#include <stdio.h>
#define WASM_RT_CHECK_BASE(mem)                                               \
  if (((uintptr_t)((mem)->data)) != ((uintptr_t)wasm_rt_segue_read_base())) { \
    puts("Segment register mismatch\n");                                      \
    abort();                                                                  \
  }
#else
#define WASM_RT_CHECK_BASE(mem)
#endif

// MEMCHECK_DEFAULT32 is an "accelerated" MEMCHECK used only for
// default-page-size, 32-bit memories. It may do nothing at all
// (if hardware bounds-checking is enabled via guard pages)
// or it may do a slightly faster RANGE_CHECK.
#if WASM_RT_MEMCHECK_GUARD_PAGES
#define MEMCHECK_DEFAULT32(mem, a, t) WASM_RT_CHECK_BASE(mem);
#else
#define MEMCHECK_DEFAULT32(mem, a, t)                \
  WASM_RT_CHECK_BASE(mem);                           \
  if (UNLIKELY(a + (uint64_t)sizeof(t) > mem->size)) \
    TRAP(OOB);
#endif

// MEMCHECK_GENERAL can be used for any memory
#define MEMCHECK_GENERAL(mem, a, t) \
  WASM_RT_CHECK_BASE(mem);          \
  RANGE_CHECK(mem, a, sizeof(t));

#ifdef __GNUC__
#define FORCE_READ_INT(var) __asm__("" ::"r"(var));
// Clang on Mips requires "f" constraints on floats
// See https://github.com/llvm/llvm-project/issues/64241
#if defined(__clang__) && \
    (defined(mips) || defined(__mips__) || defined(__mips))
#define FORCE_READ_FLOAT(var) __asm__("" ::"f"(var));
#else
#define FORCE_READ_FLOAT(var) __asm__("" ::"r"(var));
#endif
#else
#define FORCE_READ_INT(var)
#define FORCE_READ_FLOAT(var)
#endif

static inline void load_data(u8* dest, const u8* src, size_t n) {
  if (!n) {
    return;
  }
#if WABT_BIG_ENDIAN
  for (size_t i = 0; i < n; i++) {
    dest[i] = src[n - i - 1];
  }
#else
  wasm_rt_memcpy(dest, src, n);
#endif
}

#define LOAD_DATA(m, o, i, s)            \
  do {                                   \
    RANGE_CHECK((&m), o, s);             \
    load_data(MEM_ADDR(&m, o, s), i, s); \
  } while (0)

#define DEF_MEM_CHECKS0(name, shared, mem_type, ret_kw, return_type)         \
  static inline return_type name##_default32(wasm_rt##shared##memory_t* mem, \
                                             u64 addr) {                     \
    MEMCHECK_DEFAULT32(mem, addr, mem_type);                                 \
    ret_kw name##_unchecked(mem, addr);                                      \
  }                                                                          \
  static inline return_type name(wasm_rt##shared##memory_t* mem, u64 addr) { \
    MEMCHECK_GENERAL(mem, addr, mem_type);                                   \
    ret_kw name##_unchecked(mem, addr);                                      \
  }

#define DEF_MEM_CHECKS1(name, shared, mem_type, ret_kw, return_type,         \
                        val_type1)                                           \
  static inline return_type name##_default32(wasm_rt##shared##memory_t* mem, \
                                             u64 addr, val_type1 val1) {     \
    MEMCHECK_DEFAULT32(mem, addr, mem_type);                                 \
    ret_kw name##_unchecked(mem, addr, val1);                                \
  }                                                                          \
  static inline return_type name(wasm_rt##shared##memory_t* mem, u64 addr,   \
                                 val_type1 val1) {                           \
    MEMCHECK_GENERAL(mem, addr, mem_type);                                   \
    ret_kw name##_unchecked(mem, addr, val1);                                \
  }

#define DEF_MEM_CHECKS2(name, shared, mem_type, ret_kw, return_type,         \
                        val_type1, val_type2)                                \
  static inline return_type name##_default32(wasm_rt##shared##memory_t* mem, \
                                             u64 addr, val_type1 val1,       \
                                             val_type2 val2) {               \
    MEMCHECK_DEFAULT32(mem, addr, mem_type);                                 \
    ret_kw name##_unchecked(mem, addr, val1, val2);                          \
  }                                                                          \
  static inline return_type name(wasm_rt##shared##memory_t* mem, u64 addr,   \
                                 val_type1 val1, val_type2 val2) {           \
    MEMCHECK_GENERAL(mem, addr, mem_type);                                   \
    ret_kw name##_unchecked(mem, addr, val1, val2);                          \
  }

#define DEFINE_LOAD(name, t1, t2, t3, force_read)                      \
  static inline t3 name##_unchecked(wasm_rt_memory_t* mem, u64 addr) { \
    t1 result;                                                         \
    wasm_rt_memcpy(&result, MEM_ADDR_MEMOP(mem, addr, sizeof(t1)),     \
                   sizeof(t1));                                        \
    force_read(result);                                                \
    return (t3)(t2)result;                                             \
  }                                                                    \
  DEF_MEM_CHECKS0(name, _, t1, return, t3)

#define DEFINE_STORE(name, t1, t2)                                     \
  static inline void name##_unchecked(wasm_rt_memory_t* mem, u64 addr, \
                                      t2 value) {                      \
    t1 wrapped = (t1)value;                                            \
    wasm_rt_memcpy(MEM_ADDR_MEMOP(mem, addr, sizeof(t1)), &wrapped,    \
                   sizeof(t1));                                        \
  }                                                                    \
  DEF_MEM_CHECKS1(name, _, t1, , void, t2)

DEFINE_LOAD(i32_load, u32, u32, u32, FORCE_READ_INT)
DEFINE_LOAD(i64_load, u64, u64, u64, FORCE_READ_INT)
DEFINE_LOAD(f32_load, f32, f32, f32, FORCE_READ_FLOAT)
DEFINE_LOAD(f64_load, f64, f64, f64, FORCE_READ_FLOAT)
DEFINE_LOAD(i32_load8_s, s8, s32, u32, FORCE_READ_INT)
DEFINE_LOAD(i64_load8_s, s8, s64, u64, FORCE_READ_INT)
DEFINE_LOAD(i32_load8_u, u8, u32, u32, FORCE_READ_INT)
DEFINE_LOAD(i64_load8_u, u8, u64, u64, FORCE_READ_INT)
DEFINE_LOAD(i32_load16_s, s16, s32, u32, FORCE_READ_INT)
DEFINE_LOAD(i64_load16_s, s16, s64, u64, FORCE_READ_INT)
DEFINE_LOAD(i32_load16_u, u16, u32, u32, FORCE_READ_INT)
DEFINE_LOAD(i64_load16_u, u16, u64, u64, FORCE_READ_INT)
DEFINE_LOAD(i64_load32_s, s32, s64, u64, FORCE_READ_INT)
DEFINE_LOAD(i64_load32_u, u32, u64, u64, FORCE_READ_INT)
DEFINE_STORE(i32_store, u32, u32)
DEFINE_STORE(i64_store, u64, u64)
DEFINE_STORE(f32_store, f32, f32)
DEFINE_STORE(f64_store, f64, f64)
DEFINE_STORE(i32_store8, u8, u32)
DEFINE_STORE(i32_store16, u16, u32)
DEFINE_STORE(i64_store8, u8, u64)
DEFINE_STORE(i64_store16, u16, u64)
DEFINE_STORE(i64_store32, u32, u64)

#if defined(_MSC_VER)

// Adapted from
// https://github.com/nemequ/portable-snippets/blob/master/builtin/builtin.h

static inline int I64_CLZ(unsigned long long v) {
  unsigned long r = 0;
#if defined(_M_AMD64) || defined(_M_ARM)
  if (_BitScanReverse64(&r, v)) {
    return 63 - r;
  }
#else
  if (_BitScanReverse(&r, (unsigned long)(v >> 32))) {
    return 31 - r;
  } else if (_BitScanReverse(&r, (unsigned long)v)) {
    return 63 - r;
  }
#endif
  return 64;
}

static inline int I32_CLZ(unsigned long v) {
  unsigned long r = 0;
  if (_BitScanReverse(&r, v)) {
    return 31 - r;
  }
  return 32;
}

static inline int I64_CTZ(unsigned long long v) {
  if (!v) {
    return 64;
  }
  unsigned long r = 0;
#if defined(_M_AMD64) || defined(_M_ARM)
  _BitScanForward64(&r, v);
  return (int)r;
#else
  if (_BitScanForward(&r, (unsigned int)(v))) {
    return (int)(r);
  }

  _BitScanForward(&r, (unsigned int)(v >> 32));
  return (int)(r + 32);
#endif
}

static inline int I32_CTZ(unsigned long v) {
  if (!v) {
    return 32;
  }
  unsigned long r = 0;
  _BitScanForward(&r, v);
  return (int)r;
}

#define POPCOUNT_DEFINE_PORTABLE(f_n, T)                            \
  static inline u32 f_n(T x) {                                      \
    x = x - ((x >> 1) & (T) ~(T)0 / 3);                             \
    x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3); \
    x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15;                      \
    return (T)(x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;       \
  }

POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32)
POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)

#undef POPCOUNT_DEFINE_PORTABLE

#else

#define I32_CLZ(x) ((x) ? __builtin_clz(x) : 32)
#define I64_CLZ(x) ((x) ? __builtin_clzll(x) : 64)
#define I32_CTZ(x) ((x) ? __builtin_ctz(x) : 32)
#define I64_CTZ(x) ((x) ? __builtin_ctzll(x) : 64)
#define I32_POPCNT(x) (__builtin_popcount(x))
#define I64_POPCNT(x) (__builtin_popcountll(x))

#endif

#define DIV_S(ut, min, x, y)                                  \
  ((UNLIKELY((y) == 0))                  ? TRAP(DIV_BY_ZERO)  \
   : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \
                                         : (ut)((x) / (y)))

#define REM_S(ut, min, x, y)                                 \
  ((UNLIKELY((y) == 0))                  ? TRAP(DIV_BY_ZERO) \
   : (UNLIKELY((x) == min && (y) == -1)) ? 0                 \
                                         : (ut)((x) % (y)))

#define I32_DIV_S(x, y) DIV_S(u32, INT32_MIN, (s32)x, (s32)y)
#define I64_DIV_S(x, y) DIV_S(u64, INT64_MIN, (s64)x, (s64)y)
#define I32_REM_S(x, y) REM_S(u32, INT32_MIN, (s32)x, (s32)y)
#define I64_REM_S(x, y) REM_S(u64, INT64_MIN, (s64)x, (s64)y)

#define DIVREM_U(op, x, y) \
  ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x)op(y)))

#define DIV_U(x, y) DIVREM_U(/, x, y)
#define REM_U(x, y) DIVREM_U(%, x, y)

#define ROTL(x, y, mask) \
  (((x) << ((y) & (mask))) | ((x) >> (((mask) - (y) + 1) & (mask))))
#define ROTR(x, y, mask) \
  (((x) >> ((y) & (mask))) | ((x) << (((mask) - (y) + 1) & (mask))))

#define I32_ROTL(x, y) ROTL(x, y, 31)
#define I64_ROTL(x, y) ROTL(x, y, 63)
#define I32_ROTR(x, y) ROTR(x, y, 31)
#define I64_ROTR(x, y) ROTR(x, y, 63)

#define FMIN(x, y)                                           \
  ((UNLIKELY((x) != (x)))             ? NAN                  \
   : (UNLIKELY((y) != (y)))           ? NAN                  \
   : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \
   : (x < y)                          ? x                    \
                                      : y)

#define FMAX(x, y)                                           \
  ((UNLIKELY((x) != (x)))             ? NAN                  \
   : (UNLIKELY((y) != (y)))           ? NAN                  \
   : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \
   : (x > y)                          ? x                    \
                                      : y)

#define TRUNC_S(ut, st, ft, min, minop, max, x)                             \
  ((UNLIKELY((x) != (x)))                        ? TRAP(INVALID_CONVERSION) \
   : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW)       \
                                                 : (ut)(st)(x))

#define I32_TRUNC_S_F32(x) \
  TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x)
#define I64_TRUNC_S_F32(x) \
  TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x)
#define I32_TRUNC_S_F64(x) \
  TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x)
#define I64_TRUNC_S_F64(x) \
  TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x)

#define TRUNC_U(ut, ft, max, x)                                              \
  ((UNLIKELY((x) != (x)))                         ? TRAP(INVALID_CONVERSION) \
   : (UNLIKELY(!((x) > (ft) - 1 && (x) < (max)))) ? TRAP(INT_OVERFLOW)       \
                                                  : (ut)(x))

#define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, 4294967296.f, x)
#define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, (f32)UINT64_MAX, x)
#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296., x)
#define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, (f64)UINT64_MAX, x)

#define TRUNC_SAT_S(ut, st, ft, min, smin, minop, max, smax, x) \
  ((UNLIKELY((x) != (x)))         ? 0                           \
   : (UNLIKELY(!((x)minop(min)))) ? smin                        \
   : (UNLIKELY(!((x) < (max))))   ? smax                        \
                                  : (ut)(st)(x))

#define I32_TRUNC_SAT_S_F32(x)                                            \
  TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, \
              INT32_MAX, x)
#define I64_TRUNC_SAT_S_F32(x)                                              \
  TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, \
              INT64_MAX, x)
#define I32_TRUNC_SAT_S_F64(x)                                        \
  TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., \
              INT32_MAX, x)
#define I64_TRUNC_SAT_S_F64(x)                                              \
  TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, \
              INT64_MAX, x)

#define TRUNC_SAT_U(ut, ft, max, smax, x) \
  ((UNLIKELY((x) != (x)))          ? 0    \
   : (UNLIKELY(!((x) > (ft) - 1))) ? 0    \
   : (UNLIKELY(!((x) < (max))))    ? smax \
                                   : (ut)(x))

#define I32_TRUNC_SAT_U_F32(x) \
  TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x)
#define I64_TRUNC_SAT_U_F32(x) \
  TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x)
#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX, x)
#define I64_TRUNC_SAT_U_F64(x) \
  TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x)

#define DEFINE_REINTERPRET(name, t1, t2)         \
  static inline t2 name(t1 x) {                  \
    t2 result;                                   \
    wasm_rt_memcpy(&result, &x, sizeof(result)); \
    return result;                               \
  }

DEFINE_REINTERPRET(f32_reinterpret_i32, u32, f32)
DEFINE_REINTERPRET(i32_reinterpret_f32, f32, u32)
DEFINE_REINTERPRET(f64_reinterpret_i64, u64, f64)
DEFINE_REINTERPRET(i64_reinterpret_f64, f64, u64)

static float quiet_nanf(float x) {
  uint32_t tmp;
  wasm_rt_memcpy(&tmp, &x, 4);
  tmp |= 0x7fc00000lu;
  wasm_rt_memcpy(&x, &tmp, 4);
  return x;
}

static double quiet_nan(double x) {
  uint64_t tmp;
  wasm_rt_memcpy(&tmp, &x, 8);
  tmp |= 0x7ff8000000000000llu;
  wasm_rt_memcpy(&x, &tmp, 8);
  return x;
}

static double wasm_quiet(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return x;
}

static float wasm_quietf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return x;
}

static double wasm_floor(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return floor(x);
}

static float wasm_floorf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return floorf(x);
}

static double wasm_ceil(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return ceil(x);
}

static float wasm_ceilf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return ceilf(x);
}

static double wasm_trunc(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return trunc(x);
}

static float wasm_truncf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return truncf(x);
}

static float wasm_nearbyintf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return nearbyintf(x);
}

static double wasm_nearbyint(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return nearbyint(x);
}

static float wasm_fabsf(float x) {
  if (UNLIKELY(isnan(x))) {
    uint32_t tmp;
    wasm_rt_memcpy(&tmp, &x, 4);
    tmp = tmp & ~(1UL << 31);
    wasm_rt_memcpy(&x, &tmp, 4);
    return x;
  }
  return fabsf(x);
}

static double wasm_fabs(double x) {
  if (UNLIKELY(isnan(x))) {
    uint64_t tmp;
    wasm_rt_memcpy(&tmp, &x, 8);
    tmp = tmp & ~(1ULL << 63);
    wasm_rt_memcpy(&x, &tmp, 8);
    return x;
  }
  return fabs(x);
}

static double wasm_sqrt(double x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nan(x);
  }
  return sqrt(x);
}

static float wasm_sqrtf(float x) {
  if (UNLIKELY(isnan(x))) {
    return quiet_nanf(x);
  }
  return sqrtf(x);
}

static inline void memory_fill(wasm_rt_memory_t* mem, u64 d, u32 val, u64 n) {
  RANGE_CHECK(mem, d, n);
  memset(MEM_ADDR(mem, d, n), val, n);
}

static inline void memory_copy(wasm_rt_memory_t* dest,
                               const wasm_rt_memory_t* src,
                               u64 dest_addr,
                               u64 src_addr,
                               u64 n) {
  RANGE_CHECK(dest, dest_addr, n);
  RANGE_CHECK(src, src_addr, n);
  memmove(MEM_ADDR(dest, dest_addr, n), MEM_ADDR(src, src_addr, n), n);
}

static inline void memory_init(wasm_rt_memory_t* dest,
                               const u8* src,
                               u32 src_size,
                               u64 dest_addr,
                               u32 src_addr,
                               u32 n) {
  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
    TRAP(OOB);
  LOAD_DATA((*dest), dest_addr, src + src_addr, n);
}

typedef enum { RefFunc, RefNull, GlobalGet } wasm_elem_segment_expr_type_t;

typedef struct {
  wasm_elem_segment_expr_type_t expr_type;
  wasm_rt_func_type_t type;
  wasm_rt_function_ptr_t func;
  wasm_rt_tailcallee_t func_tailcallee;
  size_t module_offset;
} wasm_elem_segment_expr_t;

static inline void funcref_table_init(wasm_rt_funcref_table_t* dest,
                                      const wasm_elem_segment_expr_t* src,
                                      u32 src_size,
                                      u64 dest_addr,
                                      u32 src_addr,
                                      u32 n,
                                      void* module_instance) {
  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
    TRAP(OOB);
  RANGE_CHECK(dest, dest_addr, n);
  for (u32 i = 0; i < n; i++) {
    const wasm_elem_segment_expr_t* const src_expr = &src[src_addr + i];
    wasm_rt_funcref_t* const dest_val = &(dest->data[dest_addr + i]);
    switch (src_expr->expr_type) {
      case RefFunc:
        *dest_val = (wasm_rt_funcref_t){
            src_expr->type, src_expr->func, src_expr->func_tailcallee,
            (char*)module_instance + src_expr->module_offset};
        break;
      case RefNull:
        *dest_val = wasm_rt_funcref_null_value;
        break;
      case GlobalGet:
        *dest_val = **(wasm_rt_funcref_t**)((char*)module_instance +
                                            src_expr->module_offset);
        break;
    }
  }
}

// Currently wasm2c only supports initializing externref tables with ref.null.
static inline void externref_table_init(wasm_rt_externref_table_t* dest,
                                        u32 src_size,
                                        u64 dest_addr,
                                        u32 src_addr,
                                        u32 n) {
  if (UNLIKELY(src_addr + (uint64_t)n > src_size))
    TRAP(OOB);
  RANGE_CHECK(dest, dest_addr, n);
  for (u32 i = 0; i < n; i++) {
    dest->data[dest_addr + i] = wasm_rt_externref_null_value;
  }
}

#define DEFINE_TABLE_COPY(type)                                              \
  static inline void type##_table_copy(wasm_rt_##type##_table_t* dest,       \
                                       const wasm_rt_##type##_table_t* src,  \
                                       u64 dest_addr, u64 src_addr, u64 n) { \
    RANGE_CHECK(dest, dest_addr, n);                                         \
    RANGE_CHECK(src, src_addr, n);                                           \
    memmove(dest->data + dest_addr, src->data + src_addr,                    \
            n * sizeof(wasm_rt_##type##_t));                                 \
  }

DEFINE_TABLE_COPY(funcref)
DEFINE_TABLE_COPY(externref)

#define DEFINE_TABLE_GET(type)                        \
  static inline wasm_rt_##type##_t type##_table_get(  \
      const wasm_rt_##type##_table_t* table, u64 i) { \
    if (UNLIKELY(i >= table->size))                   \
      TRAP(OOB);                                      \
    return table->data[i];                            \
  }

DEFINE_TABLE_GET(funcref)
DEFINE_TABLE_GET(externref)

#define DEFINE_TABLE_SET(type)                                               \
  static inline void type##_table_set(const wasm_rt_##type##_table_t* table, \
                                      u64 i, const wasm_rt_##type##_t val) { \
    if (UNLIKELY(i >= table->size))                                          \
      TRAP(OOB);                                                             \
    table->data[i] = val;                                                    \
  }

DEFINE_TABLE_SET(funcref)
DEFINE_TABLE_SET(externref)

#define DEFINE_TABLE_FILL(type)                                               \
  static inline void type##_table_fill(const wasm_rt_##type##_table_t* table, \
                                       u64 d, const wasm_rt_##type##_t val,   \
                                       u64 n) {                               \
    RANGE_CHECK(table, d, n);                                                 \
    for (uint32_t i = d; i < d + n; i++) {                                    \
      table->data[i] = val;                                                   \
    }                                                                         \
  }

DEFINE_TABLE_FILL(funcref)
DEFINE_TABLE_FILL(externref)

#if defined(__GNUC__) || defined(__clang__)
#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char* const x
#define FUNC_TYPE_EXTERN_T(x) const char* const x
#define FUNC_TYPE_T(x) static const char* const x
#else
#define FUNC_TYPE_DECL_EXTERN_T(x) extern const char x[]
#define FUNC_TYPE_EXTERN_T(x) const char x[]
#define FUNC_TYPE_T(x) static const char x[]
#endif

#if (__STDC_VERSION__ < 201112L) && !defined(static_assert)
#define static_assert(X) \
  extern int(*assertion(void))[!!sizeof(struct { int x : (X) ? 2 : -1; })];
#endif

#ifdef _MSC_VER
#define WEAK_FUNC_DECL(func, fallback)                             \
  __pragma(comment(linker, "/alternatename:" #func "=" #fallback)) \
                                                                   \
      void                                                         \
      fallback(void** instance_ptr, void* tail_call_stack,         \
               wasm_rt_tailcallee_t* next)
#else
#define WEAK_FUNC_DECL(func, fallback)                                        \
  __attribute__((weak)) void func(void** instance_ptr, void* tail_call_stack, \
                                  wasm_rt_tailcallee_t* next)
#endif

static void w2c_test_tailcaller_0(w2c_test*);
static void wasm_tailcall_w2c_test_tailcaller_0(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);
static struct wasm_multi_id w2c_test_infiniteloop(w2c_test*, u32, f64);
static void wasm_tailcall_w2c_test_infiniteloop(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next);

#ifndef wasm_multi_if
#define wasm_multi_if wasm_multi_if
struct wasm_multi_if {
  u32 i0;
  f32 f1;
};
#endif  /* wasm_multi_if */

FUNC_TYPE_T(w2c_test_i32_f32) = "\x98\x89\x5c\xbd\x28\xfd\x0e\x4d\xc5\xdc\x68\x2c\x7c\xee\x61\x09\x14\x19\x30\x62\xc2\x2f\x49\xc5\xb5\x81\x57\x55\x6b\xe7\xa5\xb9";
FUNC_TYPE_T(w2c_test_t1) = "\x36\xa9\xe7\xf1\xc9\x5b\x82\xff\xb9\x97\x43\xe0\xc5\xc4\xce\x95\xd8\x3c\x9a\x43\x0a\xac\x59\xf8\x4e\xf3\xcb\xfa\xb6\x14\x50\x68";
FUNC_TYPE_T(w2c_test_t2) = "\xe5\x11\x86\xc7\x24\xdb\x44\x80\xbe\xd1\xe0\x89\xbc\xc0\x20\xea\xfb\x1c\x9a\x27\xa5\xc3\xdb\xca\x5d\xb0\x05\x0f\x7c\x03\x74\x0a";

static void wrap_w2c_spectest_print_i32_f32(void *instance, u32 var_0, f32 var_1) {
  return w2c_spectest_print_i32_f32((struct w2c_spectest*) instance, var_0, var_1);
}

static const wasm_elem_segment_expr_t elem_segment_exprs_w2c_test_e0[] = {
  {RefFunc, w2c_test_i32_f32, (wasm_rt_function_ptr_t)wrap_w2c_spectest_print_i32_f32, {wasm_tailcall_w2c_spectest_print_i32_f32}, offsetof(w2c_test, w2c_spectest_instance)},
};

static void init_tables(w2c_test* instance) {
  wasm_rt_allocate_funcref_table(&instance->w2c_tab, 1, 1);
  funcref_table_init(&instance->w2c_tab, elem_segment_exprs_w2c_test_e0, 1, 0u, 0, 1, instance);
}

static void init_elem_instances(w2c_test *instance) {
}

/* export: 'tailcaller' */
void w2c_test_tailcaller(w2c_test* instance) {
  w2c_test_tailcaller_0(instance);
}

/* export for tail-call of 'tailcaller' */
void wasm_tailcall_w2c_test_tailcaller(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {
  wasm_tailcall_w2c_test_tailcaller_0(instance_ptr, tail_call_stack, next);
}

/* handler for missing tail-call on import: 'spectest' 'print_i32_f32' */
WEAK_FUNC_DECL(wasm_tailcall_w2c_spectest_print_i32_f32, wasm_fallback_test_w2c_spectest_print_i32_f32)
{
  next->fn = NULL;
  struct wasm_multi_if params;
  wasm_rt_memcpy(&params, tail_call_stack, sizeof(params));
  w2c_spectest_print_i32_f32(*instance_ptr, params.i0, params.f1);
}

static void init_instance_import(w2c_test* instance, struct w2c_spectest* w2c_spectest_instance) {
  instance->w2c_spectest_instance = w2c_spectest_instance;
}

void wasm2c_test_instantiate(w2c_test* instance, struct w2c_spectest* w2c_spectest_instance) {
  assert(wasm_rt_is_initialized());
  init_instance_import(instance, w2c_spectest_instance);
  init_tables(instance);
  init_elem_instances(instance);
}

void wasm2c_test_free(w2c_test* instance) {
  wasm_rt_free_funcref_table(&instance->w2c_tab);
}

wasm_rt_func_type_t wasm2c_test_get_func_type(uint32_t param_count, uint32_t result_count, ...) {
  va_list args;
  
  if (param_count == 2 && result_count == 0) {
    va_start(args, result_count);
    if (true && va_arg(args, int) == WASM_RT_I32 && va_arg(args, int) == WASM_RT_F32) {
      va_end(args);
      return w2c_test_i32_f32;
    }
    va_end(args);
  }
  
  if (param_count == 0 && result_count == 0) {
    va_start(args, result_count);
    if (true) {
      va_end(args);
      return w2c_test_t1;
    }
    va_end(args);
  }
  
  if (param_count == 2 && result_count == 2) {
    va_start(args, result_count);
    if (true && va_arg(args, int) == WASM_RT_I32 && va_arg(args, int) == WASM_RT_F64 && va_arg(args, int) == WASM_RT_I32 && va_arg(args, int) == WASM_RT_F64) {
      va_end(args);
      return w2c_test_t2;
    }
    va_end(args);
  }
  
  return NULL;
}

void w2c_test_tailcaller_0(w2c_test* instance) {
  FUNC_PROLOGUE;
  u32 var_i0, var_i2;
  f32 var_f1;
  var_i0 = 1u;
  var_f1 = 2;
  var_i2 = 0u;
  static_assert(sizeof(struct wasm_multi_if) <= 1024);
  CHECK_CALL_INDIRECT(instance->w2c_tab, w2c_test_i32_f32, var_i2);
  if (!instance->w2c_tab.data[var_i2].func_tailcallee.fn) {
    CALL_INDIRECT(instance->w2c_tab, void (*)(void*, u32, f32), w2c_test_i32_f32, var_i2, instance->w2c_tab.data[var_i2].module_instance, var_i0, var_f1);
  } else {
    void *instance_ptr_storage;
    void **instance_ptr = &instance_ptr_storage;
    char tail_call_stack[1024];
    wasm_rt_tailcallee_t next_storage;
    wasm_rt_tailcallee_t *next = &next_storage;
    {
      struct wasm_multi_if tmp;
      tmp.i0 = var_i0;
      tmp.f1 = var_f1;
      wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));
    }
    next->fn = instance->w2c_tab.data[var_i2].func_tailcallee.fn;
    *instance_ptr = instance->w2c_tab.data[var_i2].module_instance;
    while (next->fn) { next->fn(instance_ptr, tail_call_stack, next); }
  }
  goto var_Bfunc;
  var_Bfunc:;
  FUNC_EPILOGUE;
}

void wasm_tailcall_w2c_test_tailcaller_0(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {
  w2c_test* instance = *instance_ptr;
  u32 var_i0, var_i2;
  f32 var_f1;
  var_i0 = 1u;
  var_f1 = 2;
  var_i2 = 0u;
  static_assert(sizeof(struct wasm_multi_if) <= 1024);
  CHECK_CALL_INDIRECT(instance->w2c_tab, w2c_test_i32_f32, var_i2);
  if (!instance->w2c_tab.data[var_i2].func_tailcallee.fn) {
    CALL_INDIRECT(instance->w2c_tab, void (*)(void*, u32, f32), w2c_test_i32_f32, var_i2, instance->w2c_tab.data[var_i2].module_instance, var_i0, var_f1);
    next->fn = NULL;
  } else {
    {
      struct wasm_multi_if tmp;
      tmp.i0 = var_i0;
      tmp.f1 = var_f1;
      wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));
    }
    next->fn = instance->w2c_tab.data[var_i2].func_tailcallee.fn;
    *instance_ptr = instance->w2c_tab.data[var_i2].module_instance;
  }
  return;
  var_Bfunc:;
  next->fn = NULL;
}

struct wasm_multi_id w2c_test_infiniteloop(w2c_test* instance, u32 var_p0, f64 var_p1) {
  FUNC_PROLOGUE;
  u32 var_i0;
  f64 var_d1;
  var_i0 = var_p0;
  var_d1 = var_p1;
  static_assert(sizeof(struct wasm_multi_id) <= 1024);
  {
    void *instance_ptr_storage;
    void **instance_ptr = &instance_ptr_storage;
    char tail_call_stack[1024];
    wasm_rt_tailcallee_t next_storage;
    wasm_rt_tailcallee_t *next = &next_storage;
    {
      struct wasm_multi_id tmp;
      tmp.i0 = var_i0;
      tmp.d1 = var_d1;
      wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));
    }
    next->fn = wasm_tailcall_w2c_test_infiniteloop;
    while (next->fn) { next->fn(instance_ptr, tail_call_stack, next); }
    {
      struct wasm_multi_id tmp;
      wasm_rt_memcpy(&tmp, tail_call_stack, sizeof(tmp));
      var_i0 = tmp.i0;
      var_d1 = tmp.d1;
    }
  }
  goto var_Bfunc;
  var_Bfunc:;
  FUNC_EPILOGUE;
  {
    struct wasm_multi_id tmp;
    tmp.i0 = var_i0;
    tmp.d1 = var_d1;
    return tmp;
  }
}

void wasm_tailcall_w2c_test_infiniteloop(void **instance_ptr, void *tail_call_stack, wasm_rt_tailcallee_t *next) {
  static_assert(sizeof(struct wasm_multi_id) <= 1024);
  w2c_test* instance = *instance_ptr;
  u32 var_p0;
  f64 var_p1;
  {
    struct wasm_multi_id tmp;
    wasm_rt_memcpy(&tmp, tail_call_stack, sizeof(tmp));
    var_p0 = tmp.i0;
    var_p1 = tmp.d1;
  }
  u32 var_i0;
  f64 var_d1;
  var_i0 = var_p0;
  var_d1 = var_p1;
  static_assert(sizeof(struct wasm_multi_id) <= 1024);
  {
    {
      struct wasm_multi_id tmp;
      tmp.i0 = var_i0;
      tmp.d1 = var_d1;
      wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));
    }
    next->fn = wasm_tailcall_w2c_test_infiniteloop;
  }
  return;
  var_Bfunc:;
  {
    struct wasm_multi_id tmp;
    tmp.i0 = var_i0;
    tmp.d1 = var_d1;
    wasm_rt_memcpy(tail_call_stack, &tmp, sizeof(tmp));
  }
  next->fn = NULL;
}
;;; STDOUT ;;)
