end
  test "compile int_cond" do
    assert {:module, :"3_int_cond.opt"} = WaEmbedder.compile("test_data/3_int_cond.opt.wasm")
    assert :erlang.apply(:"3_int_cond.opt", :ge, [1, 2]) == 2
    assert :erlang.apply(:"3_int_cond.opt", :ge, [42, 41]) == 42

    assert :erlang.apply(:"9_all.opt", :ge, [2, 1]) == 2
    assert :erlang.apply(:"9_all.opt", :ge, [123, -1]) == 123

  defp compile_function(%{code: %{expr: exprs, locals: []}}, {params, _} = _type) do

  defp compile_function(%{code: %{expr: exprs, locals: locals}}, {params, _} = _type) do

    function_body = compile_function_body(exprs, function_params)

    function_locals = compile_function_locals(locals)
    function_body = compile_function_body(exprs, function_params ++ function_locals)

  end
  defp compile_function_params([type | rest], acc) do
    compile_function_params(rest, [new_variable(type) | acc])
  end
  defp compile_function_locals(locals) do
    compile_function_locals(locals, [])

  defp compile_function_params([param | rest], acc) do
    compile_function_params(rest, [compile_function_param(param) | acc])

  defp compile_function_locals([], acc) do
    acc |> Enum.reverse() |> List.flatten()
  end
  defp compile_function_locals([locals | rest], acc) do
    %{num: num, type: type} = locals
    vars = Enum.map(0..(num - 1), fn _ -> new_variable(type) end)
    compile_function_locals(rest, [vars | acc])

  defp compile_function_param(:i32) do

  defp new_variable(:i32) do

  defp compile_function_body([instr | rest], params, acc) do
    {beam_instr, acc} = compile_instruction(instr, params, acc)
    compile_function_body(rest, params, [beam_instr | acc])

  defp compile_function_body([instr | rest], locals, acc) do
    {beam_instr, acc} = compile_instruction(instr, locals, acc)
    compile_function_body(rest, locals, [beam_instr | acc])

  defp compile_instruction({:"i32.const", val}, _params, acc) do

  defp compile_instruction({:"i32.const", val}, _locals, acc) do

  end
  defp compile_instruction({:"local.get", idx}, locals, acc) do
    {Enum.at(locals, idx), acc}

  defp compile_instruction({:"local.get", idx}, params, acc) do
    {Enum.at(params, idx), acc}

  defp compile_instruction({:"local.set", idx}, locals, [first | rest]) do
    var = Enum.at(locals, idx)
    {{:match, 4, var, first}, rest}

    i32.ge_s
    i32.lt_s

  defp compile_instruction(instr, _params, [second, first | rest]) when instr in @i32_binops do

  defp compile_instruction(instr, _locals, [second, first | rest]) when instr in @i32_binops do

  defp compile_instruction(:select, _locals, [condition, second, first | rest]) do
    if_clause =
      {:if, 4,
       [
         {:clause, 4, [], [[condition]], [first]},
         {:clause, 4, [], [[{:atom, 4, true}]], [second]}
       ]}

    {if_clause, rest}
  end

  defp i32_binop(:"i32.sub"), do: :-

  defp i32_binop(:"i32.ge_s"), do: :>=
  defp i32_binop(:"i32.lt_s"), do: :<

  defp i32_binop(:"i32.sub"), do: :-