fn arity_check(name: &str, args: &[Expr], expected: usize) -> Result<()> {

    if args.len() != expected {

        return Err(Error::Arity {

            name: name.to_string(),

            expected,

            actual: args.len(),

        });

    }

    Ok(())

}

fn compile_idx_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    expr: &Expr,

) -> Result<()> {

    let resolved = eval_value(symbols, expr)?;

    match &resolved {

            compile_for_stack(ctx, emit, symbols, expr)?;

            compile_for_stack(ctx, emit, symbols, expr)?;

            emit.struct_get(ctx.type_idx("ratio"), 0);

            emit.i32_wrap_i64();

        Expr::Number(n) if *n.denom() == 1 => {

            emit.i32_const(*n.numer() as i32);

        }

    Ok(())

}

pub(super) fn entity_count(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("ENTITY-COUNT", args, 0)?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn context_type(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("CONTEXT-TYPE", args, 0)?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn primary_entity_type(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("PRIMARY-ENTITY-TYPE", args, 0)?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn primary_entity_idx(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("PRIMARY-ENTITY-IDX", args, 0)?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn entity_type(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("ENTITY-TYPE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn entity_parent_idx(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("ENTITY-PARENT-IDX", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn compile_entity_count(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("ENTITY-COUNT", args, 0)?;

    let ty = compile_entity_count_to_stack(ctx, emit, _symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_entity_count_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("ENTITY-COUNT", args, 0)?;

    emit.call(ctx.func("get_input_entities_count"));

    Ok(WasmType::I32)

}

pub(super) fn compile_context_type(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("CONTEXT-TYPE", args, 0)?;

    let ty = compile_context_type_to_stack(ctx, emit, _symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_context_type_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("CONTEXT-TYPE", args, 0)?;

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load8_u(6);

    Ok(WasmType::I32)

}

pub(super) fn compile_primary_entity_type(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("PRIMARY-ENTITY-TYPE", args, 0)?;

    let ty = compile_primary_entity_type_to_stack(ctx, emit, _symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_primary_entity_type_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("PRIMARY-ENTITY-TYPE", args, 0)?;

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load8_u(7);

    Ok(WasmType::I32)

}

pub(super) fn compile_primary_entity_idx(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("PRIMARY-ENTITY-IDX", args, 0)?;

    let ty = compile_primary_entity_idx_to_stack(ctx, emit, _symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_primary_entity_idx_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    _symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("PRIMARY-ENTITY-IDX", args, 0)?;

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load(0x20);

    Ok(WasmType::I32)

}

fn emit_entity_header_offset(ctx: &CompileContext, emit: &mut FunctionEmitter, temp_local: u32) {

    emit.i32_const(32);

    emit.i32_mul(); // [idx * 32]

    emit.local_set(temp_local); // save idx*32

    emit.call(ctx.func("get_input_offset")); // [input_base]

    emit.i32_load(0x0C); // [entities_offset] (absolute)

    emit.local_get(temp_local); // [entities_offset, idx*32]

    emit.i32_add(); // [header_offset]

}

pub(super) fn compile_entity_type(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("ENTITY-TYPE", args, 1)?;

    let ty = compile_entity_type_to_stack(ctx, emit, symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_entity_type_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("ENTITY-TYPE", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_header_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load8_u(0); // entity_type at offset 0 in header

    Ok(WasmType::I32)

}

pub(super) fn compile_entity_parent_idx(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("ENTITY-PARENT-IDX", args, 1)?;

    let ty = compile_entity_parent_idx_to_stack(ctx, emit, symbols, args)?;

    super::super::expr::serialize_stack_to_output(ctx, emit, ty);

    Ok(())

}

pub(super) fn compile_entity_parent_idx_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("ENTITY-PARENT-IDX", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_header_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load(0x14); // parent_idx at offset 0x14 in header

    Ok(WasmType::I32)

}

fn emit_entity_data_offset(ctx: &CompileContext, emit: &mut FunctionEmitter, temp_local: u32) {

    emit_entity_header_offset(ctx, emit, temp_local);

    emit.i32_load(0x18); // data_offset at EntityHeader offset 0x18

}

pub(super) fn transaction_split_count(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TRANSACTION-SPLIT-COUNT", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn compile_transaction_split_count_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TRANSACTION-SPLIT-COUNT", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load(16); // split_count at TransactionData offset 16

    Ok(WasmType::I32)

}

pub(super) fn transaction_tag_count(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TRANSACTION-TAG-COUNT", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn compile_transaction_tag_count_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TRANSACTION-TAG-COUNT", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load(20); // tag_count at TransactionData offset 20

    Ok(WasmType::I32)

}

pub(super) fn transaction_is_multi_currency(

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<Expr> {

    arity_check("TRANSACTION-IS-MULTI-CURRENCY", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn compile_transaction_is_multi_currency_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TRANSACTION-IS-MULTI-CURRENCY", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load8_u(24); // is_multi_currency at TransactionData offset 24

    Ok(WasmType::I32)

}

pub(super) fn transaction_post_date(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TRANSACTION-POST-DATE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_transaction_post_date_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TRANSACTION-POST-DATE", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i64_load(0); // post_date at TransactionData offset 0

    emit.call(ctx.func("ratio_from_i64"));

    Ok(WasmType::Ratio)

}

pub(super) fn transaction_enter_date(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TRANSACTION-ENTER-DATE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_transaction_enter_date_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TRANSACTION-ENTER-DATE", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i64_load(8); // enter_date at TransactionData offset 8

    emit.call(ctx.func("ratio_from_i64"));

    Ok(WasmType::Ratio)

}

pub(super) fn split_value_num(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("SPLIT-VALUE-NUM", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_split_value_num_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("SPLIT-VALUE-NUM", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i64_load(32); // value_num at SplitData offset 32

    emit.call(ctx.func("ratio_from_i64"));

    Ok(WasmType::Ratio)

}

pub(super) fn split_value_denom(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("SPLIT-VALUE-DENOM", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_split_value_denom_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("SPLIT-VALUE-DENOM", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i64_load(40); // value_denom at SplitData offset 40

    emit.call(ctx.func("ratio_from_i64"));

    Ok(WasmType::Ratio)

}

pub(super) fn split_value(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("SPLIT-VALUE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_split_value_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("SPLIT-VALUE", args, 1)?;

    let temp = super::super::expr::LOCAL_TEMP_I32;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, temp);

    emit.local_set(temp);

    emit.local_get(temp);

    emit.i64_load(32);

    emit.local_get(temp);

    emit.i64_load(40);

    emit.call(ctx.func("ratio_new"));

    Ok(WasmType::Ratio)

}

pub(super) fn split_reconcile_state(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("SPLIT-RECONCILE-STATE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::I32))

}

pub(super) fn compile_split_reconcile_state_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("SPLIT-RECONCILE-STATE", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i32_load8_u(48); // reconcile_state at SplitData offset 48

    Ok(WasmType::I32)

}

pub(super) fn split_reconcile_date(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("SPLIT-RECONCILE-DATE", args, 1)?;

    super::super::expr::eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::Ratio))

}

pub(super) fn compile_split_reconcile_date_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("SPLIT-RECONCILE-DATE", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, super::super::expr::LOCAL_TEMP_I32);

    emit.i64_load(56); // reconcile_date at SplitData offset 56

    emit.call(ctx.func("ratio_from_i64"));

    Ok(WasmType::Ratio)

}

pub(super) fn get_input_entities(_symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("GET-INPUT-ENTITIES", args, 0)?;

    Ok(Expr::WasmRuntime(WasmType::ConsRef))

}

pub(super) fn compile_create_tag(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    if args.len() != 3 {

    }

    let name_val = eval_value(symbols, &args[1])?;

    let value_val = eval_value(symbols, &args[2])?;

    let is_runtime = name_val.wasm_type() == Some(WasmType::StringRef)

        || value_val.wasm_type() == Some(WasmType::StringRef);

    if is_runtime {

        return compile_create_tag_runtime(ctx, emit, symbols, args);

    }

    let name_str = match &name_val {

        Expr::String(s) => s.clone(),

    let value_str = match &value_val {

        Expr::String(s) => s.clone(),

    let tag = super::super::layout::TagGcData {

        name_data_idx: ctx.add_data(name_str.as_bytes()),

        name_len: name_str.len() as u32,

        value_data_idx: ctx.add_data(value_str.as_bytes()),

        value_len: value_str.len() as u32,

    };

    let gc = super::super::layout::GcLocals {

        type_idx: ctx.type_idx("i8_array"),

        arr: super::super::expr::LOCAL_GC_ARR,

        idx: super::super::expr::LOCAL_IDX,

    };

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    let parent_local = super::super::expr::LOCAL_TEMP_I32;

    emit.local_set(parent_local);

    ctx.serializer()

        .write_tag_gc_dynamic_parent(emit, parent_local, &tag, &gc);

    Ok(())

}

fn compile_create_tag_runtime(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    let temp = super::super::expr::LOCAL_TEMP_I32;

    let parent_local = ctx.alloc_local(WasmType::I32);

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit.local_set(parent_local);

    let name_arr = ctx.alloc_local(WasmType::StringRef);

    let value_arr = ctx.alloc_local(WasmType::StringRef);

    compile_for_stack(ctx, emit, symbols, &args[1])?;

    emit.local_set(name_arr);

    compile_for_stack(ctx, emit, symbols, &args[2])?;

    emit.local_set(value_arr);

    let name_len = ctx.alloc_local(WasmType::I32);

    let value_len = ctx.alloc_local(WasmType::I32);

    emit.local_get(name_arr);

    emit.array_len();

    emit.local_set(name_len);

    emit.local_get(value_arr);

    emit.array_len();

    emit.local_set(value_len);

    let out_base = ctx.alloc_local(WasmType::I32);

    emit.call(ctx.func("get_output_offset"));

    emit.local_set(out_base);

    let write_pos = ctx.alloc_local(WasmType::I32);

    emit.local_get(out_base);

    emit.i32_load(offset_of!(OutputHeader, next_write_pos) as u64);

    emit.local_set(write_pos);

    let str_end = ctx.alloc_local(WasmType::I32);

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load(offset_of!(GlobalHeader, output_size) as u64);

    emit.local_set(str_end);

    emit.local_get(out_base);

    emit.i32_load(offset_of!(OutputHeader, reserved) as u64);

    emit.local_set(temp);

    emit.local_get(temp);

    emit.i32_const(0);

    emit.i32_ne();

    emit.if_block(wasm_encoder::BlockType::Empty);

    emit.local_get(temp);

    emit.local_set(str_end);

    emit.end();

    emit.local_get(str_end);

    emit.local_get(value_len);

    emit.i32_sub();

    emit.local_set(str_end);

    let value_str_start = ctx.alloc_local(WasmType::I32);

    emit.local_get(str_end);

    emit.local_set(value_str_start);

    let name_str_start = ctx.alloc_local(WasmType::I32);

    emit.local_get(str_end);

    emit.local_get(name_len);

    emit.i32_sub();

    emit.local_tee(name_str_start);

    emit.local_set(str_end);

    let i8_array_idx = ctx.type_idx("i8_array");

    let idx_local = ctx.alloc_local(WasmType::I32);

    copy_gc_array_to_linear(

        emit,

        i8_array_idx,

        name_arr,

        name_len,

        out_base,

        name_str_start,

        idx_local,

    copy_gc_array_to_linear(

        emit,

        i8_array_idx,

        value_arr,

        value_len,

        out_base,

        value_str_start,

        idx_local,

    let output_size = ctx.alloc_local(WasmType::I32);

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load(offset_of!(GlobalHeader, output_size) as u64);

    emit.local_set(output_size);

    let eh_addr = ctx.alloc_local(WasmType::I32);

    emit.local_get(out_base);

    emit.local_get(write_pos);

    emit.i32_add();

    emit.local_set(eh_addr);

    emit.local_get(eh_addr);

    emit.i32_const(EntityType::Tag as i32);

    emit.i32_store8_raw();

    emit.local_get(eh_addr);

    emit.i32_const(offset_of!(EntityHeader, operation) as i32);

    emit.i32_add();

    emit.i32_const(Operation::Create as i32);

    emit.i32_store8_raw();

    emit.local_get(eh_addr);

    emit.i32_const(offset_of!(EntityHeader, flags) as i32);

    emit.i32_add();

    emit.i32_const(0);

    emit.i32_store8_raw();

    for i in 0..4u32 {

        emit.local_get(eh_addr);

        emit.i32_const((offset_of!(EntityHeader, id) + i as usize * 4) as i32);

        emit.i32_add();

        emit.i32_const(0);

        emit.i32_store_raw();

    }

    emit.local_get(eh_addr);

    emit.i32_const(offset_of!(EntityHeader, parent_idx) as i32);

    emit.i32_add();

    emit.local_get(parent_local);

    emit.i32_store_raw();

    emit.local_get(eh_addr);

    emit.i32_const(offset_of!(EntityHeader, data_offset) as i32);

    emit.i32_add();

    emit.local_get(write_pos);

    emit.i32_const(ENTITY_HEADER_SIZE as i32);

    emit.i32_add();

    emit.i32_store_raw();

    emit.local_get(eh_addr);

    emit.i32_const(offset_of!(EntityHeader, data_size) as i32);

    emit.i32_add();

    emit.i32_const(TAG_DATA_SIZE as i32);

    emit.i32_store_raw();

    let td_addr = ctx.alloc_local(WasmType::I32);

    emit.local_get(eh_addr);

    emit.i32_const(ENTITY_HEADER_SIZE as i32);

    emit.i32_add();

    emit.local_set(td_addr);

    emit.local_get(td_addr);

    emit.local_get(output_size);

    emit.local_get(name_str_start);

    emit.i32_sub();

    emit.i32_store_raw();

    emit.local_get(td_addr);

    emit.i32_const(offset_of!(TagData, value_offset) as i32);

    emit.i32_add();

    emit.local_get(output_size);

    emit.local_get(value_str_start);

    emit.i32_sub();

    emit.i32_store_raw();

    emit.local_get(td_addr);

    emit.i32_const(offset_of!(TagData, name_len) as i32);

    emit.i32_add();

    emit.local_get(value_len);

    emit.i32_const(16);

    emit.i32_shl();

    emit.local_get(name_len);

    emit.i32_or();

    emit.i32_store_raw();

    emit.local_get(td_addr);

    emit.i32_const(offset_of!(TagData, reserved) as i32);

    emit.i32_add();

    emit.i32_const(0);

    emit.i32_store_raw();

    emit.local_get(out_base);

    emit.i32_const(offset_of!(OutputHeader, output_entity_count) as i32);

    emit.i32_add();

    emit.local_get(out_base);

    emit.i32_load(offset_of!(OutputHeader, output_entity_count) as u64);

    emit.i32_const(1);

    emit.i32_add();

    emit.i32_store_raw();

    emit.local_get(out_base);

    emit.i32_const(offset_of!(OutputHeader, next_write_pos) as i32);

    emit.i32_add();

    emit.local_get(write_pos);

    emit.i32_const((ENTITY_HEADER_SIZE + TAG_DATA_SIZE) as i32);

    emit.i32_add();

    emit.i32_store_raw();

    emit.local_get(out_base);

    emit.i32_const(offset_of!(OutputHeader, strings_offset) as i32);

    emit.i32_add();

    emit.local_get(output_size);

    emit.i32_store_raw();

    emit.local_get(out_base);

    emit.i32_const(offset_of!(OutputHeader, reserved) as i32);

    emit.i32_add();

    emit.local_get(str_end);

    emit.i32_store_raw();

    Ok(())

}

fn copy_gc_array_to_linear(

    emit: &mut FunctionEmitter,

    type_idx: u32,

    arr_local: u32,

    len_local: u32,

    base_local: u32,

    offset_local: u32,

    idx_local: u32,

) {

    emit.i32_const(0);

    emit.local_set(idx_local);

    emit.block_start();

    emit.loop_start();

    emit.local_get(idx_local);

    emit.local_get(len_local);

    emit.i32_ge_u();

    emit.br_if(1);

    emit.local_get(base_local);

    emit.local_get(offset_local);

    emit.i32_add();

    emit.local_get(idx_local);

    emit.i32_add();

    emit.local_get(arr_local);

    emit.local_get(idx_local);

    emit.array_get_u(type_idx);

    emit.i32_store8_raw();

    emit.local_get(idx_local);

    emit.i32_const(1);

    emit.i32_add();

    emit.local_set(idx_local);

    emit.br(0);

    emit.block_end();

    emit.block_end();

}

pub(super) fn compile_delete_entity(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<()> {

    arity_check("DELETE-ENTITY", args, 1)?;

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    let temp = super::super::expr::LOCAL_TEMP_I32;

    emit_entity_header_offset(ctx, emit, temp);

    let header_local = ctx.alloc_local(WasmType::I32);

    emit.local_set(header_local);

    let type_local = ctx.alloc_local(WasmType::I32);

    emit.local_get(header_local);

    emit.i32_load8_u(0);

    emit.local_set(type_local);

    ctx.serializer()

        .write_delete_entity(emit, type_local, header_local);

    Ok(())

}

pub(super) fn tag_name(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TAG-NAME", args, 1)?;

    eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::StringRef))

}

pub(super) fn tag_value(symbols: &mut SymbolTable, args: &[Expr]) -> Result<Expr> {

    arity_check("TAG-VALUE", args, 1)?;

    eval_value(symbols, &args[0])?;

    Ok(Expr::WasmRuntime(WasmType::StringRef))

}

fn compile_tag_string_field_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

    offset_field: u64,

    len_field: u64,

) -> Result<WasmType> {

    let temp = super::super::expr::LOCAL_TEMP_I32;

    let data_local = ctx.alloc_local(WasmType::I32);

    let str_off_local = ctx.alloc_local(WasmType::I32);

    let str_len_local = ctx.alloc_local(WasmType::I32);

    let pool_local = ctx.alloc_local(WasmType::I32);

    let arr_local = ctx.alloc_local(WasmType::StringRef);

    let idx_local = ctx.alloc_local(WasmType::I32);

    compile_idx_to_stack(ctx, emit, symbols, &args[0])?;

    emit_entity_data_offset(ctx, emit, temp);

    emit.local_set(data_local);

    emit.local_get(data_local);

    emit.i32_load(offset_field);

    emit.local_set(str_off_local);

    emit.local_get(data_local);

    emit.i32_load16_u(len_field);

    emit.local_set(str_len_local);

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load(std::mem::offset_of!(scripting_format::GlobalHeader, strings_pool_offset) as u64);

    emit.local_set(pool_local);

    let i8_array_idx = ctx.type_idx("i8_array");

    emit.local_get(str_len_local);

    emit.array_new_default(i8_array_idx);

    emit.local_set(arr_local);

    emit.i32_const(0);

    emit.local_set(idx_local);

    emit.block_start();

    emit.loop_start();

    emit.local_get(idx_local);

    emit.local_get(str_len_local);

    emit.i32_ge_u();

    emit.br_if(1);

    emit.local_get(arr_local);

    emit.local_get(idx_local);

    emit.local_get(pool_local);

    emit.local_get(str_off_local);

    emit.i32_add();

    emit.local_get(idx_local);

    emit.i32_add();

    emit.i32_load8_u(0);

    emit.array_set(i8_array_idx);

    emit.local_get(idx_local);

    emit.i32_const(1);

    emit.i32_add();

    emit.local_set(idx_local);

    emit.br(0);

    emit.block_end(); // loop

    emit.block_end(); // block

    emit.local_get(arr_local);

    Ok(WasmType::StringRef)

}

pub(super) fn compile_tag_name_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TAG-NAME", args, 1)?;

    compile_tag_string_field_to_stack(

        ctx,

        emit,

        symbols,

        args,

        offset_of!(scripting_format::TagData, name_offset) as u64,

        offset_of!(scripting_format::TagData, name_len) as u64,

}

pub(super) fn compile_tag_value_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

    symbols: &mut SymbolTable,

    args: &[Expr],

) -> Result<WasmType> {

    arity_check("TAG-VALUE", args, 1)?;

    compile_tag_string_field_to_stack(

        ctx,

        emit,

        symbols,

        args,

        offset_of!(scripting_format::TagData, value_offset) as u64,

        offset_of!(scripting_format::TagData, value_len) as u64,

}

pub(super) fn compile_get_input_entities_to_stack(

    ctx: &mut CompileContext,

    emit: &mut FunctionEmitter,

) -> Result<WasmType> {

    let i_local = ctx.alloc_local(WasmType::I32);

    let result_local = ctx.alloc_local(WasmType::ConsRef);

    let cons_type = ctx.type_idx("cons");

    emit.ref_null(cons_type);

    emit.local_set(result_local);

    emit.call(ctx.func("get_input_offset"));

    emit.i32_load(0x08); // entity_count at GlobalHeader offset 8

    emit.i32_const(1);

    emit.i32_sub();

    emit.local_set(i_local);

    emit.block_start();

    emit.loop_start();

    emit.local_get(i_local);

    emit.i32_const(0);

    emit.i32_lt_s();

    emit.br_if(1);

    emit.local_get(i_local);

    emit.local_get(result_local);

    emit.struct_new(cons_type);

    emit.local_set(result_local);

    emit.local_get(i_local);

    emit.i32_const(1);

    emit.i32_sub();

    emit.local_set(i_local);

    emit.br(0);

    emit.block_end(); // end loop

    emit.block_end(); // end block

    emit.local_get(result_local);

    Ok(WasmType::ConsRef)

}

    fn test_entity_count_returns_wasm_runtime_i32() {

        let mut symbols = SymbolTable::new();

        let result = entity_count(&mut symbols, &[]).unwrap();

        assert_eq!(result, Expr::WasmRuntime(WasmType::I32));

    }

    fn test_context_type_returns_wasm_runtime_i32() {

        let mut symbols = SymbolTable::new();

        let result = context_type(&mut symbols, &[]).unwrap();

        assert_eq!(result, Expr::WasmRuntime(WasmType::I32));

    }

    fn test_primary_entity_type_returns_wasm_runtime_i32() {

        let mut symbols = SymbolTable::new();

        let result = primary_entity_type(&mut symbols, &[]).unwrap();

        assert_eq!(result, Expr::WasmRuntime(WasmType::I32));

    }

    fn test_primary_entity_idx_returns_wasm_runtime_i32() {

        let mut symbols = SymbolTable::new();

        let result = primary_entity_idx(&mut symbols, &[]).unwrap();

        assert_eq!(result, Expr::WasmRuntime(WasmType::I32));

    }

    fn test_entity_count_arity_error() {

        let mut symbols = SymbolTable::new();

        assert!(entity_count(&mut symbols, &[Expr::Nil]).is_err());

    }

    fn test_entity_type_arity_error() {

        let mut symbols = SymbolTable::new();

        assert!(entity_type(&mut symbols, &[]).is_err());

    }