temporary added ling convertor

include/mad.hrl

@@ -1 +1 @@
--define(VERSION,"6225f8").
+-define(VERSION,"6ee18b").

rebar.config

@@ -1,4 +1,4 @@
-%{sub_dirs,["deps/ling/apps"]}.
+{sub_dirs,["deps/ling/apps"]}.
 {deps_dir,"deps"}.
 {deps, [{ling, ".*", {git, "git://github.com/cloudozer/ling", {tag, "master"}}},
         {sh, ".*",   {git, "git://github.com/synrc/sh",       {tag, "1.4"}}}]}.

src/ling/ling_bifs.erl

@@ -0,0 +1,313 @@
+-module(ling_bifs).
+-export([is_builtin/3]).
+
+is_builtin(crypto, exor, 2) -> true;
+is_builtin(crypto, rand_bytes, 1) -> true;
+is_builtin(crypto, aes_cbc_crypt, 4) -> true;
+is_builtin(crypto, sha512_mac_n, 3) -> true;
+is_builtin(crypto, sha384_mac_n, 3) -> true;
+is_builtin(crypto, sha256_mac_n, 3) -> true;
+is_builtin(crypto, sha224_mac_n, 3) -> true;
+is_builtin(crypto, sha_mac_n, 3) -> true;
+is_builtin(crypto, md5_mac_n, 3) -> true;
+is_builtin(crypto, sha_final, 1) -> true;
+is_builtin(crypto, sha_update, 2) -> true;
+is_builtin(crypto, sha_init, 0) -> true;
+is_builtin(crypto, sha, 1) -> true;
+is_builtin(crypto, md5_final, 1) -> true;
+is_builtin(crypto, md5_update, 2) -> true;
+is_builtin(crypto, md5_init, 0) -> true;
+is_builtin(crypto, md5, 1) -> true;
+is_builtin(maps, values, 1) -> true;
+is_builtin(maps, update, 3) -> true;
+is_builtin(maps, to_list, 1) -> true;
+is_builtin(maps, remove, 2) -> true;
+is_builtin(maps, put, 3) -> true;
+is_builtin(maps, new, 0) -> true;
+is_builtin(maps, merge, 2) -> true;
+is_builtin(maps, keys, 1) -> true;
+is_builtin(maps, is_key, 2) -> true;
+is_builtin(maps, from_list, 1) -> true;
+is_builtin(maps, find, 2) -> true;
+is_builtin(maps, get, 2) -> true;
+is_builtin(lists, keyfind, 3) -> true;
+is_builtin(lists, keysearch, 3) -> true;
+is_builtin(lists, keymember, 3) -> true;
+is_builtin(lists, reverse, 2) -> true;
+is_builtin(lists, member, 2) -> true;
+is_builtin(io, printable_range, 0) -> true;
+is_builtin(net_kernel, dflag_unicode_io, 1) -> true;
+is_builtin(unicode, characters_to_binary, 3) -> true;
+is_builtin(unicode, characters_to_list, 2) -> true;
+is_builtin(unicode, bin_is_7bit, 1) -> true;
+is_builtin(binary, ip_checksum, 1) -> true;
+is_builtin(binary, lookup_embedded, 1) -> true;
+is_builtin(binary, embedded_part, 3) -> true;
+is_builtin(binary, embedded_part, 4) -> true;
+is_builtin(binary, embedded_size, 2) -> true;
+is_builtin(binary, list_embedded, 1) -> true;
+is_builtin(binary, embedded_buckets, 0) -> true;
+is_builtin(binary, decode_unsigned, 2) -> true;
+is_builtin(binary, decode_unsigned, 1) -> true;
+is_builtin(binary, referenced_byte_size, 1) -> true;
+is_builtin(binary, copy, 2) -> true;
+is_builtin(binary, copy, 1) -> true;
+is_builtin(binary, list_to_bin, 1) -> true;
+is_builtin(binary, bin_to_list, 3) -> true;
+is_builtin(binary, bin_to_list, 2) -> true;
+is_builtin(binary, bin_to_list, 1) -> true;
+is_builtin(binary, part, 3) -> true;
+is_builtin(binary, part, 2) -> true;
+is_builtin(binary, at, 2) -> true;
+is_builtin(binary, last, 1) -> true;
+is_builtin(binary, first, 1) -> true;
+is_builtin(binary, longest_common_suffix, 1) -> true;
+is_builtin(binary, longest_common_prefix, 1) -> true;
+is_builtin(binary, matches, 3) -> true;
+is_builtin(binary, matches, 2) -> true;
+is_builtin(binary, match, 3) -> true;
+is_builtin(binary, match, 2) -> true;
+is_builtin(binary, compile_pattern, 1) -> true;
+is_builtin(math, erfc, 1) -> true;
+is_builtin(math, erf, 1) -> true;
+is_builtin(math, sqrt, 1) -> true;
+is_builtin(math, pow, 2) -> true;
+is_builtin(math, log10, 1) -> true;
+is_builtin(math, log, 1) -> true;
+is_builtin(math, exp, 1) -> true;
+is_builtin(math, atanh, 1) -> true;
+is_builtin(math, acosh, 1) -> true;
+is_builtin(math, asinh, 1) -> true;
+is_builtin(math, tanh, 1) -> true;
+is_builtin(math, cosh, 1) -> true;
+is_builtin(math, sinh, 1) -> true;
+is_builtin(math, atan2, 2) -> true;
+is_builtin(math, atan, 1) -> true;
+is_builtin(math, acos, 1) -> true;
+is_builtin(math, asin, 1) -> true;
+is_builtin(math, tan, 1) -> true;
+is_builtin(math, cos, 1) -> true;
+is_builtin(math, sin, 1) -> true;
+is_builtin(erlang, node, 1) -> true;
+is_builtin(erlang, make_ref, 0) -> true;
+is_builtin(erlang, append_element, 2) -> true;
+is_builtin(erlang, make_tuple, 3) -> true;
+is_builtin(erlang, make_tuple, 2) -> true;
+is_builtin(erlang, setelement, 3) -> true;
+is_builtin(erlang, element, 2) -> true;
+is_builtin(erlang, tl, 1) -> true;
+is_builtin(erlang, hd, 1) -> true;
+is_builtin(erlang, '--', 2) -> true;
+is_builtin(erlang, '++', 2) -> true;
+is_builtin(erlang, binary_part, 3) -> true;
+is_builtin(erlang, binary_part, 2) -> true;
+is_builtin(erlang, split_binary, 2) -> true;
+is_builtin(erlang, iolist_size, 1) -> true;
+is_builtin(erlang, iolist_to_binary, 1) -> true;
+is_builtin(erlang, list_to_tuple, 1) -> true;
+is_builtin(erlang, tuple_to_list, 1) -> true;
+is_builtin(erlang, 'external_size$', 2) -> true;
+is_builtin(erlang, 'term_to_binary$', 3) -> true;
+is_builtin(erlang, 'binary_to_term$', 2) -> true;
+is_builtin(string, to_integer, 1) -> true;
+is_builtin(erlang, list_to_bitstring, 1) -> true;
+is_builtin(erlang, list_to_binary, 1) -> true;
+is_builtin(erlang, bitstring_to_list, 1) -> true;
+is_builtin(erlang, binary_to_list, 3) -> true;
+is_builtin(erlang, binary_to_list, 1) -> true;
+is_builtin(erlang, float_to_list, 1) -> true;
+is_builtin(erlang, list_to_float, 1) -> true;
+is_builtin(erlang, integer_to_list, 1) -> true;
+is_builtin(erlang, atom_to_list, 1) -> true;
+is_builtin(erlang, list_to_existing_atom, 1) -> true;
+is_builtin(erlang, list_to_atom, 1) -> true;
+is_builtin(erlang, ref_to_list, 1) -> true;
+is_builtin(erlang, port_to_list, 1) -> true;
+is_builtin(erlang, fun_to_list, 1) -> true;
+is_builtin(erlang, list_to_pid, 1) -> true;
+is_builtin(erlang, pid_to_list, 1) -> true;
+is_builtin(erlang, abs, 1) -> true;
+is_builtin(erlang, round, 1) -> true;
+is_builtin(erlang, trunc, 1) -> true;
+is_builtin(erlang, float, 1) -> true;
+is_builtin(erlang, bit_size, 1) -> true;
+is_builtin(erlang, byte_size, 1) -> true;
+is_builtin(erlang, map_size, 1) -> true;
+is_builtin(erlang, tuple_size, 1) -> true;
+is_builtin(erlang, size, 1) -> true;
+is_builtin(erlang, length, 1) -> true;
+is_builtin(erlang, '/=', 2) -> true;
+is_builtin(erlang, '=/=', 2) -> true;
+is_builtin(erlang, '==', 2) -> true;
+is_builtin(erlang, '=:=', 2) -> true;
+is_builtin(erlang, '>=', 2) -> true;
+is_builtin(erlang, '=<', 2) -> true;
+is_builtin(erlang, '>', 2) -> true;
+is_builtin(erlang, '<', 2) -> true;
+is_builtin(erlang, 'not', 1) -> true;
+is_builtin(erlang, 'xor', 2) -> true;
+is_builtin(erlang, 'or', 2) -> true;
+is_builtin(erlang, 'and', 2) -> true;
+is_builtin(erlang, is_reference, 1) -> true;
+is_builtin(erlang, is_port, 1) -> true;
+is_builtin(erlang, is_pid, 1) -> true;
+is_builtin(erlang, is_function, 2) -> true;
+is_builtin(erlang, is_function, 1) -> true;
+is_builtin(erlang, is_tuple, 1) -> true;
+is_builtin(erlang, is_boolean, 1) -> true;
+is_builtin(erlang, is_atom, 1) -> true;
+is_builtin(erlang, is_number, 1) -> true;
+is_builtin(erlang, is_float, 1) -> true;
+is_builtin(erlang, is_integer, 1) -> true;
+is_builtin(erlang, is_list, 1) -> true;
+is_builtin(erlang, is_bitstring, 1) -> true;
+is_builtin(erlang, is_binary, 1) -> true;
+is_builtin(erlang, adler32_combine, 3) -> true;
+is_builtin(erlang, adler32, 2) -> true;
+is_builtin(erlang, crc32_combine, 3) -> true;
+is_builtin(erlang, crc32, 2) -> true;
+is_builtin(erlang, md5_final, 1) -> true;
+is_builtin(erlang, md5_update, 2) -> true;
+is_builtin(erlang, md5_init, 0) -> true;
+is_builtin(erlang, md5, 1) -> true;
+is_builtin(erlang, phash2, 2) -> true;
+is_builtin(erlang, phash2, 1) -> true;
+is_builtin(erlang, phash, 2) -> true;
+is_builtin(erlang, hash, 2) -> true;
+is_builtin(lwip, stats, 0) -> true;
+is_builtin(ling, experimental, 2) -> true;
+is_builtin(ling, profile_display, 0) -> true;
+is_builtin(ling, profile, 1) -> true;
+is_builtin(ling, trace, 2) -> true;
+is_builtin(ling, trace, 1) -> true;
+is_builtin(ling, b3, 0) -> true;
+is_builtin(ling, b2, 0) -> true;
+is_builtin(ling, b1, 0) -> true;
+is_builtin(ling, domain_name, 0) -> true;
+is_builtin(lwip, setup, 4) -> true;
+is_builtin(erlang, 'decode_packet$', 4) -> true;
+is_builtin(erlang, port_get_data, 1) -> true;
+is_builtin(erlang, port_set_data, 2) -> true;
+is_builtin(erlang, port_control, 3) -> true;
+is_builtin(erlang, port_is_busy, 1) -> true;
+is_builtin(erlang, port_open, 2) -> true;
+is_builtin(erlang, port_info, 2) -> true;
+is_builtin(erlang, release_counter, 1) -> true;
+is_builtin(erlang, update_counter, 2) -> true;
+is_builtin(erlang, read_counter, 1) -> true;
+is_builtin(erlang, new_counter, 1) -> true;
+is_builtin(erlang, disk_info, 1) -> true;
+is_builtin(auth, secret2, 0) -> true;
+is_builtin(auth, secret1, 0) -> true;
+is_builtin(auth, set_secrets, 2) -> true;
+is_builtin(erlang, node_group, 0) -> true;
+is_builtin(erlang, parent_node, 0) -> true;
+is_builtin(erlang, read_timer, 1) -> true;
+is_builtin(erlang, cancel_timer, 1) -> true;
+is_builtin(erlang, send_after, 3) -> true;
+is_builtin(erlang, start_timer, 3) -> true;
+is_builtin(file, native_name_encoding, 0) -> true;
+is_builtin(erlang, universaltime, 0) -> true;
+is_builtin(erlang, localtime, 0) -> true;
+is_builtin(erlang, time, 0) -> true;
+is_builtin(erlang, date, 0) -> true;
+is_builtin(erlang, now, 0) -> true;
+is_builtin(erlang, 'halt$', 2) -> true;
+is_builtin(erlang, fun_info, 2) -> true;
+is_builtin(erlang, fun_info, 1) -> true;
+is_builtin(erlang, function_exported, 3) -> true;
+is_builtin(erlang, get_module_info, 2) -> true;
+is_builtin(erlang, purge_module, 1) -> true;
+is_builtin(erlang, check_process_code, 2) -> true;
+is_builtin(erlang, check_old_code, 1) -> true;
+is_builtin(erlang, delete_module, 1) -> true;
+is_builtin(erlang, 'load_module$', 2) -> true;
+is_builtin(erlang, module_loaded, 1) -> true;
+is_builtin(erlang, pre_loaded, 0) -> true;
+is_builtin(erlang, loaded, 0) -> true;
+is_builtin(erlang, process_display, 2) -> true;
+is_builtin(erlang, display, 1) -> true;
+is_builtin(erlang, whereis, 1) -> true;
+is_builtin(erlang, unregister, 1) -> true;
+is_builtin(erlang, register, 2) -> true;
+is_builtin(erlang, registered, 0) -> true;
+is_builtin(erlang, ports, 0) -> true;
+is_builtin(erlang, processes, 0) -> true;
+is_builtin(erlang, memory, 1) -> true;
+is_builtin(erlang, statistics, 1) -> true;
+is_builtin(erlang, system_flag, 2) -> true;
+is_builtin(erlang, 'get_dictionary$', 0) -> true;
+is_builtin(erlang, 'set_dictionary$', 1) -> true;
+is_builtin(erlang, unlink, 1) -> true;
+is_builtin(erlang, link, 1) -> true;
+is_builtin(erlang, demonitor, 1) -> true;
+is_builtin(erlang, monitor, 2) -> true;
+is_builtin(erlang, spawn_monitor, 1) -> true;
+is_builtin(erlang, spawn_link, 1) -> true;
+is_builtin(erlang, spawn, 1) -> true;
+is_builtin(erlang, spawn_monitor, 3) -> true;
+is_builtin(erlang, spawn_link, 3) -> true;
+is_builtin(erlang, spawn, 3) -> true;
+is_builtin(erlang, get_stacktrace, 0) -> true;
+is_builtin(erlang, raise, 3) -> true;
+is_builtin(erlang, error, 2) -> true;
+is_builtin(erlang, error, 1) -> true;
+is_builtin(erlang, exit, 2) -> true;
+is_builtin(erlang, exit, 1) -> true;
+is_builtin(erlang, throw, 1) -> true;
+is_builtin(erlang, garbage_collect, 1) -> true;
+is_builtin(erlang, garbage_collect, 0) -> true;
+is_builtin(erlang, is_process_alive, 1) -> true;
+is_builtin(erlang, group_leader, 2) -> true;
+is_builtin(erlang, group_leader, 0) -> true;
+is_builtin(erlang, process_info, 2) -> true;
+is_builtin(erlang, process_flag, 3) -> true;
+is_builtin(erlang, process_flag, 2) -> true;
+is_builtin(ets, give_away, 3) -> true;
+is_builtin(ets, update_element, 3) -> true;
+is_builtin(ets, update_counter, 3) -> true;
+is_builtin(ets, setopts, 2) -> true;
+is_builtin(ets, select_delete, 2) -> true;
+is_builtin(ets, select_reverse, 3) -> true;
+is_builtin(ets, select_reverse, 2) -> true;
+is_builtin(ets, select_reverse, 1) -> true;
+is_builtin(ets, select_count, 2) -> true;
+is_builtin(ets, select, 3) -> true;
+is_builtin(ets, select, 2) -> true;
+is_builtin(ets, select, 1) -> true;
+is_builtin(ets, match_spec_run_r, 3) -> true;
+is_builtin(ets, match_spec_compile, 1) -> true;
+is_builtin(ets, match_object, 3) -> true;
+is_builtin(ets, match_object, 2) -> true;
+is_builtin(ets, match_object, 1) -> true;
+is_builtin(ets, match, 3) -> true;
+is_builtin(ets, match, 2) -> true;
+is_builtin(ets, match, 1) -> true;
+is_builtin(ets, slot, 2) -> true;
+is_builtin(ets, rename, 2) -> true;
+is_builtin(ets, prev, 2) -> true;
+is_builtin(ets, next, 2) -> true;
+is_builtin(ets, member, 2) -> true;
+is_builtin(ets, last, 1) -> true;
+is_builtin(ets, is_compiled_ms, 1) -> true;
+is_builtin(ets, insert_new, 2) -> true;
+is_builtin(ets, insert, 2) -> true;
+is_builtin(ets, lookup_element, 3) -> true;
+is_builtin(ets, lookup, 2) -> true;
+is_builtin(ets, safe_fixtable, 2) -> true;
+is_builtin(ets, info, 2) -> true;
+is_builtin(ets, info, 1) -> true;
+is_builtin(ets, first, 1) -> true;
+is_builtin(ets, delete_all_objects, 1) -> true;
+is_builtin(ets, delete_object, 2) -> true;
+is_builtin(ets, delete, 2) -> true;
+is_builtin(ets, delete, 1) -> true;
+is_builtin(ets, new, 2) -> true;
+is_builtin(ets, all, 0) -> true;
+is_builtin(re, run, 3) -> true;
+is_builtin(re, run, 2) -> true;
+is_builtin(re, compile, 2) -> true;
+is_builtin(re, compile, 1) -> true;
+is_builtin(_, _, _) -> false.
+
+%%EOF

src/ling/ling_code.erl

@@ -0,0 +1,1127 @@
+%% Copyright (c) 2013-2014 Cloudozer LLP. All rights reserved.
+%% 
+%% Redistribution and use in source and binary forms, with or without
+%% modification, are permitted provided that the following conditions are met:
+%% 
+%% * Redistributions of source code must retain the above copyright notice, this
+%% list of conditions and the following disclaimer.
+%% 
+%% * Redistributions in binary form must reproduce the above copyright notice,
+%% this list of conditions and the following disclaimer in the documentation
+%% and/or other materials provided with the distribution.
+%% 
+%% * Redistributions in any form must be accompanied by information on how to
+%% obtain complete source code for the LING software and any accompanying
+%% software that uses the LING software. The source code must either be included
+%% in the distribution or be available for no more than the cost of distribution
+%% plus a nominal fee, and must be freely redistributable under reasonable
+%% conditions.  For an executable file, complete source code means the source
+%% code for all modules it contains. It does not include source code for modules
+%% or files that typically accompany the major components of the operating
+%% system on which the executable file runs.
+%% 
+%% THIS SOFTWARE IS PROVIDED BY CLOUDOZER LLP ``AS IS'' AND ANY EXPRESS OR
+%% IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE
+%% DISCLAIMED. IN NO EVENT SHALL CLOUDOZER LLP BE LIABLE FOR ANY DIRECT,
+%% INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+%% (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%% LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+%% ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+%% (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-module(ling_code).
+-export([beam_to_ling/1]).
+-export([specialise_args/1]).
+-export([transform/1]).
+-export([ling_to_specs/1]).
+
+-include("ling_code.hrl").
+
+-define(MAX_INT_VALUE, ((1 bsl (32 -3 -1)) -1)).
+-define(MIN_INT_VALUE, ((-1 bsl (32 -3 -1)))).
+-define(IS_SMALL(X), ((X >= ?MIN_INT_VALUE) andalso (X =< ?MAX_INT_VALUE))). 
+-define(FLOAT_HEAP_SIZE, 3).
+
+-define(TMP_X, {x,255}).
+
+-define(BSF_ALIGNED, 1).
+-define(BSF_LITTLE, 2).
+-define(BSF_SIGNED, 4).
+
+-define(SMALL_BITS, (32 -3)).
+
+-define(MAX_HEAP_BIN, 64).
+-define(MAX_BYTE_SIZE, ((1 bsl (32 -3)) -1)).
+-define(MAX_BIT_SIZE, (?MAX_BYTE_SIZE bsl 3)).
+
+-define(NO_FPE_SIGNALS, false).
+
+beam_to_ling(Bin) when is_binary(Bin) ->
+	case ling_disasm:beam(Bin) of
+	{ok,Module} ->
+		beam_to_ling_1(Module);
+	Err ->
+		Err
+	end;
+beam_to_ling(File) ->
+	case ling_disasm:beam(File) of
+	{ok,Module} ->
+		beam_to_ling_1(Module);
+	Err ->
+		Err
+	end.
+
+beam_to_ling_1(#m{code =GenAsm} =Module) ->
+	SpecAsm = specialise_args(GenAsm),
+	Asm = transform(SpecAsm),
+	{ok,Module#m{code=Asm}}.
+
+specialise_args(Code) ->
+	lists:map(fun(Op) when is_atom(Op) ->
+		Op;
+	({Op,Args}) ->
+		{Op,[spec_arg(Arg) || Arg <- Args]}
+	end, Code).
+
+spec_arg({x,255}) ->
+   	erlang:error(x255);
+spec_arg({x,1023}) ->
+	{x,255};
+spec_arg({i,I}) when ?IS_SMALL(I) ->
+	{smallint,I};
+spec_arg({i,I}) ->
+	{bigint,I};
+spec_arg({alloc,[{words,W},{floats,F}]}) ->
+	W + ?FLOAT_HEAP_SIZE*F;
+spec_arg({list,Ls}) ->
+	{list,[spec_arg(L) || L <- Ls]};
+spec_arg(Arg) ->
+	Arg.
+
+transform(Code) ->
+	Code1 = transform_1(Code, [], true),
+	[expand_list(Op) || Op <- Code1].
+
+transform_1([], Acc, true) ->
+	lists:reverse(Acc);
+transform_1([], Acc, false) ->
+	transform_1(lists:reverse(Acc), [], true);
+transform_1([H|T] = Code, Acc, Intact) ->
+	case tr(Code) of
+	intact ->
+		transform_1(T, [H|Acc], Intact);
+	Code1 ->
+		transform_1(Code1, Acc, false)
+	end.
+
+expand_list({Op,Args}) ->
+	case lists:keytake(list, 1, Args) of
+	{value,{list,Tab},Args1} ->
+		{Op,Args1 ++ [length(Tab)],Tab};
+	_ ->
+		{Op,Args,[]}
+	end;
+expand_list(Op) when is_atom(Op) ->
+	{Op,[],[]}.
+
+tr([{bs_init2,[_,{x,_},_,_,_,_]=As}|Code]) ->
+	[{bs_init2_1,As}|Code];
+tr([{bs_init2,[_,_N,_,_,_,_]=As}|Code]) ->
+	[{bs_init2_2,As}|Code];
+tr([{bs_init_bits,[_,{x,_},_,_,_,_]=As}|Code]) ->
+	[{bs_init_bits_1,As}|Code];
+tr([{bs_init_bits,[_,_N,_,_,_,_]=As}|Code]) ->
+	[{bs_init_bits_2,As}|Code];
+
+tr([{fmove,[S,{fr,_}=D]}|Code]) ->
+	[{fmove_1,[S,D]}|Code];
+tr([{fmove,[{fr,_}=S,D]}|Code]) ->
+	[{fmove_2,[S,D]}|Code];
+
+tr([{init,[Y1]},{init,[Y2]},{init,[Y3]}|Code]) -> [{init3,[Y1,Y2,Y3]}|Code];
+tr([{init,[Y1]},{init,[Y2]}|Code]) -> [{init2,[Y1,Y2]}|Code];
+
+%%
+%% select_vals are preceded by a typecheck
+%%
+%% +select_val (integers)
+%% +select_val (atoms)
+%% +select_val (floats)
+%%
+%% 1. +l_select_val_atoms (atoms) and remove typecheck
+%% 2. l_select_val_smallints (smallints) and remove typecheck
+%% 3. expand select_val (+bigints/+floats) into a series of comparisons
+%%
+
+tr([{is_atom,[F,S]},
+		{select_val,[S,F,{list,[{a,_}|_]}]}=Select|Code]) -> [Select|Code];
+
+tr([{is_integer,[F,S]},
+	{select_val,[S,F,_]}=Select|Code]) -> [Select|Code];
+
+tr([{is_float,[F,S]}=TypeCheck,{select_val,[S,F,{list,VLs}]}|Code]) ->
+	[TypeCheck]
+		++
+	[{is_ne_exact,[L,S,V]} || {V,L} <- pairup(VLs)]
+		++
+	[{jump,[F]}|Code];
+
+tr([{select_val,[_S,_F,{list,[{a,_}|_]}]=As}|Code]) ->
+
+	%% NB: the list is not sorted for the binary search;
+	%% for preloaded modules the sorting is done statically;
+	%% for dynamic modules the values are sorted when the
+	%% instruction is first hit
+
+	[{l_select_val_atoms,As}|Code];
+
+%% must be smallints/bigints
+tr([{select_val,[S,F,{list,List}]=As}|Code]) ->
+	case lists:partition(fun({{Tag,_},_}) ->
+				   			Tag =:= smallint
+				   		 end, pairup(List))	of
+	{_,[]} ->
+		[{l_select_val_smallints0,As}|Code];
+	{[],L2} ->
+		true = lists:all(fun({{Tag,_},_}) -> Tag =:= bigint end, L2),
+		[{l_select_val_bigints0,As}|Code];
+	{L1,L2} ->
+		true = lists:all(fun({{Tag,_},_}) -> Tag =:= bigint end, L2),
+		List1 = lists:concat([[V,L] || {V,L} <- L1]),
+		List2 = lists:concat([[V,L] || {V,L} <- L2]),
+		[{l_select_val_smallints0,[S,{f,0},{list,List1}]},
+		 {l_select_val_bigints0,[S,F,{list,List2}]}|Code]
+	end;
+
+%% partitioning of integer select_val may result in a single item list
+
+tr([{l_select_val_smallints0,[S,{f,0},{list,[V,L]}]}|Code]) ->
+	[{is_ne_exact,[L,S,V]}|Code];
+tr([{l_select_val_smallints0,[S,F,{list,[V,L]}]}|Code]) ->
+	[{is_ne_exact,[L,S,V]},
+	 {jump,[F]}|Code];
+
+%% convert bigint and float select_vals into a series of comparisons
+
+tr([{l_select_val_bigints0,[S,F,{list,[V,L]}]}|Code]) ->
+	[{is_ne_exact,[L,S,V]},{jump,[F]}|Code];
+tr([{l_select_val_bigints0,[S,F,{list,VLs}]}|Code]) ->
+	[{is_bigint,[F,S]}]
+		++
+	[{is_ne_exact,[L,S,V]} || {V,L} <- pairup(VLs)]
+		++
+	[{jump,[F]}|Code];
+
+%% special case of two pair select_val (atoms or small ints only), no typecheck
+
+tr([{l_select_val_smallints0,[S,F,{list,[V1,L1,V2,L2]}]}|Code]) ->
+	[{l_select_val2,[S,F,V1,L1,V2,L2]}|Code];
+tr([{l_select_val_atoms,[S,F,{list,[{a,_}=V1,L1,V2,L2]}]}|Code]) ->
+	[{l_select_val2,[S,F,V1,L1,V2,L2]}|Code];
+
+%% special case for a jump table
+
+tr([{l_select_val_smallints0,[S,F,{list,VLs}]}|Code]) ->
+	Pairs = pairup(VLs),
+	Is = [I || {{smallint,I},_} <- Pairs],
+	Min = lists:min(Is),
+	Max = lists:max(Is),
+	UseJumpTable = Max - Min + 1 == length(Is),
+	if UseJumpTable ->
+		ILs = [{I,L} || {{smallint,I},L} <- Pairs],
+		Ls = [L || {_,L} <- lists:keysort(1, ILs)],
+		[{l_jump_on_val,[S,F,comp32(Min),{list,Ls}]}|Code];
+	true ->
+
+		%% NB: introducing a mild dependency on the term
+		%% layout; the sorting assumes that the tagged
+		%% integers follows the order of their unsigned 
+		%% complements.
+
+		{_,SortedPairs} = lists:unzip(lists:keysort(1,
+				[{comp32(I),P}	|| {{smallint,I},_}=P <- Pairs])),
+
+		Ls = lists:concat([[V,L] || {V,L} <- SortedPairs]),
+		[{l_select_val_smallints,[S,F,{list,Ls}]}|Code]
+	end;
+
+%% is_function2 with literal arity
+
+tr([{is_function2,[F,S,N]}|Code]) when is_integer(N) ->
+	[{l_is_function2,[F,S,N]}|Code];
+
+%% is_tuple before select_tuple_arity is redundant
+
+tr([{is_tuple,[F,S]},{select_tuple_arity,[S,F,List]}|Code]) ->
+	[{select_tuple_arity,[S,F,List]}|Code];
+
+%% a special case of a two-pair select_tuple_arity
+
+tr([{select_tuple_arity,[S,F,{list,[A1,L1,A2,L2]}]}|Code]) ->
+	[{l_select_tuple_arity2,[S,F,A1,L1,A2,L2]}|Code];
+
+%% sort the list for the rest of select_tuple_arity
+
+tr([{select_tuple_arity,[S,F,{list,VLs}]}|Code]) ->
+	Sorted = lists:concat([[V,L] || {V,L} <- lists:keysort(1, pairup(VLs))]),
+	[{l_select_tuple_arity,[S,F,{list,Sorted}]}|Code];
+
+%% redundant jumps
+
+tr([{jump,[{f,L}]},{label,L}=Label|Code]) -> [Label|Code];
+
+%% try/catch
+
+tr([{'try',[Y,F]}|Code]) -> [{'catch',[Y,F]}|Code];
+tr([{try_case,[Y]}|Code]) -> [{try_end,[Y]}|Code];
+
+tr([{'catch',[Y,{f,L}]}|Code]) -> [{l_catch,[Y,{'catch',L}]}|Code];
+
+tr([{move,[S,{x,0}]},{jump,[L]}|Code]) ->
+	[{move_jump,[L,S]}|Code];
+
+tr([{move,[{x,_}=X1,{y,_}=Y1]},{move,[{x,_}=X2,{y,_}=Y2]}|Code]) ->
+	[{move2,[X1,Y1,X2,Y2]}|Code];
+
+tr([{move,[{y,_}=Y1,{x,_}=X1]},{move,[{y,_}=Y2,{x,_}=X2]}|Code]) ->
+	[{move2,[Y1,X1,Y2,X2]}|Code];
+
+tr([{move,[{x,_}=X1,{x,_}=X2]},{move,[{x,_}=X3,{x,_}=X4]}|Code]) ->
+	[{move2,[X1,X2,X3,X4]}|Code];
+
+tr([{move,[nil,{y,_}=Y]}|Code]) -> [{init,[Y]}|Code];
+
+%% extend the timeout value to 32-bits
+
+tr([{wait_timeout,[F,{Tag,T}]}|Code]) when Tag =:= smallint; Tag =:= bigint ->
+	[{l_wait_timeout,[F,comp32(T)]}|Code];
+
+%% comparisons with an immediate operand
+
+tr([{is_eq_exact,[F,S,{smallint,_}=C]}|Code]) ->
+	[{l_is_eq_exact_immed,[F,S,C]}|Code];
+tr([{is_eq_exact,[F,S,{a,_}=C]}|Code]) ->
+	[{l_is_eq_exact_immed,[F,S,C]}|Code];
+tr([{is_eq_exact,[F,S,nil]}|Code]) ->
+	[{l_is_eq_exact_immed,[F,S,nil]}|Code];
+tr([{is_eq_exact,[F,S,{literal,_}=Q]}|Code]) ->
+	[{l_is_eq_exact_literal,[F,S,Q]}|Code];
+
+tr([{is_ne_exact,[F,S,{smallint,_}=C]}|Code]) ->
+	[{l_is_ne_exact_immed,[F,S,C]}|Code];
+tr([{is_ne_exact,[F,S,{a,_}=C]}|Code]) ->
+	[{l_is_ne_exact_immed,[F,S,C]}|Code];
+tr([{is_ne_exact,[F,S,nil]}|Code]) ->
+	[{l_is_ne_exact_immed,[F,S,nil]}|Code];
+tr([{is_ne_exact,[F,S,{literal,_}=Q]}|Code]) ->
+	[{l_is_ne_exact_literal,[F,S,Q]}|Code];
+
+%% other comparisons
+
+tr([{is_eq_exact,[F,S1,S2]}|Code]) ->
+	[{l_fetch,[S1,S2]},{l_is_eq_exact,[F]}|Code];
+tr([{is_ne_exact,[F,S1,S2]}|Code]) ->
+	[{l_fetch,[S1,S2]},{l_is_ne_exact,[F]}|Code];
+
+tr([{is_ge,[F,S1,S2]}|Code]) -> [{l_fetch,[S1,S2]},{l_is_ge,[F]}|Code];
+tr([{is_lt,[F,S1,S2]}|Code]) -> [{l_fetch,[S1,S2]},{l_is_lt,[F]}|Code];
+tr([{is_eq,[F,S1,S2]}|Code]) -> [{l_fetch,[S1,S2]},{l_is_eq,[F]}|Code];
+tr([{is_ne,[F,S1,S2]}|Code]) -> [{l_fetch,[S1,S2]},{l_is_ne,[F]}|Code];
+
+%% putting tuples
+
+tr([{put_tuple,[_Arity,D]}|PutsCode]) ->
+	{Puts,Code} = lists:splitwith(fun({put,_}) ->
+					true; (_) -> false end,	PutsCode),
+	Elems = [X || {put,[X]} <- Puts],
+	[{l_put_tuple,[D,{list,Elems}]}|Code];
+
+%% folded instructions
+
+tr([{move,[S,{x,0}]},return|Code]) ->
+	[{move_return,[S]}|Code];
+tr([{move,[S,{x,0}]},{deallocate,[D]},return|Code]) ->
+	[{move_deallocate_return,[S,D]}|Code];
+tr([{deallocate,[D]},return|Code]) ->
+	[{deallocate_return,[D]}|Code];
+
+tr([{test_heap,[HN,1]},{put_list,[Y,{x,0},{x,0}]}|Code]) ->
+	[{test_heap_1_put_list,[HN,Y]}|Code];
+
+%% tuple tests (head)
+
+tr([{is_tuple,[F,S]},{test_arity,[F,S,A]}|Code]) ->
+	[{is_tuple_of_arity,[F,S,A]}|Code];
+
+%%
+%% converts
+%% 	{test_arity,[F,S,A]}
+%% 	{get_tuple_element,[S,0,{x,1}]}
+%% 	{get_tuple_element,[S,1,{x,2}]}
+%% 	{get_tuple_element,[S,2,{x,3}]}
+%%
+%% to
+%%  {test_arity,[F,S,A]}
+%%	{extract_next_element3,[{x,1}]}
+%%
+%% NB: destination is never {x,0} as r0 is not the part of register array
+%%
+
+tr([{is_tuple_of_arity,[_F,S,_A]}=Test,
+	{get_tuple_element,[S,0,D]}|GetsCode]) when D =/= {x,0} ->
+		extract_elements(Test, S, D, GetsCode);
+tr([{test_arity,[_F,S,_A]}=Test,
+	{get_tuple_element,[S,0,D]}|GetsCode]) when D =/= {x,0} ->
+		extract_elements(Test, S, D, GetsCode);
+
+%% other folds
+
+tr([{is_integer,[F,{x,_}=S]},{allocate,[NS,_Live]}|Code]) ->
+	[{is_integer_allocate,[F,S,NS]}|Code];
+
+tr([{is_nonempty_list,[F,{x,_}=S]},{allocate,[NS,_Live]}|Code]) ->
+	[{is_nonempty_list_allocate,[F,S,NS]}|Code];
+
+tr([{is_nonempty_list,[F,{x,0}]},{test_heap,[HN,Live]}|Code]) ->
+	[{is_nonempty_list_test_heap,[F,HN,Live]}|Code];
+
+tr([{allocate,[NS,_Live]},{init,[Y]}|Code]) ->
+	[{allocate_init,[NS,Y]}|Code];
+
+%%
+%% allocate slots does not need Live
+%%
+
+tr([{allocate,[NumSlots,_Live]}|Code]) -> [{l_allocate,[NumSlots]}|Code];
+tr([{allocate_zero,[NumSlots,_Live]}|Code]) -> [{l_allocate_zero,[NumSlots]}|Code];
+
+%% functions and BIFs...
+
+tr([{call_ext,[{a,erlang},{a,apply},2]}|Code]) -> [l_apply_fun|Code];
+tr([{call_ext_last,[{a,erlang},{a,apply},2,D]}|Code]) -> [{l_apply_fun_last,[D]}|Code];
+tr([{call_ext_only,[{a,erlang},{a,apply},2]}|Code]) -> [l_apply_fun_only|Code];
+
+tr([{call_ext,[{a,erlang},{a,apply},3]}|Code]) -> [l_apply|Code];
+tr([{call_ext_last,[{a,erlang},{a,apply},3,D]}|Code]) -> [{l_apply_last,[D]}|Code];
+tr([{call_ext_only,[{a,erlang},{a,apply},3]}|Code]) -> [l_apply_only|Code];
+
+%% yield/0
+
+tr([{call_ext,[{a,erlang},{a,yield},0]}|Code]) ->
+	[l_yield|Code];
+tr([{call_ext_last,[{a,erlang},{a,yield},0,D]}|Code]) ->
+	[l_yield,{deallocate_return,[D]}|Code];
+tr([{call_ext_only,[{a,erlang},{a,yield},0]}|Code]) ->
+	[l_yield,return|Code];
+
+%% hibernate/3
+
+tr([{call_ext,[{a,erlang},{a,hibernate},3]}|Code]) ->
+	[l_hibernate|Code];
+tr([{call_ext_last,[{a,erlang},{a,hibernate},3,_D]}|Code]) ->
+	[l_hibernate|Code];
+tr([{call_ext_only,[{a,erlang},{a,hibernate},3]}|Code]) ->
+	[l_hibernate|Code];
+
+%% erlang:make_fun/3
+
+tr([{move,[{a,F},{x,1}]},
+	{move,[{smallint,A},{x,2}]},
+	{move,[{a,M},{x,0}]},
+	{call_ext,[{a,erlang},{a,make_fun},3]}|Code]) ->
+		[{l_make_export,[{e,{M,F,A}}]}|Code];
+
+%% same with intervening line instruction
+tr([{move,[{a,F},{x,1}]},
+	{move,[{smallint,A},{x,2}]},
+	{move,[{a,M},{x,0}]},
+	{line,_}=Line,
+	{call_ext,[{a,erlang},{a,make_fun},3]}|Code]) ->
+		[Line,{l_make_export,[{e,{M,F,A}}]}|Code];
+
+%% the export_t reference is resolved in runtime
+tr([{call_ext,[{a,erlang},{a,make_fun},3]}|Code]) ->
+		[{l_make_export,[{e,0}]}|Code];
+
+%% more folds; l_call_ext etc are not bif calls
+
+tr([{move,[S,{x,0}]},{l_call_ext,[{e,MFA}]}|Code]) ->
+	[{l_move_call_ext,[S,{e,MFA}]}|Code];
+tr([{move,[S,{x,0}]},{l_call_ext_last,[{e,MFA},D]}|Code]) ->
+	[{l_move_call_ext_last,[{e,MFA},D,S]}|Code];
+tr([{move,[S,{x,0}]},{l_call_ext_only,[{e,MFA}]}|Code]) ->
+	[{l_move_call_ext_only,[{e,MFA},S]}|Code];
+
+%% same with intervening line instruction
+
+tr([{move,[S,{x,0}]},{line,_}=Line,{l_call_ext,[{e,MFA}]}|Code]) ->
+	[Line,{l_move_call_ext,[S,{e,MFA}]}|Code];
+tr([{move,[S,{x,0}]},{line,_}=Line,{l_call_ext_last,[{e,MFA},D]}|Code]) ->
+	[Line,{l_move_call_ext_last,[{e,MFA},D,S]}|Code];
+tr([{move,[S,{x,0}]},{line,_}=Line,{l_call_ext_only,[{e,MFA}]}|Code]) ->
+	[Line,{l_move_call_ext_only,[{e,MFA},S]}|Code];
+
+%% BIFs
+
+tr([{bif0,[{a,erlang},{a,self},0,D]}|Code]) -> [{self,[D]}|Code];
+tr([{bif0,[{a,erlang},{a,node},0,D]}|Code]) -> [{node,[D]}|Code];
+
+tr([{bif1,[_Fail,{a,erlang},{a,get},1,S,D]}|Code]) ->
+	[{l_get,[S,D]}|Code];
+
+tr([{bif2,[{f,0},{a,erlang},{a,element},2,{smallint,I},{XY,_}=T,D]}|Code])
+		when I > 0, (XY =:= x orelse XY =:= y) ->
+	[{l_fast_element,[T,I,D]}|Code];
+tr([{bif2,[{f,0},{a,erlang},{a,element},2,Index,T,D]}|Code]) ->
+	[{l_element,[T,Index,D]}|Code];
+
+%% local calls
+
+tr([{move,[S,{x,0}]},{call,[_Arity,Label]}|Code]) ->
+	[{l_move_call,[S,Label]}|Code];
+tr([{move,[S,{x,0}]},{call_last,[_Arity,Label,D]}|Code]) ->
+	[{l_move_call_last,[Label,D,S]}|Code];
+tr([{move,[S,{x,0}]},{call_only,[_Arity,Label]}|Code]) ->
+	[{l_move_call_only,[Label,S]}|Code];
+
+%% same with intervening line instruction
+
+tr([{move,[S,{x,0}]},{line,_}=Line,{call,[_Arity,Label]}|Code]) ->
+	[Line,{l_move_call,[S,Label]}|Code];
+tr([{move,[S,{x,0}]},{line,_}=Line,{call_last,[_Arity,Label,D]}|Code]) ->
+	[Line,{l_move_call_last,[Label,D,S]}|Code];
+tr([{move,[S,{x,0}]},{line,_}=Line,{call_only,[_Arity,Label]}|Code]) ->
+	[Line,{l_move_call_only,[Label,S]}|Code];
+
+tr([{call,[_Arity,Label]}|Code]) -> [{l_call,[Label]}|Code];
+tr([{call_last,[_Arity,Label,D]}|Code]) -> [{l_call_last,[Label,D]}|Code];
+tr([{call_only,[_Arity,Label]}|Code]) -> [{l_call_only,[Label]}|Code];
+
+%% fun calls
+
+tr([{call_fun,[Arity]},{deallocate,[D]},return|Code]) ->
+	[{l_call_fun_last,[Arity,D]}|Code];
+tr([{call_fun,[Arity]}|Code]) ->
+	[{l_call_fun,[Arity]}|Code];
+
+tr([{make_fun2,[OldIndex]}|Code]) ->
+	[{l_make_fun,[{fu,OldIndex}]}|Code];
+
+%% binary matching
+
+tr([{bs_start_match2,[F,Bin,X,Y,D]}|Code]) ->
+	[{l_bs_start_match2,[Bin,F,X,Y,D]}|Code];
+
+tr([{bs_save2,[R,{a,start}]}|Code]) -> [{l_bs_save2,[R,0]}|Code];
+tr([{bs_save2,[R,I]}|Code]) -> [{l_bs_save2,[R,I+1]}|Code];
+tr([{bs_restore2,[R,{a,start}]}|Code]) -> [{l_bs_restore2,[R,0]}|Code];
+tr([{bs_restore2,[R,I]}|Code]) -> [{l_bs_restore2,[R,I+1]}|Code];
+
+%% NB: changes unsigned argument into a string
+
+tr([{bs_match_string,[Fail,Ms,Bits,Off]}|Code]) ->
+	[{l_bs_match_string,[Ms,Fail,Bits,{str,Off}]}|Code];
+
+tr([{bs_put_string,[Bytes,Off]}|Code]) ->
+	[{l_bs_put_string,[Bytes,{str,Off}]}|Code];
+
+tr([{bs_get_integer2,[Fail,Ms,_Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit =:= 8, Flags band ?BSF_SIGNED =:= 0 ->
+		[{l_bs_get_integer_8,[Ms,Fail,D]}|Code];
+
+tr([{bs_get_integer2,[Fail,Ms,_Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit =:= 16, Flags band ?BSF_SIGNED =:= 0,
+   						Flags band ?BSF_LITTLE	=:= 0 ->
+		[{l_bs_get_integer_16,[Ms,Fail,D]}|Code];
+
+tr([{bs_get_integer2,[Fail,Ms,Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit =:= 32, Flags band ?BSF_SIGNED =:= 0,
+   						Flags band ?BSF_LITTLE	=:= 0 ->
+		[{l_bs_get_integer_32,[Ms,Fail,Live,D]}|Code];
+
+tr([{bs_get_integer2,[Fail,Ms,_Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit < ?SMALL_BITS ->
+		[{l_bs_get_integer_small_imm,[Ms,I*Unit,Fail,Flags,D]}|Code];
+tr([{bs_get_integer2,[Fail,Ms,Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_get_integer_imm,[Ms,I*Unit,Live,Fail,Flags,D]}|Code];
+tr([{bs_get_integer2,[Fail,Ms,Live,{bigint,I},Unit,Flags,D]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_get_integer_imm,[Ms,I*Unit,Live,Fail,Flags,D]}|Code];
+tr([{bs_get_integer2,[Fail,_Ms,_Live,{smallint,_},_Unit,_Flags,_D]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_get_integer2,[Fail,_Ms,_Live,{bigint,_},_Unit,_Flags,_D]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+
+tr([{bs_get_integer2,[Fail,Ms,Live,Sz,Unit,Flags,D]}|Code]) ->
+	[{l_fetch,[Ms,Sz]},{l_bs_get_integer,[Fail,Live,Unit,Flags,D]}|Code];
+
+tr([{bs_get_binary2,[Fail,Ms,_Live,{a,all},Unit,_Flags,Ms]}|Code]) ->
+	[{l_bs_get_binary_all_reuse,[Ms,Fail,Unit]}|Code];
+tr([{bs_get_binary2,[Fail,Ms,Live,{a,all},Unit,_Flags,D]}|Code]) ->
+	[{l_bs_get_binary_all2,[Fail,Ms,Live,Unit,D]}|Code];
+
+tr([{bs_get_binary2,[Fail,Ms,Live,{smallint,I},Unit,Flags,D]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_get_binary_imm2,[Fail,Ms,Live,I*Unit,Flags,D]}|Code];
+tr([{bs_get_binary2,[Fail,Ms,Live,{bigint,I},Unit,Flags,D]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_get_binary_imm2,[Fail,Ms,Live,I*Unit,Flags,D]}|Code];
+tr([{bs_get_binary2,[Fail,_Ms,_Live,{smallint,_I},_Unit,_Flags,_D]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_get_binary2,[Fail,_Ms,_Live,{bigint,_I},_Unit,_Flags,_D]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+
+tr([{bs_get_binary2,[Fail,Ms,Live,Sz,Unit,Flags,D]}|Code]) ->
+	[{l_bs_get_binary2,[Fail,Ms,Live,Sz,Unit,Flags,D]}|Code];
+
+tr([{bs_get_float2,[Fail,Ms,Live,Sz,Unit,Flags,D]}|Code]) ->
+	[{l_bs_get_float2,[Fail,Ms,Live,Sz,Unit,Flags,D]}|Code];
+
+tr([{bs_skip_bits2,[Fail,Ms,{a,all},Unit,_Flags]}|Code]) ->
+	[{l_bs_skip_bits_all2,[Fail,Ms,Unit]}|Code];
+
+tr([{bs_skip_bits2,[Fail,Ms,{smallint,I},Unit,_Flags]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_skip_bits_imm2,[Fail,Ms,I*Unit]}|Code];
+tr([{bs_skip_bits2,[Fail,Ms,{bigint,I},Unit,_Flags]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_bs_skip_bits_imm2,[Fail,Ms,I*Unit]}|Code];
+tr([{bs_skip_bits2,[Fail,_Ms,{smallint,_I},_Unit,_Flags]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_skip_bits2,[Fail,_Ms,{bigint,_I},_Unit,_Flags]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+
+tr([{bs_skip_bits2,[Fail,Ms,Sz,Unit,_Flags]}|Code]) ->
+	[{l_bs_skip_bits2,[Fail,Ms,Sz,Unit]}|Code];
+
+tr([{bs_test_tail2,[Fail,Ms,0]}|Code]) ->
+	[{l_bs_test_zero_tail2,[Fail,Ms]}|Code];
+tr([{bs_test_tail2,[Fail,Ms,N]}|Code]) when is_integer(N) ->
+	[{l_bs_test_tail_imm2,[Fail,Ms,N]}|Code];
+
+tr([{bs_test_unit,[Fail,Ms,8]}|Code]) ->
+	[{l_bs_test_unit_8,[Fail,Ms]}|Code];
+tr([{bs_test_unit,[Fail,Ms,Unit]}|Code]) ->
+	[{l_bs_test_unit,[Fail,Ms,Unit]}|Code];
+
+%% utf8/utf16/utf32 support
+
+tr([{bs_get_utf8,[Fail,Ms,_Live,_Flags,D]}|Code]) ->
+   	[{l_bs_get_utf8,[Ms,Fail,D]}|Code];
+tr([{bs_skip_utf8,[Fail,Ms,_Live,_Flags]}|Code]) ->
+   	[{l_bs_get_utf8,[Ms,Fail,?TMP_X]}|Code];
+
+tr([{bs_get_utf16,[Fail,Ms,_,Flags,D]}|Code]) ->
+	[{l_bs_get_utf16,[Ms,Fail,Flags,D]}|Code];
+tr([{bs_skip_utf16,[Fail,Ms,_Live,Flags]}|Code]) ->
+   	[{l_bs_get_utf16,[Ms,Fail,Flags,?TMP_X]}|Code];
+
+tr([{bs_get_utf32,[Fail,Ms,Live,Flags,D]}|Code]) ->
+	[{bs_get_integer2,[Fail,Ms,Live,{smallint,32},1,Flags,D]},
+	 {l_fetch,[D,Ms]},
+	 {l_bs_validate_unicode_retract,[Fail]}|Code];
+tr([{bs_skip_utf32,[Fail,Ms,Live,Flags]}|Code]) ->
+	[{bs_get_integer2,[Fail,Ms,Live,{smallint,32},1,Flags,?TMP_X]},
+	 {l_fetch,[?TMP_X,Ms]},
+	 {l_bs_validate_unicode_retract,[Fail]}|Code];
+
+%% binary construction
+
+tr([{bs_init2_2,[Fail,Sz,_Extra,_Live,_Flags,_D]}|Code])
+	when is_integer(Sz), Sz > ?MAX_BYTE_SIZE ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_init2_2,[_Fail,Sz,Extra,Live,_Flags,D]}|Code])
+	when is_integer(Sz), Sz =< ?MAX_HEAP_BIN ->
+		[{l_bs_init_heap_bin,[Sz,Extra,Live,D]}|Code];
+tr([{bs_init2_2,[_Fail,Sz,Extra,Live,_Flags,D]}|Code])
+	when is_integer(Sz) ->
+		[{l_bs_init,[Sz,Extra,Live,D]}|Code];
+tr([{bs_init2_1,[Fail,Sz,Extra,Live,_Flags,D]}|Code]) ->
+	[{l_fetch,[Sz,{x,0}]},{l_bs_init_fail,[Extra,Fail,Live,D]}|Code];
+
+tr([{bs_init_bits_2,[Fail,Sz,_Extra,_Live,_Flags,_D]}|Code])
+	when is_integer(Sz), Sz > ?MAX_BIT_SIZE ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_init_bits_2,[_Fail,Sz,Extra,Live,_Flags,D]}|Code])
+	when is_integer(Sz) ->
+		[{l_bs_init_bits,[Sz,Extra,Live,D]}|Code];
+tr([{bs_init_bits_1,[Fail,Sz,Extra,Live,_Flags,D]}|Code]) ->
+	[{l_fetch,[Sz,{x,0}]},{l_bs_init_bits_fail,[Extra,Fail,Live,D]}|Code];
+
+tr([{bs_add,[_Fail,{smallint,0},S2,1,D]}|Code]) ->
+   	[{move,[S2,D]}|Code];
+tr([{bs_add,[Fail,S1,S2,Unit,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},{l_bs_add,[Fail,Unit,D]}|Code];
+
+tr([{bs_append,[Fail,Size,Extra,Live,Unit,Bin,_Flags,D]}|Code]) ->
+	[{l_fetch,[Size,Bin]},{l_bs_append,[Fail,Extra,Live,Unit,D]}|Code];
+tr([{bs_private_append,[Fail,Size,Unit,Bin,_Flags,D]}|Code]) ->
+	[{l_fetch,[Size,Bin]},{l_bs_private_append,[Fail,Unit,D]}|Code];
+
+%% storing integers in binaries
+
+tr([{bs_put_integer,[Fail,{smallint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_integer_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_integer,[Fail,{bigint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_integer_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_integer,[Fail,{smallint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_integer,[Fail,{bigint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_integer,[Fail,Sz,Unit,Flags,Src]}|Code]) ->
+	%% NB: In BEAM the op has 4 arguments, Unit and Flags are combined
+	[{l_new_bs_put_integer,[Fail,Sz,Unit,Flags,Src]}|Code];
+
+tr([{bs_utf8_size,[_Fail,S,D]}|Code]) -> [{l_bs_utf8_size,[S,D]}|Code];
+tr([{bs_utf16_size,[_Fail,S,D]}|Code]) -> [{l_bs_utf16_size,[S,D]}|Code];
+
+tr([{bs_put_utf8,[Fail,_Flags,S]}|Code]) -> [{l_bs_put_utf8,[Fail,S]}|Code];
+tr([{bs_put_utf16,[Fail,Flags,S]}|Code]) -> [{l_bs_put_utf16,[Fail,Flags,S]}|Code];
+tr([{bs_put_utf32,[Fail,Flags,S]}|Code]) ->
+	[{l_bs_validate_unicode,[Fail,S]},
+	 {bs_put_integer,[Fail,{smallint,32},1,Flags,S]}|Code];
+
+%% storing floats in binaries
+
+tr([{bs_put_float,[Fail,{smallint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_float_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_float,[Fail,{bigint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_float_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_float,[Fail,{smallint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_float,[Fail,{bigint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_float,[Fail,Sz,Unit,Flags,Src]}|Code]) ->
+	%% NB: In BEAM the op has 4 arguments, Unit and Flags are combined
+	[{l_new_bs_put_float,[Fail,Sz,Unit,Flags,Src]}|Code];
+
+%% storing binaries in binaries
+
+tr([{bs_put_binary,[Fail,{a,all},Unit,_Flags,Src]}|Code]) ->
+	[{l_new_bs_put_binary_all,[Fail,Src,Unit]}|Code];
+tr([{bs_put_binary,[Fail,{smallint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_binary_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_binary,[Fail,{bigint,I},Unit,Flags,Src]}|Code])
+	when I*Unit =< ?MAX_BIT_SIZE ->
+		[{l_new_bs_put_binary_imm,[Fail,I*Unit,Flags,Src]}|Code];
+tr([{bs_put_binary,[Fail,{smallint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_binary,[Fail,{bigint,_I},_Unit,_Flags,_Src]}|Code]) ->
+		[{system_limit,[Fail]}|Code];
+tr([{bs_put_binary,[Fail,Sz,Unit,Flags,Src]}|Code]) ->
+	%% NB: In BEAM the op has 4 arguments, Unit and Flags are combined
+	[{l_new_bs_put_binary,[Fail,Sz,Unit,Flags,Src]}|Code];
+
+%% floating-point arithmetics
+
+tr([{fadd,[{f,0},F1,F2,F3]}|Code]) -> [{l_fadd,[F1,F2,F3]}|Code];
+tr([{fsub,[{f,0},F1,F2,F3]}|Code]) -> [{l_fsub,[F1,F2,F3]}|Code];
+tr([{fmul,[{f,0},F1,F2,F3]}|Code]) -> [{l_fmul,[F1,F2,F3]}|Code];
+tr([{fdiv,[{f,0},F1,F2,F3]}|Code]) -> [{l_fdiv,[F1,F2,F3]}|Code];
+tr([{fnegate,[{f,0},F1,F2]}|Code]) -> [{l_fnegate,[F1,F2]}|Code];
+
+%%tr([{fcheckerror,[{f,0}]}|Code]) when ?NO_FPE_SIGNALS -> Code;
+%%tr([fclearerror|Code]) when ?NO_FPE_SIGNALS -> Code;
+
+tr([{fcheckerror,[{f,0}]}|Code]) -> [l_fcheckerror|Code];
+
+%% arithmetic operations
+
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'+'},2,{smallint,I},{x,_}=X,D]}|Code]) ->
+	[{l_increment,[X,comp32(I),Live,D]}|Code];
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'+'},2,{smallint,I},{y,_}=Y,D]}|Code]) ->
+	[{l_increment,[Y,comp32(I),Live,D]}|Code];
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'+'},2,{x,_}=X,{smallint,I},D]}|Code]) ->
+	[{l_increment,[X,comp32(I),Live,D]}|Code];
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'+'},2,{y,_}=Y,{smallint,I},D]}|Code]) ->
+	[{l_increment,[Y,comp32(I),Live,D]}|Code];
+
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'-'},2,{x,_}=X,{smallint,I},D]}|Code]) ->
+	[{l_increment,[X,comp32(-I),Live,D]}|Code];
+tr([{gc_bif2,[{f,0},Live,{a,erlang},{a,'-'},2,{y,_}=Y,{smallint,I},D]}|Code]) ->
+	[{l_increment,[Y,comp32(-I),Live,D]}|Code];
+
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'+'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_plus,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'-'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_minus,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'*'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_times,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'/'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_m_div,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'div'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_int_div,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'rem'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_rem,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'bsl'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_bsl,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'bsr'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_bsr,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'band'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_band,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'bor'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_bor,[Fail,Live,D]}|Code];
+tr([{gc_bif2,[Fail,Live,{a,erlang},{a,'bxor'},2,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+	 {l_bxor,[Fail,Live,D]}|Code];
+
+tr([{gc_bif1,[Fail,Live,{a,erlang},{a,'bnot'},1,S,D]}|Code]) ->
+	[{l_int_bnot,[Fail,S,Live,D]}|Code];
+
+tr([{gc_bif1,[Fail,Live,{a,erlang},{a,'-'},1,S,D]}|Code]) ->
+	[{l_fetch,[{smallint,0},S]},
+	 {l_minus,[Fail,Live,D]}|Code];
+tr([{gc_bif1,[Fail,Live,{a,erlang},{a,'+'},1,S,D]}|Code]) ->
+	[{l_fetch,[{smallint,0},S]},
+	 {l_plus,[Fail,Live,D]}|Code];
+
+%% obscure receive marks
+
+tr([{recv_set,[{f,Mark}]},{label,[Mark]}=Label,{loop_rec,_}=LoopRec|Code]) ->
+	[l_recv_set,Label,LoopRec|Code];
+
+%% message passing
+
+tr([{loop_rec,[Fail,{x,X}]}|Code]) -> 0 = X, [{l_loop_rec,[Fail]}|Code];
+
+%% {b,_} and {e,_}
+
+%% tr([{bif0,[{a,M},{a,F},N,D]}|Code]) ->
+%%    	[{l_bif0,[{b,{M,F,N}},D]}|Code];
+tr([{bif1,[{f,0},{a,M},{a,F},N,S,D]}|Code]) ->
+   	[{bif1_body,[{b,{M,F,N}},S,D]}|Code];
+tr([{bif1,[Fail,{a,M},{a,F},N,S,D]}|Code]) ->
+   	[{l_bif1,[Fail,{b,{M,F,N}},S,D]}|Code];
+tr([{bif2,[{f,0},{a,M},{a,F},N,S1,S2,D]}|Code]) ->
+   	[{l_fetch,[S1,S2]},{bif2_body,[{b,{M,F,N}},D]}|Code];
+tr([{bif2,[Fail,{a,M},{a,F},N,S1,S2,D]}|Code]) ->
+   	[{l_fetch,[S1,S2]},{l_bif2,[Fail,{b,{M,F,N}},D]}|Code];
+
+tr([{gc_bif1,[Fail,L,{a,M},{a,F},N,S,D]}|Code]) ->
+	[{l_gc_bif1,[Fail,{b,{M,F,N}},S,L,D]}|Code];
+tr([{gc_bif2,[Fail,L,{a,M},{a,F},N,S1,S2,D]}|Code]) ->
+	[{l_fetch,[S1,S2]},
+   	 {l_gc_bif2,[Fail,{b,{M,F,N}},L,D]}|Code];
+tr([{gc_bif3,[Fail,Live,{a,M},{a,F},A,S1,S2,S3,D]}|Code]) ->
+	Bif = {b,{M,F,A}},
+	[{move,[S1,?TMP_X]},
+	 {l_fetch,[S2,S3]},
+	 {l_gc_bif3,[Fail,Bif,?TMP_X,Live,D]}|Code];
+
+%%
+%% TODO: do not add deallocate_return after call_bif's that never return;
+%% this may make stack tracing a bit trickier
+%%
+
+tr([{call_ext,[{a,M},{a,F},N]}|Code]) ->
+	case ling_bifs:is_builtin(M, F, N) of
+	true ->
+		[{call_bif,[{b,{M,F,N}}]}|Code];
+	false ->
+		[{l_call_ext,[{e,{M,F,N}}]}|Code]
+	end;
+tr([{call_ext_last,[{a,M},{a,F},N,D]}|Code]) ->
+	case ling_bifs:is_builtin(M, F, N) of
+	true ->
+		[{call_bif,[{b,{M,F,N}}]},{deallocate_return,[D]}|Code];
+	false ->
+		[{l_call_ext_last,[{e,{M,F,N}},D]}|Code]
+	end;
+tr([{call_ext_only,[{a,M},{a,F},N]}|Code]) ->
+	case ling_bifs:is_builtin(M, F, N) of
+	true ->
+		[{allocate,[0,N]},{call_bif,[{b,{M,F,N}}]},{deallocate_return,[0]}|Code];
+	false ->
+		[{l_call_ext_only,[{e,{M,F,N}}]}|Code]
+	end;
+
+tr([{trim,[N,_R]}|Code]) -> [{l_trim,[N]}|Code];	%% 1
+
+%% Maps
+%%tr([{put_map_assoc,[{f,0},{literal,#{}},D,_Live,L]}|Code]) ->
+%%	[{new_map,[D,L]}|Code];
+tr([{put_map_assoc,[{f,0},{x,_}=S,D,_Live,L]}|Code]) ->
+	[{update_map_assoc,[S,D,L]}|Code];
+tr([{put_map_assoc,[{f,0},{y,_}=S,D,_Live,L]}|Code]) ->
+	[{update_map_assoc,[S,D,L]}|Code];
+tr([{put_map_assoc,[{f,0},S,D,_Live,L]}|Code]) ->
+	[{move,[S,?TMP_X]},{update_map_assoc,[?TMP_X,D,L]}|Code];
+
+%%tr([{put_map_exact,[{f,0},{literal,#{}},D,_Live,L]}|Code]) ->
+%%	[{new_map,[D,L]}|Code];
+tr([{put_map_exact,[F,{x,_}=S,D,_Live,L]}|Code]) ->
+	[{update_map_exact,[F,S,D,L]}|Code];
+tr([{put_map_exact,[F,{y,_}=S,D,_Live,L]}|Code]) ->
+	[{update_map_exact,[F,S,D,L]}|Code];
+tr([{put_map_exact,[F,S,D,_Live,L]}|Code]) ->
+	[{move,[S,?TMP_X]},{update_map_exact,[F,?TMP_X,D,L]}|Code];
+
+tr([{get_map_elements,[F,S,{list,[K,D]}]}|Code]) ->
+	[{get_map_element,[F,S,K,D]}|Code];
+
+tr([{has_map_fields,[F,S,{list,[K]}]}|Code]) ->
+	[{has_map_field,[F,S,K]}|Code];
+
+tr(_) -> intact.
+
+pairup([]) -> [];
+pairup([V,L|VLs]) ->
+	[{V,L}|pairup(VLs)].
+
+%%
+%%	TODO
+%%
+%%	This may be enhanced by continuing replacing get_tuple_element
+%%	with extract_next_elementN as the pointer in tmp_arg1 is still
+%%	valid after extract_next_elementN. The source should be the same.
+%%
+%%	Example:
+%% 		{is_tuple_of_arity,[{f,9},{x,0},3],[]}
+%%		{extract_next_element,[{y,0}],[]}
+%%		{get_tuple_element,[{x,0},1,{x,2}],[]}	-> convert
+%%		{get_tuple_element,[{x,0},2,{x,1}],[]}	-> convert
+%%
+
+extract_elements(Test, S, D, GetsCode) ->
+	case extract_elements_1(S, D, GetsCode) of
+	{1,Code} ->
+		[Test,{extract_next_element,[D]}|Code];
+	{2,Code} ->
+		[Test,{extract_next_element2,[D]}|Code];
+	{3,Code} ->
+		[Test,{extract_next_element3,[D]}|Code]
+	end.
+
+extract_elements_1(S, {XY,D}, GetsCode) ->
+	extract_elements_1(S, {XY,D+1}, GetsCode, 1).
+
+extract_elements_1(S, {XY,D}, [{get_tuple_element,[S,P,{XY,D}]}|Code], P)
+	when P < 3 ->
+		extract_elements_1(S, {XY,D+1}, Code, P+1);
+extract_elements_1(_, _, Code, P) ->
+	{P,Code}.
+
+comp32(I) when I >= 0, I < (1 bsl 31) ->
+	I;
+comp32(I) when I < 0, I >= -(1 bsl 31) ->
+	(1 bsl 32) + I.
+
+-record(lts, {labels,atoms,literals,catches,imports}).
+
+ling_to_specs(Ling) -> %% {ok,#m{}}
+	{Labels,Lines} = label_line_offsets(Ling),
+
+	{NewLineInfo,FileNameAtoms} = case Ling#m.line_info of
+	undefined ->
+		{undefined,[]};
+	{_,_,LineItems,FileNames} ->
+		As = [list_to_atom(FN) || FN <- FileNames],
+
+		LIs = lists:map(fun({Off,0}) ->
+		{Off,undefined};
+			({Off,N}) ->
+		{F,L} = lists:nth(N, LineItems),
+			{Off,{F,L}}
+		end, Lines),
+
+		{{LIs,As},As}
+	end,
+
+	SpecsNoInd = lists:map(fun({Op,Args,Trail}) ->
+		No = ling_iopvars:fit_args(Op, Args),
+		Types = ling_iopvars:var_args(Op, No),
+
+		[{opcode,ling_iopvars:var_index(Op, No)}]
+				 ++ spec(Args, Types)
+				 ++ spec_trail(Trail)
+
+	end, [Trio || {Op,_,_}=Trio <- Ling#m.code, Op =/= label, Op =/= line]),
+
+	AllArgs = lists:concat(SpecsNoInd),
+
+	%% NB: the standart usort is using == and thus
+	%% coalesces floating-point literals with integers
+	%%
+	EqualsExact = fun(A, B) -> A =:= B end,
+
+	Literals = lists:usort(EqualsExact,
+						   [Q || {literal,Q} <- AllArgs]
+									++
+						   [F || {float,F} <- AllArgs]
+									++
+						   [I || {bigint,I} <- AllArgs]),
+	Catches = lists:usort([L || {'catch',L} <- AllArgs]),
+	Imports = lists:usort([MFA || {b,MFA} <- AllArgs])
+									++
+			  lists:usort([MFA || {e,{_,_,_}=MFA} <- AllArgs]),
+
+	Atoms = lists:usort([A || {a,A} <- AllArgs]
+				++ lists:concat([[M,F] || {M,F,_} <- Imports])
+				++ FileNameAtoms),
+
+	AtomsDict = index_dict(Atoms),
+	LiteralsDict = index_dict(Literals),
+	CatchesDict = index_dict(Catches),
+	ImportsDict = index_dict(Imports),
+
+	Lts = #lts{labels=Labels,
+			   atoms=AtomsDict,
+			   literals=LiteralsDict,
+			   catches=CatchesDict,
+			   imports=ImportsDict},
+	
+	Specs = [indexify(S, Lts) || S <- SpecsNoInd],
+
+	Funs = [{Name,Arity,dict:fetch(F, Labels),Index,NumFree,Uniq}
+				|| {Name,Arity,F,Index,NumFree,Uniq} <- Ling#m.lambdas],
+	Exps = [{Function,Arity,dict:fetch(F, Labels)}
+				|| {Function,Arity,F} <- Ling#m.exports],
+	Cats = [dict:fetch(L, Labels)
+				|| L <- Catches],
+
+	{ok,Ling#m{code=Specs,
+			   lambdas=Funs,
+			   exports=Exps,
+			   catches=Cats,
+		  	   atoms=Atoms,
+		   	   imports=Imports,
+		       literals=Literals,
+		   	   line_info=NewLineInfo}}.
+
+label_line_offsets(Ling) -> %% {LabDict,LineDict,CodeSize}
+	{Labels,Lines,_} = lists:foldl(fun({line,[N],_}, {Labels,Lines,Off}) ->
+		{Labels,[{Off,N}|Lines],Off};
+	
+	({label,[L],_}, {Labels,Lines,Off}) -> 
+		{dict:store(L, Off, Labels),Lines,Off};
+
+	({Op,Args,Trail}, {Labels,Lines,Off}) ->
+		No = ling_iopvars:fit_args(Op, Args),
+		Types = ling_iopvars:var_args(Op, No),
+		{Labels,Lines,Off +1 + ling_iops:wsize(Types) + length(Trail)}	%% +1 for opcode
+	end, {dict:new(),[],0}, Ling#m.code),
+
+	{Labels,lists:reverse(Lines)}.
+
+index_dict(Ls) ->
+	{D,_} = lists:foldl(fun(L, {D,N}) ->
+		{dict:store(L, N, D),N+1}
+	end, {dict:new(),0}, Ls),
+	D.
+
+indexify(As, Lts) ->
+	lists:map(fun({f,0}) ->
+		{f,none};
+	({f,F}) ->
+		{f,dict:fetch(F, Lts#lts.labels)};
+	({a,A}) ->
+		{atom,dict:fetch(A, Lts#lts.atoms)};
+	({literal,Q}) ->
+		{literal,dict:fetch(Q, Lts#lts.literals)};
+	({e,0}) ->
+		{export,none};
+	({e,MFA}) ->
+		{export,dict:fetch(MFA, Lts#lts.imports)};
+	({b,MFA}) ->
+		{bif,dict:fetch(MFA, Lts#lts.imports)};
+	({'catch',L}) ->
+		{'catch',dict:fetch(L, Lts#lts.catches)};
+	(X) ->
+		X
+	end, As).
+
+spec(As, Ps) ->
+	spec(As, Ps, [], []).
+
+spec([], [], WWs, BWs) ->
+	lists:reverse(WWs) ++ [bytes(Bs) || Bs <- lists:reverse(BWs)];
+spec([Val|As], [Val|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, BWs);
+spec([N|As], [{u,N}|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, BWs);
+spec([N|As], [{u8,N}|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, BWs);
+spec([{smallint,I}|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [{tag_int,I}|WWs], BWs);
+spec([{bigint,I}|As], [t|Ps], WWs, BWs) -> %% bigints are now just literals
+	spec(As, Ps, [{literal,I}|WWs], BWs);
+spec([{float,F}|As], [t|Ps], WWs, BWs) -> %% floats are now just literals
+	spec(As, Ps, [{literal,F}|WWs], BWs);
+spec([U|As], [u8|Ps], WWs, BWs) when is_integer(U), U >= 0, U =< 255 ->
+	spec(As, Ps, WWs, add_byte(BWs, U));
+spec([U|As], [u32|Ps], WWs, BWs) when is_integer(U), U >= 0 ->
+	spec(As, Ps, [U|WWs], BWs);
+spec([{x,X}|As], [x8|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, add_byte(BWs, X));
+spec([{x,X}|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [{reg_as_term,X}|WWs], BWs);
+spec([{fr,R}|As], [fr|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, add_byte(BWs, R));
+spec([{y,Y}|As], [y8|Ps], WWs, BWs) ->
+	spec(As, Ps, WWs, add_byte(BWs, Y));
+spec([{y,Y}|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [{slot_as_term,Y}|WWs], BWs);
+spec([nil|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [nil|WWs], BWs);
+spec([{f,none}=F|As], [f|Ps], WWs, BWs) ->
+	spec(As, Ps, [F|WWs], BWs);
+spec([{f,Off}|As], [f|Ps], WWs, BWs) ->
+	spec(As, Ps, [{f,Off}|WWs], BWs);
+spec([{e,_}=Exp|As], [e|Ps], WWs, BWs) ->
+	spec(As, Ps, [Exp|WWs], BWs);
+spec([{b,_}=Bif|As], [b|Ps], WWs, BWs) ->
+	spec(As, Ps, [Bif|WWs], BWs);
+spec([{fu,_}=Fu|As], [fu|Ps], WWs, BWs) ->
+	spec(As, Ps, [Fu|WWs], BWs);
+spec([{str,_}=Str|As], [str|Ps], WWs, BWs) ->
+	spec(As, Ps, [Str|WWs], BWs);
+spec([{'catch',_}=Cc|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [Cc|WWs], BWs);
+spec([{literal,_}=Lit|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [Lit|WWs], BWs);
+spec([{a,_}=Atom|As], [t|Ps], WWs, BWs) ->
+	spec(As, Ps, [Atom|WWs], BWs).
+
+spec_trail(As) ->
+	lists:map(fun({a,_}=A) -> A;
+				 ({smallint,I}) -> {tag_int,I};
+				 ({bigint,I}) -> {literal,I};
+				 ({float,F}) -> {literal,F};
+				 ({f,_Off}=F) -> F;
+				 ({x,X}) -> {reg_as_term,X};
+				 ({y,Y}) -> {slot_as_term,Y};
+				 ({literal,_}=Lit) -> Lit;
+				 (nil) -> nil;
+				 (U) when is_integer(U), U >= 0 -> U
+	end, As).
+
+bytes([B]) -> B;
+bytes([B1,B2]) -> (B1 bsl 8) bor B2;
+bytes([B1,B2,B3]) -> (B1 bsl 16) bor (B2 bsl 8) bor B3;
+bytes([B1,B2,B3,B4]) -> (B1 bsl 24) bor (B2 bsl 16) bor (B3 bsl 8) bor B4.
+
+add_byte([], Name) ->
+	[[Name]];
+add_byte([[_,_,_,_]|_]=Words, Name) ->
+	[[Name]|Words];
+add_byte([Bs|Words], Name) ->
+	[[Name|Bs]|Words].
+

src/ling/ling_disasm.erl

@@ -0,0 +1,492 @@
+%% Copyright (c) 2013-2014 Cloudozer LLP. All rights reserved.
+%% 
+%% Redistribution and use in source and binary forms, with or without
+%% modification, are permitted provided that the following conditions are met:
+%% 
+%% * Redistributions of source code must retain the above copyright notice, this
+%% list of conditions and the following disclaimer.
+%% 
+%% * Redistributions in binary form must reproduce the above copyright notice,
+%% this list of conditions and the following disclaimer in the documentation
+%% and/or other materials provided with the distribution.
+%% 
+%% * Redistributions in any form must be accompanied by information on how to
+%% obtain complete source code for the LING software and any accompanying
+%% software that uses the LING software. The source code must either be included
+%% in the distribution or be available for no more than the cost of distribution
+%% plus a nominal fee, and must be freely redistributable under reasonable
+%% conditions.  For an executable file, complete source code means the source
+%% code for all modules it contains. It does not include source code for modules
+%% or files that typically accompany the major components of the operating
+%% system on which the executable file runs.
+%% 
+%% THIS SOFTWARE IS PROVIDED BY CLOUDOZER LLP ``AS IS'' AND ANY EXPRESS OR
+%% IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE
+%% DISCLAIMED. IN NO EVENT SHALL CLOUDOZER LLP BE LIABLE FOR ANY DIRECT,
+%% INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+%% (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%% LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+%% ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+%% (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-module(ling_disasm).
+-export([beam/1]).
+
+-include("ling_code.hrl").
+
+-define(tag_u, 0).
+-define(tag_i, 1).
+-define(tag_a, 2).
+-define(tag_x, 3).
+-define(tag_y, 4).
+-define(tag_f, 5).
+-define(tag_h, 6).
+-define(tag_z, 7).
+
+-define(CODE_CHUNK, "Code").
+-define(STR_CHUNK, "StrT").
+-define(LIT_CHUNK, "LitT").
+-define(FUN_CHUNK, "FunT").
+-define(ATTR_CHUNK, "Attr").
+-define(CINF_CHUNK, "CInf").
+-define(LINE_CHUNK, "Line").
+-define(ABST_CHUNK, "Abst").
+
+-record(da, {atoms,literals,lambdas,imports,exports}).
+
+beam(Beam) -> %% {ok,#m{}}
+
+	ChunkNames = [?CODE_CHUNK,
+		atoms,indexed_imports,labeled_exports,?STR_CHUNK,abstract_code],
+
+	{ok,{Module,[{?CODE_CHUNK,HdrCodeBin},
+				 {atoms,Atoms},
+				 {indexed_imports,Imports},
+				 {labeled_exports,Exports},
+				 {?STR_CHUNK,StrTabBin},
+				 {abstract_code,_AbstCode}]}} = 
+
+			 beam_lib:chunks(Beam, ChunkNames),
+
+	%% AbstCode = no_abstract_code | {raw_abstract_v1,Forms}
+	
+	%%TODO: make this an option
+	AbstCode = no_abstract_code,
+
+	Literals = case optional_chunk(Beam, ?LIT_CHUNK) of
+	missing ->
+		[];
+	LitBin ->
+		decode_literals(LitBin)
+	end,
+
+	Lambdas = case optional_chunk(Beam, ?FUN_CHUNK) of
+	missing ->
+		[];
+	FunBin ->
+		decode_lambdas(FunBin, Atoms)
+	end,
+
+	%%io:format("Lambdas=~p~n", [Lambdas]),
+
+	Attrs = case optional_chunk(Beam, ?ATTR_CHUNK) of
+	missing ->
+		undefined;
+	AttrBin ->
+		binary_to_term(AttrBin)
+	end,
+
+	CInfs = case optional_chunk(Beam, ?CINF_CHUNK) of
+	missing ->
+		undefined;
+	CInfBin ->
+		binary_to_term(CInfBin)
+	end,
+
+	<<16:32,				%% header size
+	  0:32,					%% BEAM format number
+	  _MaxOpCode:32,
+	  _NumLabels:32,
+	  _NumFunctions:32,CodeBin/binary>> = HdrCodeBin,
+	
+	St = #da{atoms=Atoms,
+			 literals=Literals,
+			 lambdas=Lambdas,
+			 imports=Imports,
+			 exports=Exports},
+	
+	Code = disasm_code(CodeBin, St),
+
+	LineInfo = case optional_chunk(Beam, ?LINE_CHUNK) of
+	missing ->
+		undefined;
+	LineBin ->
+		decode_line_info(LineBin)
+	end,
+
+	lists:foreach(fun(Op) ->
+		%%io:format("~p~n", [Op]),
+		validate(Op)
+	end, Code),
+
+	{ok,#m{mod_name=Module,
+		   code =Code,
+		   exports =Exports,
+		   lambdas =Lambdas,
+	   	   strings =StrTabBin,
+	   	   attrs =Attrs,
+	       compile_info =CInfs,
+	   	   line_info =LineInfo,
+		   abst_code =AbstCode}}.
+
+optional_chunk(Beam, ChunkName) ->
+	case beam_lib:chunks(Beam, [ChunkName]) of
+	{error,beam_lib,{missing_chunk,_,_}} ->
+		missing;
+	{ok,{_,[{_,Chunk}]}} ->
+		Chunk
+	end.
+
+decode_literals(<<_:32,Compressed/binary>>) ->
+	<<_:32,Tab/binary>> = case catch zlib:uncompress(Compressed) of
+	{'EXIT',_} -> %% BEAM uses noop zlib
+		Compressed;
+	X ->
+		X
+	end,
+	decode_literals_1(Tab, 0).
+
+decode_literals_1(<<Sz:32,Ext:Sz/binary,Rest/binary>>, Index) ->
+	[{Index,binary_to_term(Ext)}|decode_literals_1(Rest, Index+1)];
+decode_literals_1(<<>>, _) -> [].
+
+decode_lambdas(<<_:32,Tab/binary>>, Atoms) ->
+	decode_lambdas_1(Tab, Atoms, 0). %% NB: sorting order is not by Index
+
+decode_lambdas_1(<<F:32,A:32,Lab:32,Index:32,NFree:32,OldUniq:32,More/binary>>,
+		Atoms, OldIndex) ->
+	Info = {lookup(F, Atoms),A,Lab,Index,NFree,OldUniq},
+	[Info|decode_lambdas_1(More, Atoms, OldIndex+1)];
+decode_lambdas_1(<<>>, _, _) -> [].
+
+disasm_code(Code, St) ->
+	disasm_code(Code, St, []).
+
+disasm_code(<<>>, _St, Acc) ->
+	lists:reverse(Acc);
+disasm_code(<<OpCode,Code/binary>>, St, Acc) ->
+	{OpName,Arity} = beam_opcodes:opname(OpCode),
+	{Args,More} =  decode_args(Code, Arity, [], St),
+	disasm_code(More, St, [decorate(OpName, Args, St)|Acc]).
+
+decode_line_info(<<0:32,	%% Version
+				   Flags:32,
+				   NI:32,
+				   NT:32,
+				   NF:32,LBin/binary>>) ->
+	decode_line_info(LBin, {Flags,NI,NT,NF}, 1, nofile, []).
+
+decode_line_info(LBin, {_,_,NT,_}=D, T, CF, Acc) when T =< NT ->
+	case decode_arg(LBin, nostate) of
+	{{a,FileIndex},More} ->
+		decode_line_info(More, D, T, FileIndex, Acc);
+	{{i,Line},More} ->
+		decode_line_info(More, D, T+1, CF, [{CF,Line}|Acc])
+	end;
+decode_line_info(LBin, D, _, _, Acc) ->
+	Items = lists:reverse(Acc),
+	decode_line_info2(LBin, D, Items, 1, []).
+
+decode_line_info2(<<Sz:16,Name:Sz/binary,LBin/binary>>,
+							{_,_,_,NF}=D, Items, F, Acc) when F =< NF ->
+	NameStr = binary_to_list(Name),
+	decode_line_info2(LBin, D, Items, F+1, [NameStr|Acc]);
+decode_line_info2(_, {Flags,NI,_,_}, Items, _, Acc) ->
+	Files = lists:reverse(Acc),
+	{Flags,NI,Items,Files}.
+
+decode_args(Code, 0, Acc, _St) ->
+	{lists:reverse(Acc),Code};
+decode_args(Code, N, Acc, St) ->
+	{Arg,MoreCode} = decode_arg(Code, St),
+	decode_args(MoreCode, N-1, [Arg|Acc], St).
+
+decode_arg(<<0:4,0:1,?tag_z:3,Float:64/float,Code/binary>>, _St) ->
+	{{float,Float},Code};
+decode_arg(<<1:4,0:1,?tag_z:3,Code/binary>>, St) ->
+	{Len,MoreCode} = decode_arg(Code, St),
+	{List,EvenMore} = decode_list(MoreCode, Len, St),
+	{{list,List},EvenMore};
+decode_arg(<<2:4,0:1,?tag_z:3,Code/binary>>, St) ->
+	{R,MoreCode} = decode_arg(Code, St),
+	{{fr,R},MoreCode};
+decode_arg(<<3:4,0:1,?tag_z:3,LenCode/binary>>, St) ->
+	{Len = 2,Code} = decode_arg(LenCode, St),
+	case decode_list(Code, 2*Len, St) of
+	{[0,Words,1,Floats],MoreCode} ->
+		{{alloc,[{words,Words},{floats,Floats}]},MoreCode};
+	{[1,Floats,0,Words],MoreCode} ->
+		{{alloc,[{words,Words},{floats,Floats}]},MoreCode}
+	end;
+decode_arg(<<4:4,0:1,?tag_z:3,Code/binary>>, St) ->
+	{Index,MoreCode} = decode_arg(Code, St),
+	{{literal,lookup(Index, St#da.literals)},MoreCode};
+
+decode_arg(<<V:4,0:1,Tag:3,Code/binary>>, St) ->
+	{decode_tag(Tag, V, St),Code};
+decode_arg(<<V1:3,1:2,Tag:3,V2,Code/binary>>, St) ->
+	{decode_tag(Tag, (V1 bsl 8) bor V2, St),Code};
+decode_arg(<<31:5,Tag:3,Code/binary>>, St) ->
+	{S,BytesCode} = decode_arg(Code, St),
+	Size = S+9,
+	<<Bytes:Size/binary,MoreCode/binary>> = BytesCode,
+	{decode_tag(Tag, bytes_to_value(Bytes), St),MoreCode};
+decode_arg(<<S:3,3:2,Tag:3,Code/binary>>, St) ->
+	Size = S+2,
+	<<Bytes:Size/binary,MoreCode/binary>> = Code,
+	{decode_tag(Tag, bytes_to_value(Bytes), St),MoreCode}.
+
+decode_tag(?tag_x, X, _St) -> {x,X};
+decode_tag(?tag_y, Y, _St) -> {y,Y};
+decode_tag(?tag_a, Index, nostate) -> {a,Index};
+decode_tag(?tag_a, 0, _St) -> nil;
+decode_tag(?tag_a, Index, St) -> {a,lookup(Index, St#da.atoms)};
+decode_tag(?tag_i, I, _St) -> {i,I};
+decode_tag(?tag_f, L, _St) -> {f,L};
+decode_tag(?tag_u, N, _St) -> N.
+
+bytes_to_value(<<Digit,_/binary>> = Bytes) when Digit > 127 ->
+	negative_bytes_to_value(Bytes, 0, 1);
+bytes_to_value(Bytes) ->
+	bytes_to_value(Bytes, 0).
+
+bytes_to_value(<<>>, Acc) ->
+	Acc;
+bytes_to_value(<<N,Bytes/binary>>, Acc) ->
+	bytes_to_value(Bytes, (Acc bsl 8) bor N).
+
+negative_bytes_to_value(<<>>, Acc, Z) ->
+	Acc - Z;
+negative_bytes_to_value(<<N,Bytes/binary>>, Acc, Z) ->
+	negative_bytes_to_value(Bytes, (Acc bsl 8) bor N, (Z bsl 8)).
+
+decode_list(Code, N, St) ->
+	decode_list(Code, N, St, []).
+
+decode_list(Code, 0, _St, Acc) ->
+	{lists:reverse(Acc),Code};
+decode_list(Code, N, St, Acc) ->
+	{Arg,MoreCode} = decode_arg(Code, St),
+	decode_list(MoreCode, N-1, St, [Arg|Acc]).
+
+lookup(Key, List) ->
+	{_, Val} = lists:keyfind(Key, 1, List),
+	Val.
+
+lookup_import(E, St) ->
+	{_,M,F,A} = lists:keyfind(E+1, 1, St#da.imports),
+	[{a,M},{a,F},A].
+
+decorate(call_ext=Op, [_A,E], St) ->
+	{Op,lookup_import(E, St)};
+decorate(call_ext_last=Op, [_A,E,D], St) ->
+	{Op,lookup_import(E, St) ++ [D]};
+decorate(call_ext_only=Op, [_A,E], St) ->
+	{Op,lookup_import(E, St)};
+
+decorate(bif0=Op, [E,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[M,F,A,D]};
+decorate(bif1=Op, [Fail,E,S,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[Fail,M,F,A,S,D]};
+decorate(bif2=Op, [Fail,E,S1,S2,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[Fail,M,F,A,S1,S2,D]};
+
+decorate(gc_bif1=Op, [Fail,Live,E,S,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[Fail,Live,M,F,A,S,D]};
+decorate(gc_bif2=Op, [Fail,Live,E,S1,S2,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[Fail,Live,M,F,A,S1,S2,D]};
+decorate(gc_bif3=Op, [Fail,Live,E,S1,S2,S3,D], St) ->
+	[M,F,A] = lookup_import(E, St),
+	{Op,[Fail,Live,M,F,A,S1,S2,S3,D]};
+
+%decorate(make_fun2=Op, [OldIndex], St) ->
+%	{_,_,_,_,NumFree,_} = lookup(OldIndex, St#da.lambdas),
+%	{Op,[OldIndex,NumFree]};
+
+decorate(is_function2=Op,[{f,_}=F,{x,_}=X,{i,N}], _St) ->
+	{Op,[F,X,N]};
+decorate(is_function2=Op,[{f,_}=F,{y,_}=Y,{i,N}], _St) ->
+	{Op,[F,Y,N]};
+
+decorate(OpName, [], _St) ->
+	OpName;
+decorate(OpName, Args, _St) ->
+	{OpName,Args}.
+
+-define(U(X), (is_integer(X) andalso X >= 0)).
+
+validate({allocate,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({allocate_heap,[U1,{alloc,_},U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({allocate_heap,[U1,U2,U3]}) when ?U(U1), ?U(U2), ?U(U3) -> ok;
+validate({allocate_heap_zero,[U1,{alloc,_},U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({allocate_heap_zero,[U1,U2,U3]}) when ?U(U1), ?U(U2), ?U(U3) -> ok;
+validate({allocate_zero,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({apply,[U]}) when ?U(U) -> ok;
+validate({apply_last,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({badmatch,[S]}) -> src(S);
+validate({bif0,[{a,_},{a,_},U,D]}) when ?U(U) -> dst(D);
+validate({bif1,[{f,_},{a,_},{a,_},U,S,D]}) when ?U(U) -> src(S), dst(D);
+validate({bif2,[{f,_},{a,_},{a,_},U,S1,S2,D]}) when ?U(U) -> src(S1), src(S2), dst(D);
+validate({bs_add,[{f,_},S1,S2,U,{x,_}]}) when ?U(U) -> src(S1), src(S2);
+validate({bs_append,[{f,_},S,U1,U2,U3,_D,U4,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3), ?U(U4) -> src(S); %%, dst(D);
+validate({bs_context_to_binary,[D]}) -> dst(D);
+validate({bs_get_binary2,[{f,_},{x,_},U1,S,U2,U3,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3) -> src(S);
+validate({bs_get_float2,[{f,_},{x,_},U1,S,U2,U3,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3) -> src(S);
+validate({bs_get_integer2,[{f,_},{x,_},U1,S,U2,U3,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3) -> src(S);
+validate({bs_get_utf16,[{f,_},{x,_},U1,U2,{x,_}]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_get_utf32,[{f,_},{x,_},U1,U2,{x,_}]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_get_utf8,[{f,_},{x,_},U1,U2,{x,_}]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_init2,[{f,_},U1,U2,U3,U4,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3), ?U(U4) -> ok;
+validate({bs_init2,[{f,_},{x,_},U1,U2,U3,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3) -> ok;
+validate({bs_init_bits,[{f,_},U1,U2,U3,U4,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3), ?U(U4) -> ok;
+validate({bs_init_bits,[{f,_},{x,_},U1,U2,U3,{x,_}]}) when ?U(U1), ?U(U2), ?U(U3) -> ok;
+validate(bs_init_writable) -> ok;
+validate({bs_match_string,[{f,_},{x,_},U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_private_append,[{f,_},S,U1,D,U2,{x,_}]}) when ?U(U1), ?U(U2) -> src(S), dst(D);
+validate({bs_put_binary,[{f,_},S1,U1,U2,S2]}) when ?U(U1), ?U(U2) -> src(S1), src(S2);
+validate({bs_put_float,[{f,_},S1,U1,U2,S2]}) when ?U(U1), ?U(U2) -> src(S1), src(S2);
+validate({bs_put_integer,[{f,_},S1,U1,U2,S2]}) when ?U(U1), ?U(U2) -> src(S1), src(S2);
+validate({bs_put_string,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_put_utf16,[{f,_},U,D]}) when ?U(U) -> dst(D);
+validate({bs_put_utf32,[{f,_},U,D]}) when ?U(U) -> dst(D);
+validate({bs_put_utf8,[{f,_},U,D]}) when ?U(U) -> dst(D);
+validate({bs_restore2,[{x,_},{a,_}]}) -> ok;
+validate({bs_restore2,[{x,_},U]}) when ?U(U) -> ok;
+validate({bs_save2,[{x,_},{a,_}]}) -> ok;
+validate({bs_save2,[{x,_},U]}) when ?U(U) -> ok;
+validate({bs_skip_bits2,[{f,_},{x,_},S,U1,U2]}) when ?U(U1), ?U(U2) -> src(S);
+validate({bs_skip_utf16,[{f,_},{x,_},U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_skip_utf32,[{f,_},{x,_},U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_skip_utf8,[{f,_},{x,_},U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({bs_start_match2,[{f,_},D,U1,U2,{x,_}]}) when ?U(U1), ?U(U2) -> dst(D);
+validate({bs_test_tail2,[{f,_},{x,_},U]}) when ?U(U) -> ok;
+validate({bs_test_unit,[{f,_},{x,_},U]}) when ?U(U) -> ok;
+validate({bs_utf16_size,[{f,_},S,{x,_}]}) -> src(S);
+validate({bs_utf8_size,[{f,_},S,{x,_}]}) -> src(S);
+validate({call,[U,{f,_}]}) when ?U(U) -> ok;
+validate({call_ext,[{a,_},{a,_},U]}) when ?U(U) -> ok;
+validate({call_ext_last,[{a,_},{a,_},U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({call_ext_only,[{a,_},{a,_},U]}) when ?U(U) -> ok;
+validate({call_fun,[U]}) when ?U(U) -> ok;
+validate({call_last,[U1,{f,_},U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({call_only,[U,{f,_}]}) when ?U(U) -> ok;
+validate({case_end,[D]}) -> dst(D);
+validate({'catch',[{y,_},{f,_}]}) -> ok;
+validate({catch_end,[{y,_}]}) -> ok;
+validate({deallocate,[U]}) when ?U(U) -> ok;
+validate({fadd,[{f,_},{fr,_},{fr,_},{fr,_}]}) -> ok;
+validate({fcheckerror,[{f,_}]}) -> ok;
+validate(fclearerror) -> ok;
+validate({fconv,[S,{fr,_}]}) -> src(S);
+validate({fdiv,[{f,_},{fr,_},{fr,_},{fr,_}]}) -> ok;
+validate({fmove,[S,{fr,_}]}) -> src(S);
+validate({fmove,[{fr,_},{fr,_}]}) -> ok;
+validate({fmove,[{fr,_},D]}) -> dst(D);
+validate({fmul,[{f,_},{fr,_},{fr,_},{fr,_}]}) -> ok;
+validate({fnegate,[{f,_},{fr,_},{fr,_}]}) -> ok;
+validate({fsub,[{f,_},{fr,_},{fr,_},{fr,_}]}) -> ok;
+validate({func_info,[{a,_},{a,_},U]}) when ?U(U) -> ok;
+validate({gc_bif1,[{f,_},U1,{a,_},{a,_},U2,S,D]}) when ?U(U1), ?U(U2) -> src(S), dst(D);
+validate({gc_bif2,[{f,_},U1,{a,_},{a,_},U2,S1,S2,D]}) when ?U(U1), ?U(U2) -> src(S1), src(S2), dst(D);
+validate({gc_bif3,[{f,_},U1,{a,_},{a,_},U2,S1,S2,S3,D]}) when ?U(U1), ?U(U2) -> src(S1), src(S2), src(S3), dst(D);
+validate({get_list,[D1,D2,D3]}) -> dst(D1), dst(D2), dst(D3);
+validate({get_tuple_element,[D1,U,D2]}) when ?U(U) -> dst(D1), dst(D2);
+validate(if_end) -> ok;
+validate({init,[{y,_}]}) -> ok;
+validate(int_code_end) -> ok;
+validate({is_atom,[{f,_},D]}) -> dst(D);
+validate({is_binary,[{f,_},D]}) -> dst(D);
+validate({is_bitstr,[{f,_},D]}) -> dst(D);
+validate({is_boolean,[{f,_},D]}) -> dst(D);
+validate({is_eq,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_eq_exact,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_float,[{f,_},D]}) -> dst(D);
+validate({is_function,[{f,_},D]}) -> dst(D);
+validate({is_function2,[{f,_},D,U]}) when ?U(U) -> dst(D);
+validate({is_function2,[{f,_},D1,D2]}) -> dst(D1), dst(D2);
+validate({is_ge,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_integer,[{f,_},D]}) -> dst(D);
+validate({is_list,[{f,_},D]}) -> dst(D);
+validate({is_lt,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_ne,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_ne_exact,[{f,_},S1,S2]}) -> src(S1), src(S2);
+validate({is_nil,[{f,_},D]}) -> dst(D);
+validate({is_nonempty_list,[{f,_},D]}) -> dst(D);
+validate({is_number,[{f,_},D]}) -> dst(D);
+validate({is_pid,[{f,_},D]}) -> dst(D);
+validate({is_port,[{f,_},D]}) -> dst(D);
+validate({is_reference,[{f,_},D]}) -> dst(D);
+validate({is_tuple,[{f,_},D]}) -> dst(D);
+validate({jump,[{f,_}]}) -> ok;
+validate({label,[U]}) when ?U(U) -> ok;
+validate({loop_rec,[{f,_},{x,_}]}) -> ok;
+validate({loop_rec_end,[{f,_}]}) -> ok;
+validate({make_fun2,[U]}) when ?U(U) -> ok;
+validate({move,[S,D]}) -> src(S), dst(D);
+validate(on_load) -> ok;
+validate({put,[S]}) -> src(S);
+validate({put_list,[S1,S2,D]}) -> src(S1), src(S2), dst(D);
+validate({put_tuple,[U,D]}) when ?U(U) -> dst(D);
+validate({raise,[D1,D2]}) -> dst(D1), dst(D2);
+validate({recv_mark,[{f,_}]}) -> ok;
+validate({recv_set,[{f,_}]}) -> ok;
+validate(remove_message) -> ok;
+validate(return) -> ok;
+validate({select_tuple_arity,[D,{f,_},{list,_}]}) -> dst(D);
+validate({select_val,[D,{f,_},{list,_}]}) -> dst(D);
+validate(send) -> ok;
+validate({set_tuple_element,[S,{x,_},U]}) when ?U(U) -> src(S);
+validate({test_arity,[{f,_},D,U]}) when ?U(U) -> dst(D);
+validate({test_heap,[{alloc,_},U]}) when ?U(U) -> ok;
+validate({test_heap,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate(timeout) -> ok;
+validate({trim,[U1,U2]}) when ?U(U1), ?U(U2) -> ok;
+validate({'try',[{y,_},{f,_}]}) -> ok;
+validate({try_case,[{y,_}]}) -> ok;
+validate({try_case_end,[{x,_}]}) -> ok;
+validate({try_end,[{y,_}]}) -> ok;
+validate({wait,[{f,_}]}) -> ok;
+validate({wait_timeout,[{f,_},S]}) -> src(S);
+
+validate({is_map,[{f,_},S]}) -> src(S);
+validate({put_map_assoc,[{f,_},S,D,_Live,{list,_}]}) -> src(S), dst(D);
+validate({put_map_exact,[{f,_},S,D,_Live,{list,_}]}) -> src(S), dst(D);
+validate({get_map_elements,[{f,_},S,{list,_}]}) -> src(S);
+validate({has_map_fields,[{f,_},S,{list,_}]}) -> src(S);
+
+validate({line,_}) -> ok;
+
+validate(X) -> erlang:error(X).
+
+%% a/float/i/literal/nil/x/y
+src({a,_}) -> ok;
+src({float,_}) -> ok;
+src({i,_}) -> ok;
+src({literal,_}) -> ok;
+src(nil) -> ok;
+src({x,_}) -> ok;
+src({y,_}) -> ok;
+src(X) -> erlang:error(X).
+
+dst({x,_}) -> ok;
+dst({y,_}) -> ok;
+dst(X) -> erlang:error(X).
+
+%%EOF

src/ling/ling_iops.erl

@@ -0,0 +1,131 @@
+%% Copyright (c) 2013-2014 Cloudozer LLP. All rights reserved.
+%% 
+%% Redistribution and use in source and binary forms, with or without
+%% modification, are permitted provided that the following conditions are met:
+%% 
+%% * Redistributions of source code must retain the above copyright notice, this
+%% list of conditions and the following disclaimer.
+%% 
+%% * Redistributions in binary form must reproduce the above copyright notice,
+%% this list of conditions and the following disclaimer in the documentation
+%% and/or other materials provided with the distribution.
+%% 
+%% * Redistributions in any form must be accompanied by information on how to
+%% obtain complete source code for the LING software and any accompanying
+%% software that uses the LING software. The source code must either be included
+%% in the distribution or be available for no more than the cost of distribution
+%% plus a nominal fee, and must be freely redistributable under reasonable
+%% conditions.  For an executable file, complete source code means the source
+%% code for all modules it contains. It does not include source code for modules
+%% or files that typically accompany the major components of the operating
+%% system on which the executable file runs.
+%% 
+%% THIS SOFTWARE IS PROVIDED BY CLOUDOZER LLP ``AS IS'' AND ANY EXPRESS OR
+%% IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE
+%% DISCLAIMED. IN NO EVENT SHALL CLOUDOZER LLP BE LIABLE FOR ANY DIRECT,
+%% INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+%% (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%% LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+%% ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+%% (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-module(ling_iops).
+-export([packing_options/1,broadest_packing/1]).
+-export([packing_tags/1,wsize/1]).
+
+broadest_packing(Types) ->
+	[broad(T) || T <- Types].
+
+broad(u) -> u32;
+broad(u8) -> u8;
+broad(a) -> t;
+broad(x) -> t;
+broad(y) -> t;
+broad(d) -> t;
+broad(s) -> t;
+broad(f) -> f;
+broad(e) -> e;
+broad(fu) -> fu;
+broad(str) -> str;
+broad(ca) -> t;
+broad(b) -> b;
+broad(fr) -> fr.
+
+packing_options(Args) ->
+	generate(fun arg_rep/1, Args).
+
+generate(_, []) ->
+	[[]];
+generate(F, [A|As]) ->
+	[[G|Gs] || G <- F(A), Gs <- generate(F, As)].
+
+%% NB: the broadest case should be in the end
+arg_rep({u8,N}) when is_integer(N), N >= 0, N =< 255 -> [u8];
+arg_rep(N) when is_integer(N), N >= 0, N =< 255 -> [u8,u32];
+arg_rep(N) when is_integer(N), N >= 0 -> [u32];
+arg_rep({a,_}) -> [t];
+arg_rep({smallint,I}) when I >= -128, I =< 127 -> [i8,t];
+arg_rep({smallint,_I}) -> [t];
+arg_rep({bigint,_I}) -> [t];
+arg_rep(nil) -> [t];
+arg_rep({x,X}) when X =< 255 -> [x8,t];
+arg_rep({x,_X}) -> [t];
+arg_rep({y,Y}) when Y =< 255 -> [y8,t];
+arg_rep({y,_Y}) -> [t];
+arg_rep({f,_}) -> [f];
+arg_rep({float,_}) -> [t];
+arg_rep({fr,_}) -> [fr];
+arg_rep({literal,_}) -> [t];
+arg_rep({e,_}) -> [e];
+arg_rep({bif,_}) -> [b].
+
+bs(u8) -> 8;
+bs(u32) -> 32;
+bs(i8) -> 8;
+bs(x8) -> 8;
+bs(y8) -> 8;
+bs(t) -> 32;
+bs(f) -> 32;
+bs(e) -> 32;
+bs(b) -> 32;
+bs(fr) -> 8;
+bs(fu) -> 32;
+bs(str) -> 32;
+bs(nil) -> 0;
+bs({_,_}) -> 0.
+
+wsize(RRR) ->
+	(lists:sum([bs(A) || A <- RRR]) + 31) div 32.
+
+packing_tags(Ts) ->
+	packing_tags(Ts, 0, 0, 0, []).
+
+packing_tags([], NW, _, _, Acc) ->
+	lists:map(fun({T,{bits,NB,Off}}) ->
+		{T,{bits,NB+NW,Off}};
+   	(X) ->
+	   	X
+	end, lists:reverse(Acc));
+
+packing_tags([{T,V}|Ts], NW, NB, Off, Acc) ->
+	packing_tags(Ts, NW, NB, Off, [{T,{value,V}}|Acc]);
+packing_tags([nil|Ts], NW, NB, Off, Acc) ->
+	packing_tags(Ts, NW, NB, Off, [{t,{value,nil}}|Acc]);
+packing_tags([T|Ts], NW, NB, Off, Acc) ->
+	case bs(T) of
+	8 ->
+		pack8(T, Ts, NW, NB, Off, Acc);
+	32 ->
+		packing_tags(Ts, NW+1, NB, Off, [{T,{word,NW}}|Acc])
+	end.
+
+pack8(T, Ts, NW, NB, 0=Off, Acc) ->
+	packing_tags(Ts, NW, NB+1, 8, [{T,{bits,NB,Off}}|Acc]);
+pack8(T, Ts, NW, NB, 24=Off, Acc) ->
+	packing_tags(Ts, NW, NB, 0, [{T,{bits,NB-1,Off}}|Acc]);
+pack8(T, Ts, NW, NB, Off, Acc) ->
+	packing_tags(Ts, NW, NB, Off+8, [{T,{bits,NB-1,Off}}|Acc]).
+
+%%EOF

src/ling/ling_iopvars.erl

@@ -0,0 +1,5492 @@
+
+-module(ling_iopvars).
+-export([var_order/0]).
+-export([fit_args/2]).
+-export([var_args/2]).
+-export([var_index/2]).
+-export([var_by_index/1]).
+
+var_order() -> [
+		{move,0},
+	{move,1},
+	{l_call,0},
+	{test_heap,0},
+	{move,2},
+	{badmatch,0},
+	{move,3},
+	{l_put_tuple,0},
+	{move,4},
+	{move2,1},
+	{get_tuple_element,0},
+	{move2,0},
+	{put_list,0},
+	{is_tuple_of_arity,1},
+	{get_tuple_element,1},
+	{l_call_only,0},
+	{call_bif,7},
+	{l_bs_start_match2,0},
+	{l_bs_test_zero_tail2,0},
+	{l_bs_match_string,0},
+	{l_is_eq_exact_immed,0},
+	{put_list,1},
+	{is_tuple_of_arity,0},
+	{l_is_eq_exact_immed,1},
+	{get_list,0},
+	{l_put_tuple,1},
+	{move,5},
+	{l_call_ext,85},
+	{l_move_call_ext,0},
+	{return,0},
+	{move2,2},
+	{l_is_ge,0},
+	{l_move_call_last,0},
+	{l_make_fun,0},
+	{is_tuple_of_arity,2},
+	{extract_next_element2,0},
+	{move_deallocate_return,0},
+	{call_bif,3},
+	{l_allocate,0},
+	{l_fetch,0},
+	{l_trim,0},
+	{is_nil,0},
+	{is_nonempty_list,0},
+	{move_return,25},
+	{l_move_call_ext,1},
+	{deallocate_return,0},
+	{case_end,0},
+	{get_list,1},
+	{l_allocate,1},
+	{l_fetch,1},
+	{jump,0},
+	{extract_next_element,0},
+	{put_list,3},
+	{l_is_eq_exact_immed,2},
+	{move2,3},
+	{l_fetch,2},
+	{l_is_eq_exact,0},
+	{call_bif,8},
+	{l_allocate,2},
+	{l_is_eq_exact_immed,3},
+	{get_tuple_element,2},
+	{l_move_call,26},
+	{deallocate_return,1},
+	{move_return,0},
+	{init2,0},
+	{get_tuple_element,3},
+	{put_list,2},
+	{init,0},
+	{move2,4},
+	{l_is_eq_exact_immed,4},
+	{call_bif,9},
+	{l_fetch,3},
+	{deallocate_return,2},
+	{extract_next_element,1},
+	{is_nonempty_list,1},
+	{put_list,4},
+	{l_put_tuple,2},
+	{l_allocate,3},
+	{is_tuple_of_arity,3},
+	{move2,5},
+	{init,1},
+	{get_tuple_element,4},
+	{l_fetch,4},
+	{init3,0},
+	{get_list,2},
+	{l_move_call_ext,38},
+	{allocate_init,0},
+	{l_is_eq_exact_immed,5},
+	{l_trim,1},
+	{test_heap_1_put_list,0},
+	{l_is_lt,0},
+	{l_is_eq_exact_literal,0},
+	{call_bif,6},
+	{call_bif,45},
+	{l_allocate_zero,0},
+	{allocate_heap,0},
+	{is_tuple,0},
+	{move_return,1},
+	{is_nonempty_list,2},
+	{l_allocate_zero,1},
+	{move,6},
+	{l_call_last,0},
+	{init,2},
+	{l_gc_bif1,0},
+	{deallocate_return,3},
+	{get_tuple_element,5},
+	{l_increment,0},
+	{call_bif,2},
+	{is_nonempty_list_allocate,0},
+	{l_select_val_atoms,0},
+	{l_move_call,0},
+	{l_is_eq_exact_immed,6},
+	{call_bif,5},
+	{move_deallocate_return,1},
+	{is_nonempty_list,3},
+	{extract_next_element,2},
+	{is_list,0},
+	{l_select_val2,3},
+	{l_fetch,5},
+	{extract_next_element3,0},
+	{is_nil,1},
+	{move_deallocate_return,2},
+	{l_call_last,1},
+	{l_trim,2},
+	{l_call_last,2},
+	{get_list,3},
+	{l_select_val2,0},
+	{l_move_call_only,12},
+	{is_nil,2},
+	{move2,6},
+	{l_allocate,4},
+	{l_move_call_only,0},
+	{extract_next_element2,1},
+	{move_return,2},
+	{test_arity,0},
+	{move2,7},
+	{l_call_ext,0},
+	{l_new_bs_put_integer_imm,0},
+	{l_select_val2,4},
+	{l_move_call_only,1},
+	{l_select_val2,1},
+	{remove_message,0},
+	{init,3},
+	{l_allocate_zero,2},
+	{l_plus,0},
+	{l_catch,0},
+	{deallocate_return,4},
+	{is_nonempty_list,4},
+	{bif1_body,0},
+	{l_put_tuple,3},
+	{extract_next_element,3},
+	{l_is_eq_exact_immed,7},
+	{move_jump,14},
+	{move,7},
+	{l_allocate_zero,3},
+	{l_move_call_only,2},
+	{l_select_tuple_arity2,0},
+	{l_bs_start_match2,1},
+	{catch_end,0},
+	{move_return,3},
+	{is_nonempty_list,5},
+	{l_is_eq_exact_immed,8},
+	{l_call_last,3},
+	{l_move_call_only,3},
+	{l_call_last,4},
+	{get_list,4},
+	{move_return,4},
+	{move,8},
+	{test_arity,1},
+	{move_return,5},
+	{is_nonempty_list,6},
+	{l_call_fun,0},
+	{l_increment,1},
+	{put_list,5},
+	{init,4},
+	{l_is_eq,0},
+	{l_select_val2,2},
+	{l_move_call_ext,2},
+	{l_call_ext_only,4},
+	{l_bs_get_binary_all_reuse,0},
+	{send,0},
+	{set_tuple_element,0},
+	{bif2_body,0},
+	{extract_next_element2,2},
+	{l_move_call,1},
+	{l_catch,1},
+	{is_nil,3},
+	{move_deallocate_return,3},
+	{call_bif,10},
+	{extract_next_element2,3},
+	{badmatch,1},
+	{is_nonempty_list,7},
+	{l_increment,2},
+	{l_is_eq_exact_immed,9},
+	{case_end,1},
+	{extract_next_element,4},
+	{l_trim,3},
+	{l_move_call_ext_last,0},
+	{is_nonempty_list,8},
+	{l_move_call_last,1},
+	{badmatch,2},
+	{deallocate_return,5},
+	{l_fetch,6},
+	{l_select_val_atoms,1},
+	{l_bs_add,0},
+	{l_allocate,5},
+	{l_select_val_smallints,0},
+	{l_move_call,2},
+	{l_select_tuple_arity2,1},
+	{is_nonempty_list,9},
+	{l_bs_test_zero_tail2,1},
+	{l_loop_rec,0},
+	{l_move_call_ext,3},
+	{is_nil,4},
+	{l_is_ne_exact_immed,0},
+	{l_increment,3},
+	{l_is_ne,0},
+	{l_move_call,3},
+	{l_plus,1},
+	{catch_end,1},
+	{l_move_call,4},
+	{init,5},
+	{l_call_last,6},
+	{l_call_last,5},
+	{l_minus,0},
+	{l_move_call_ext,4},
+	{l_bs_match_string,1},
+	{l_allocate_zero,4},
+	{extract_next_element,5},
+	{l_select_val2,6},
+	{l_bs_init_heap_bin,0},
+	{l_allocate_zero,5},
+	{l_bs_start_match2,2},
+	{l_fetch,7},
+	{l_call_ext_last,0},
+	{is_nonempty_list_allocate,1},
+	{l_bs_restore2,0},
+	{loop_rec_end,0},
+	{call_bif,11},
+	{l_bs_get_utf16,0},
+	{l_fast_element,1},
+	{l_gc_bif1,1},
+	{l_trim,4},
+	{move,9},
+	{wait,0},
+	{l_is_eq_exact_immed,10},
+	{extract_next_element2,4},
+	{is_atom,0},
+	{call_bif,12},
+	{int_code_end,0},
+	{l_call_fun_last,0},
+	{l_move_call_ext_only,0},
+	{get_tuple_element,6},
+	{move_deallocate_return,4},
+	{bs_context_to_binary,0},
+	{init,6},
+	{l_move_call_ext,5},
+	{extract_next_element,6},
+	{self,0},
+	{is_nil,5},
+	{l_move_call_ext,6},
+	{l_call_ext_last,1},
+	{l_call_fun,1},
+	{l_is_eq_exact_immed,11},
+	{l_move_call,5},
+	{l_is_ne_exact_immed,1},
+	{is_tuple,1},
+	{extract_next_element,7},
+	{l_move_call_last,2},
+	{l_times,0},
+	{l_bs_test_unit_8,0},
+	{l_allocate,6},
+	{badmatch,3},
+	{l_move_call_ext_only,1},
+	{l_bs_test_zero_tail2,2},
+	{l_move_call_ext,7},
+	{l_move_call_ext,8},
+	{move_return,6},
+	{l_put_tuple,4},
+	{call_bif,13},
+	{l_catch,2},
+	{bif1_body,1},
+	{l_select_val_smallints,1},
+	{raise,0},
+	{call_bif,14},
+	{is_nil,6},
+	{l_move_call,6},
+	{l_move_call_ext,9},
+	{l_select_val2,7},
+	{is_integer,0},
+	{extract_next_element3,1},
+	{l_minus,1},
+	{is_nonempty_list,10},
+	{call_bif,15},
+	{l_bs_save2,0},
+	{l_call_ext_last,2},
+	{extract_next_element,8},
+	{l_call_ext,1},
+	{l_new_bs_put_binary_all,0},
+	{l_move_call_ext_only,7},
+	{is_nil,7},
+	{deallocate_return,6},
+	{l_move_call_only,4},
+	{self,1},
+	{l_call_ext,2},
+	{l_select_val2,5},
+	{case_end,2},
+	{allocate_heap_zero,0},
+	{call_bif,16},
+	{is_nonempty_list,11},
+	{extract_next_element2,5},
+	{apply,0},
+	{try_end,0},
+	{l_move_call,7},
+	{call_bif,17},
+	{l_fast_element,0},
+	{test_heap_1_put_list,1},
+	{call_bif,19},
+	{call_bif,18},
+	{call_bif,20},
+	{l_bs_test_zero_tail2,3},
+	{l_move_call_ext,10},
+	{is_nil,8},
+	{get_tuple_element,7},
+	{call_bif,21},
+	{l_call_ext,3},
+	{catch_end,2},
+	{l_put_tuple,5},
+	{is_list,1},
+	{extract_next_element3,2},
+	{get_list,7},
+	{l_bif2,0},
+	{call_bif,22},
+	{init,7},
+	{try_end,1},
+	{l_bs_get_integer_32,0},
+	{test_arity,2},
+	{l_trim,5},
+	{l_increment,4},
+	{l_move_call,8},
+	{l_call_ext,4},
+	{extract_next_element,9},
+	{l_move_call_ext,11},
+	{l_is_ne_exact,0},
+	{l_bs_get_binary2,0},
+	{extract_next_element,24},
+	{is_integer,1},
+	{l_band,0},
+	{move_jump,0},
+	{l_is_eq_exact_immed,12},
+	{l_call_fun,2},
+	{move_deallocate_return,5},
+	{l_times,1},
+	{l_move_call_last,3},
+	{put_list,7},
+	{l_call_last,7},
+	{l_move_call_ext_only,3},
+	{l_fast_element,2},
+	{l_is_eq_exact_literal,7},
+	{extract_next_element,10},
+	{extract_next_element2,6},
+	{is_tuple,2},
+	{l_catch,3},
+	{l_call_ext,5},
+	{l_call_ext,6},
+	{l_bif2,1},
+	{l_is_eq_exact_immed,13},
+	{is_binary,0},
+	{l_call_ext,7},
+	{extract_next_element2,7},
+	{l_allocate_zero,6},
+	{l_bsr,0},
+	{l_fetch,22},
+	{move,10},
+	{extract_next_element3,3},
+	{l_is_eq_exact_immed,14},
+	{get_list,5},
+	{is_atom,1},
+	{extract_next_element3,4},
+	{l_bs_get_binary_all2,0},
+	{call_bif,23},
+	{l_move_call_only,5},
+	{call_bif,24},
+	{is_nonempty_list,12},
+	{l_is_eq_exact_immed,15},
+	{l_fetch,8},
+	{l_is_eq_exact_literal,1},
+	{l_move_call_ext,12},
+	{l_bs_get_integer_8,0},
+	{l_is_ne_exact_immed,2},
+	{put_list,6},
+	{is_nil,9},
+	{l_bsl,0},
+	{l_select_val2,9},
+	{is_list,2},
+	{l_allocate_zero,9},
+	{l_put_tuple,6},
+	{l_call_ext,8},
+	{l_bs_init_fail,0},
+	{get_list,6},
+	{l_bif2,2},
+	{deallocate_return,7},
+	{l_bs_get_integer_8,1},
+	{set_tuple_element,1},
+	{l_move_call_ext,13},
+	{l_select_val2,16},
+	{call_bif,26},
+	{call_bif,25},
+	{l_call_ext,9},
+	{l_move_call,9},
+	{l_is_eq_exact_literal,2},
+	{l_bs_get_integer_32,1},
+	{extract_next_element,11},
+	{l_is_eq_exact_literal,3},
+	{l_is_eq_exact_immed,16},
+	{l_fetch,9},
+	{l_bif2,3},
+	{is_nil,10},
+	{l_bsl,1},
+	{l_bs_test_zero_tail2,5},
+	{l_trim,6},
+	{l_rem,0},
+	{move2,8},
+	{l_move_call_ext,14},
+	{timeout,0},
+	{is_binary,1},
+	{catch_end,3},
+	{l_move_call_ext_last,1},
+	{l_call_last,8},
+	{l_allocate_zero,7},
+	{l_select_val2,10},
+	{l_fetch,10},
+	{l_fmul,0},
+	{l_bs_match_string,2},
+	{call_bif,27},
+	{extract_next_element3,10},
+	{l_gc_bif1,2},
+	{move_deallocate_return,6},
+	{l_allocate,7},
+	{l_move_call,10},
+	{l_catch,4},
+	{is_nonempty_list,36},
+	{l_bs_get_integer_small_imm,0},
+	{extract_next_element,12},
+	{l_is_eq_exact_immed,36},
+	{l_call_ext,10},
+	{move_jump,1},
+	{l_fcheckerror,0},
+	{fclearerror,0},
+	{move_return,7},
+	{l_bs_append,0},
+	{node,0},
+	{l_move_call,11},
+	{extract_next_element2,16},
+	{l_move_call_last,4},
+	{l_is_eq_exact_immed,17},
+	{l_call_ext,11},
+	{extract_next_element,13},
+	{l_move_call_ext_only,2},
+	{l_is_ne_exact_immed,11},
+	{l_is_eq_exact_immed,18},
+	{l_get,1},
+	{l_element,2},
+	{is_integer,2},
+	{is_integer,7},
+	{l_move_call_ext_last,4},
+	{l_bif2,4},
+	{l_move_call_ext,16},
+	{l_call_fun,3},
+	{l_move_call,12},
+	{call_bif,28},
+	{is_nonempty_list,13},
+	{try_end,2},
+	{is_nil,11},
+	{l_select_tuple_arity,1},
+	{is_tuple,3},
+	{l_move_call_ext_last,2},
+	{node,1},
+	{is_nonempty_list,14},
+	{l_bs_restore2,1},
+	{l_move_call_ext,17},
+	{l_band,1},
+	{l_is_eq_exact_immed,19},
+	{l_get,4},
+	{call_bif,29},
+	{call_bif,1},
+	{l_fetch,11},
+	{l_gc_bif1,3},
+	{is_nil,12},
+	{l_move_call_only,6},
+	{l_move_call,13},
+	{system_limit,0},
+	{l_element,0},
+	{l_select_tuple_arity,0},
+	{bif2_body,1},
+	{is_float,1},
+	{extract_next_element2,8},
+	{l_select_val2,8},
+	{is_integer_allocate,0},
+	{is_atom,2},
+	{l_int_div,0},
+	{l_get,2},
+	{l_gc_bif1,5},
+	{l_move_call_ext,18},
+	{is_nil,29},
+	{l_is_eq_exact_immed,20},
+	{call_bif,30},
+	{l_bor,0},
+	{l_bif1,0},
+	{l_catch,5},
+	{l_get,0},
+	{l_fetch,12},
+	{l_call_ext,13},
+	{l_call_ext,12},
+	{is_tuple,9},
+	{try_end,3},
+	{init,8},
+	{call_bif,32},
+	{call_bif,31},
+	{is_nil,13},
+	{apply_last,0},
+	{call_bif,33},
+	{l_int_div,1},
+	{call_bif,34},
+	{extract_next_element,14},
+	{put_list,9},
+	{is_nonempty_list,15},
+	{case_end,11},
+	{l_bs_skip_bits2,0},
+	{l_call_ext,14},
+	{deallocate_return,8},
+	{l_call_ext_last,3},
+	{l_move_call_ext,19},
+	{l_is_ne_exact_immed,3},
+	{extract_next_element3,5},
+	{is_integer,3},
+	{l_trim,7},
+	{l_is_eq_exact_immed,21},
+	{l_increment,8},
+	{call_bif,4},
+	{is_nonempty_list,16},
+	{is_list,7},
+	{l_element,4},
+	{extract_next_element3,6},
+	{l_is_eq_exact_literal,4},
+	{test_arity,3},
+	{move_deallocate_return,7},
+	{l_move_call_ext_only,4},
+	{l_fadd,0},
+	{l_call_ext,16},
+	{l_call_ext,15},
+	{try_end,5},
+	{try_end,4},
+	{l_move_call_ext,20},
+	{l_bs_match_string,3},
+	{call_bif,35},
+	{l_call_ext,17},
+	{fmove_1,0},
+	{l_increment,6},
+	{if_end,0},
+	{l_increment,5},
+	{l_call_ext,18},
+	{is_integer,4},
+	{l_bs_get_utf8,0},
+	{is_list,3},
+	{is_atom,3},
+	{l_fetch,13},
+	{l_bs_init_bits_fail,0},
+	{call_bif,36},
+	{l_call_ext,19},
+	{l_bs_test_zero_tail2,4},
+	{fconv,0},
+	{case_end,3},
+	{catch_end,4},
+	{l_make_export,0},
+	{l_rem,1},
+	{self,2},
+	{fmove_2,0},
+	{l_bor,1},
+	{l_call_ext_last,4},
+	{call_bif,37},
+	{l_call_last,9},
+	{bif1_body,2},
+	{is_binary,2},
+	{l_fetch,14},
+	{l_call_ext,20},
+	{l_move_call_ext,21},
+	{l_bs_skip_bits_all2,0},
+	{l_catch,7},
+	{l_move_call_ext,22},
+	{extract_next_element,15},
+	{badmatch,4},
+	{l_move_call,14},
+	{self,5},
+	{get_tuple_element,8},
+	{l_move_call_ext,23},
+	{l_move_call_ext,24},
+	{l_call_ext,21},
+	{l_move_call_only,7},
+	{put_list,8},
+	{l_is_eq_exact_immed,22},
+	{is_nonempty_list_test_heap,0},
+	{is_tuple,4},
+	{extract_next_element2,9},
+	{case_end,4},
+	{l_is_function2,0},
+	{bif2_body,3},
+	{fmove_2,1},
+	{l_call_ext,22},
+	{extract_next_element,16},
+	{extract_next_element2,10},
+	{move_jump,2},
+	{move_return,8},
+	{is_nonempty_list,17},
+	{is_pid,0},
+	{l_jump_on_val,0},
+	{l_get,3},
+	{bif1_body,3},
+	{l_select_val2,11},
+	{l_allocate_zero,8},
+	{is_list,4},
+	{l_is_ne_exact_immed,4},
+	{fmove_1,2},
+	{bif1_body,4},
+	{fmove_1,1},
+	{is_nonempty_list,18},
+	{l_bs_test_unit_8,3},
+	{l_fetch,15},
+	{l_is_eq_exact_immed,24},
+	{put_list,10},
+	{call_bif,38},
+	{l_gc_bif1,4},
+	{extract_next_element,17},
+	{is_atom,6},
+	{l_move_call,15},
+	{l_allocate,10},
+	{l_move_call_ext_last,3},
+	{l_call_ext,23},
+	{l_element,1},
+	{move_deallocate_return,8},
+	{l_new_bs_put_integer,0},
+	{l_call_ext,24},
+	{l_move_call_last,5},
+	{l_move_call_ext,25},
+	{init,9},
+	{l_allocate,8},
+	{l_call_ext,25},
+	{l_fdiv,0},
+	{bs_context_to_binary,4},
+	{l_bif2,6},
+	{l_call_ext_last,6},
+	{get_list,8},
+	{node,4},
+	{l_call_ext,26},
+	{extract_next_element,18},
+	{deallocate_return,9},
+	{l_move_call_ext,15},
+	{is_binary,3},
+	{move_deallocate_return,9},
+	{l_call_ext,27},
+	{is_nonempty_list,19},
+	{l_select_val_atoms,2},
+	{badmatch,17},
+	{call_bif,39},
+	{l_call_ext,28},
+	{extract_next_element2,11},
+	{badmatch,5},
+	{case_end,5},
+	{l_bs_restore2,2},
+	{l_fetch,16},
+	{l_bs_get_integer,0},
+	{l_is_eq_exact_immed,25},
+	{l_call_ext,29},
+	{move_return,9},
+	{is_function,2},
+	{l_bif1,2},
+	{l_move_call_ext,26},
+	{call_bif,40},
+	{l_call_ext,30},
+	{case_end,6},
+	{l_move_call_ext,27},
+	{catch_end,5},
+	{l_bs_get_binary_imm2,0},
+	{l_move_call_ext,28},
+	{call_bif,42},
+	{call_bif,41},
+	{l_call_ext,32},
+	{l_call_ext,31},
+	{l_bs_test_unit_8,1},
+	{l_move_call,16},
+	{l_bsr,1},
+	{l_move_call_ext,29},
+	{l_bs_skip_bits_imm2,0},
+	{l_move_call_ext,30},
+	{l_call_ext,34},
+	{l_call_ext,33},
+	{is_nil,15},
+	{is_nil,14},
+	{badmatch,6},
+	{l_call_last,11},
+	{fconv,1},
+	{is_boolean,0},
+	{l_is_ne_exact_immed,5},
+	{call_bif,43},
+	{l_call_ext,35},
+	{is_nil,16},
+	{l_move_call_only,8},
+	{l_bs_test_unit_8,2},
+	{catch_end,7},
+	{l_bs_get_utf16,1},
+	{get_list,9},
+	{l_plus,2},
+	{deallocate_return,12},
+	{l_element,3},
+	{move_jump,3},
+	{l_bs_put_string,0},
+	{is_pid,1},
+	{is_atom,4},
+	{l_select_tuple_arity,2},
+	{l_call_ext,36},
+	{extract_next_element,19},
+	{case_end,7},
+	{l_catch,6},
+	{l_call_ext,38},
+	{l_call_ext,37},
+	{move_jump,4},
+	{is_nil,17},
+	{is_list,5},
+	{try_case_end,0},
+	{l_bs_get_binary_all2,1},
+	{move,11},
+	{l_move_call_last,6},
+	{put_list,14},
+	{move_jump,5},
+	{move_return,10},
+	{l_is_eq_exact_literal,5},
+	{bif2_body,2},
+	{get_tuple_element,9},
+	{put_list,11},
+	{l_select_val2,12},
+	{call_bif,44},
+	{is_nonempty_list,20},
+	{l_fsub,0},
+	{l_move_call_ext,31},
+	{bif1_body,5},
+	{l_call_ext,39},
+	{extract_next_element3,7},
+	{l_bs_start_match2,3},
+	{l_trim,8},
+	{bs_context_to_binary,1},
+	{l_call_ext,40},
+	{move_return,11},
+	{l_call_fun,4},
+	{l_is_eq_exact_literal,6},
+	{l_is_ne_exact_immed,6},
+	{test_heap_1_put_list,2},
+	{test_heap_1_put_list,3},
+	{l_is_eq_exact_immed,26},
+	{self,3},
+	{l_call_ext,41},
+	{l_move_call_ext,33},
+	{init,10},
+	{l_bs_skip_bits_imm2,1},
+	{l_call_ext,42},
+	{extract_next_element2,12},
+	{badmatch,7},
+	{l_move_call_ext_only,5},
+	{l_call_ext,43},
+	{move_jump,6},
+	{is_nil,18},
+	{l_call_ext_only,0},
+	{l_fetch,17},
+	{l_move_call_ext,34},
+	{l_move_call_ext,35},
+	{l_is_eq_exact_immed,27},
+	{l_bs_append,1},
+	{l_bif2,5},
+	{l_bs_get_binary2,1},
+	{l_bs_get_integer_small_imm,1},
+	{l_call_ext,47},
+	{l_call_ext,46},
+	{l_call_ext,45},
+	{l_call_ext,44},
+	{move_return,12},
+	{l_bs_save2,1},
+	{is_function,0},
+	{l_bs_get_integer_imm,0},
+	{l_move_call_ext_only,6},
+	{l_call_ext,48},
+	{l_move_call,17},
+	{l_is_ne_exact_immed,7},
+	{l_call_ext,50},
+	{l_call_ext,49},
+	{is_integer,5},
+	{move_return,13},
+	{l_bs_put_string,1},
+	{try_end,7},
+	{l_yield,0},
+	{l_move_call,18},
+	{l_fetch,18},
+	{l_is_eq_exact_immed,28},
+	{l_new_bs_put_integer,1},
+	{node,2},
+	{l_call_ext,51},
+	{move_jump,7},
+	{case_end,9},
+	{case_end,8},
+	{is_nonempty_list,22},
+	{is_nonempty_list,21},
+	{l_move_call,19},
+	{l_move_call_ext,37},
+	{get_list,11},
+	{l_fetch,19},
+	{l_new_bs_put_float_imm,1},
+	{l_move_call,20},
+	{l_call_ext_only,1},
+	{l_gc_bif1,6},
+	{l_bif1,1},
+	{l_move_call,21},
+	{l_is_ne_exact_literal,0},
+	{l_bs_put_string,2},
+	{l_call_ext,52},
+	{l_is_eq_exact_immed,23},
+	{extract_next_element,20},
+	{is_nil,19},
+	{badmatch,8},
+	{catch_end,6},
+	{l_is_function2,1},
+	{l_call_ext,53},
+	{move_return,14},
+	{badmatch,9},
+	{self,4},
+	{l_call_ext,56},
+	{l_call_ext,55},
+	{l_call_ext,54},
+	{l_call_ext_last,5},
+	{l_move_call,23},
+	{l_move_call,22},
+	{l_select_tuple_arity,3},
+	{l_apply,0},
+	{init,16},
+	{init,11},
+	{l_move_call_last,8},
+	{l_move_call_last,7},
+	{l_call_ext,59},
+	{l_call_ext,58},
+	{l_call_ext,57},
+	{extract_next_element2,13},
+	{l_new_bs_put_integer_imm,1},
+	{try_end,6},
+	{deallocate_return,10},
+	{l_move_call,24},
+	{l_fetch,20},
+	{get_list,10},
+	{l_allocate,9},
+	{bs_init_writable,0},
+	{l_call_ext,60},
+	{extract_next_element,21},
+	{extract_next_element3,8},
+	{is_integer,6},
+	{move_jump,8},
+	{badmatch,10},
+	{is_nonempty_list,23},
+	{l_bs_private_append,0},
+	{deallocate_return,11},
+	{l_move_call,25},
+	{l_call_ext,63},
+	{l_call_ext,62},
+	{l_call_ext,61},
+	{move_jump,9},
+	{move_return,16},
+	{move_return,15},
+	{bs_context_to_binary,2},
+	{l_jump_on_val,1},
+	{l_increment,7},
+	{l_is_ne_exact_immed,8},
+	{l_call_ext,67},
+	{l_call_ext,66},
+	{l_call_ext,65},
+	{l_call_ext,64},
+	{extract_next_element2,14},
+	{put_list,13},
+	{is_float,0},
+	{l_is_eq_exact_immed,29},
+	{l_select_val2,14},
+	{l_call_ext,69},
+	{l_call_ext,68},
+	{extract_next_element3,9},
+	{move_return,17},
+	{is_nonempty_list,25},
+	{is_nonempty_list,24},
+	{l_select_tuple_arity2,2},
+	{is_atom,5},
+	{l_call_ext_only,2},
+	{l_is_ne_exact_immed,9},
+	{node,3},
+	{is_tuple,5},
+	{l_call_ext,73},
+	{l_call_ext,72},
+	{l_call_ext,71},
+	{l_call_ext,70},
+	{extract_next_element,22},
+	{wait_timeout,0},
+	{extract_next_element2,15},
+	{is_nil,20},
+	{is_nonempty_list,26},
+	{l_wait_timeout,2},
+	{l_minus,2},
+	{is_tuple,6},
+	{l_call_ext,79},
+	{l_call_ext,78},
+	{l_call_ext,77},
+	{l_call_ext,76},
+	{l_call_ext,75},
+	{l_call_ext,74},
+	{l_call_last,10},
+	{l_bs_test_tail_imm2,0},
+	{move_jump,10},
+	{move_return,18},
+	{is_integer_allocate,1},
+	{is_nonempty_list,27},
+	{l_new_bs_put_float_imm,0},
+	{l_fetch,21},
+	{move,12},
+	{move2,9},
+	{l_bs_skip_bits_all2,1},
+	{is_tuple,7},
+	{l_call_ext,84},
+	{l_call_ext,83},
+	{l_call_ext,82},
+	{l_call_ext,81},
+	{l_call_ext,80},
+	{l_is_eq_exact_immed,30},
+	{is_nil,21},
+	{recv_mark,0},
+	{raise,1},
+	{case_end,10},
+	{is_function,1},
+	{l_call_ext_only,3},
+	{l_recv_set,0},
+	{l_bs_skip_bits_all2,2},
+	{l_fast_element,3},
+	{l_trim,11},
+	{l_times,2},
+	{bs_context_to_binary,3},
+	{l_move_call_ext,32},
+	{l_is_eq_exact_immed,31},
+	{is_port,0},
+	{l_bs_get_float2,0},
+	{l_bs_get_utf8,1},
+	{l_select_val2,15},
+	{l_select_tuple_arity,4},
+	{test_heap_1_put_list,4},
+	{is_map,0},
+	{l_trim,9},
+	{badmatch,11},
+	{l_apply_fun,0},
+	{init,12},
+	{l_is_eq_exact_immed,32},
+	{extract_next_element,23},
+	{l_move_call_only,10},
+	{l_move_call_only,9},
+	{l_is_eq_exact_immed,33},
+	{l_is_ne_exact_immed,10},
+	{move_return,19},
+	{badmatch,13},
+	{badmatch,12},
+	{l_bs_get_integer_16,0},
+	{l_bs_get_binary_all_reuse,1},
+	{l_is_eq_exact_immed,34},
+	{move_jump,11},
+	{move_return,21},
+	{move_return,20},
+	{l_move_call_only,11},
+	{badmatch,14},
+	{is_list,6},
+	{l_bs_init_fail,1},
+	{l_move_call_ext,36},
+	{is_tuple,8},
+	{move_jump,13},
+	{move_jump,12},
+	{move_return,22},
+	{is_nil,22},
+	{is_nonempty_list,29},
+	{is_nonempty_list,28},
+	{l_bs_init,0},
+	{l_bs_restore2,3},
+	{move,13},
+	{l_bs_get_binary_imm2,1},
+	{is_nonempty_list,30},
+	{l_bs_init_bits,0},
+	{l_bs_put_utf16,0},
+	{is_bitstr,0},
+	{l_bs_validate_unicode,0},
+	{is_nonempty_list,32},
+	{is_nonempty_list,31},
+	{l_bs_save2,2},
+	{l_bs_utf16_size,0},
+	{l_bs_get_binary2,2},
+	{l_is_eq_exact_immed,35},
+	{get_tuple_element,10},
+	{l_bs_get_integer_32,2},
+	{move_return,24},
+	{move_return,23},
+	{is_nil,23},
+	{badmatch,15},
+	{is_nonempty_list,33},
+	{move,14},
+	{l_bs_add,1},
+	{is_reference,0},
+	{is_nil,26},
+	{is_nil,25},
+	{is_nil,24},
+	{l_new_bs_put_binary,0},
+	{badmatch,16},
+	{is_nonempty_list,34},
+	{init,13},
+	{is_nil,28},
+	{is_nil,27},
+	{put_list,12},
+	{is_nonempty_list,35},
+	{l_bs_validate_unicode_retract,0},
+	{l_wait_timeout,0},
+	{l_gc_bif2,0},
+	{init,14},
+	{l_fast_element,4},
+	{l_trim,10},
+	{l_new_bs_put_binary_all,1},
+	{l_apply_last,0},
+	{init,15},
+	{is_number,0},
+	{l_int_bnot,0},
+	{l_bs_put_utf8,0},
+	{l_new_bs_put_float,0},
+	{l_select_val2,13},
+	{l_bs_utf8_size,0},
+	{l_wait_timeout,1},
+	{fmove_2,2},
+	{l_jump_on_val,2},
+	{l_bs_get_binary_imm2,2},
+	{l_fnegate,0},
+	{get_list,12},
+	{l_bs_get_integer_imm,1},
+	{bif1_body,6},
+	{l_bs_get_binary_all_reuse,2},
+	{l_bxor,0},
+	{l_new_bs_put_integer_imm,2},
+	{l_int_div,2},
+	{l_gc_bif3,0},
+	{l_apply_only,0},
+	{l_bor,2},
+	{l_bs_start_match2,4},
+	{l_rem,2},
+	{l_bsl,2},
+	{l_new_bs_put_binary_imm,0},
+	{l_apply_fun_only,0},
+	{l_bs_get_integer_8,2},
+	{l_bs_get_integer_small_imm,2},
+	{l_hibernate,0},
+	{l_apply_fun_last,0},
+	{l_band,2},
+	{is_bigint,0},
+	{on_load,0},
+	{move2,10},
+	{l_bs_test_unit,0},
+	{l_m_div,0},
+	{l_select_val_smallints,2},
+	{is_function2,0},
+	{test_heap,1},
+	{func_info,0},
+	{call_bif,0},
+	{l_bs_get_utf16,2},
+	{l_put_tuple,7},
+	{allocate_init,1},
+	{l_call_fun_last,1},
+	{set_tuple_element,2},
+	{allocate_heap,1},
+	{is_tuple_of_arity,4},
+	{test_arity,4},
+	{l_bs_match_string,4},
+	{is_nonempty_list_allocate,2},
+	{l_bs_append,2},
+	{try_case_end,1},
+	{init3,1},
+	{l_select_tuple_arity2,3},
+	{init2,1},
+	{l_is_function2,2},
+	{l_bs_get_binary_all2,2},
+	{is_nonempty_list_test_heap,1},
+	{allocate_heap_zero,1},
+	{l_bs_init_heap_bin,1},
+	{l_plus,3},
+	{l_bs_get_integer,1}
+
+].
+
+
+fit_args(allocate_heap, [NumSlots,HeapNeeded,Live]) when NumSlots >= 0, NumSlots =< 255, HeapNeeded >= 0, HeapNeeded =< 255, Live >= 0, Live =< 255 -> 0;
+fit_args(allocate_heap, [_,_,Live]) when Live >= 0, Live =< 255 -> 1;
+fit_args(allocate_heap_zero, [NumSlots,HeapNeeded,Live]) when NumSlots >= 0, NumSlots =< 255, HeapNeeded >= 0, HeapNeeded =< 255, Live >= 0, Live =< 255 -> 0;
+fit_args(allocate_heap_zero, [_,_,Live]) when Live >= 0, Live =< 255 -> 1;
+fit_args(allocate_init, [_,{y,0}]) -> 0;
+fit_args(allocate_init, [_,_]) -> 1;
+fit_args(apply, [Arg0]) when Arg0 >= 0, Arg0 =< 255 -> 0;
+fit_args(apply_last, [Arg0,_]) when Arg0 >= 0, Arg0 =< 255 -> 0;
+fit_args(badmatch, [{x,0}]) -> 0;
+fit_args(badmatch, [{x,3}]) -> 1;
+fit_args(badmatch, [{x,2}]) -> 2;
+fit_args(badmatch, [{x,1}]) -> 3;
+fit_args(badmatch, [{y,2}]) -> 4;
+fit_args(badmatch, [{y,3}]) -> 5;
+fit_args(badmatch, [{x,4}]) -> 6;
+fit_args(badmatch, [{y,4}]) -> 7;
+fit_args(badmatch, [{x,5}]) -> 8;
+fit_args(badmatch, [{y,0}]) -> 9;
+fit_args(badmatch, [{x,7}]) -> 10;
+fit_args(badmatch, [{y,6}]) -> 11;
+fit_args(badmatch, [{y,9}]) -> 13;
+fit_args(badmatch, [{y,5}]) -> 12;
+fit_args(badmatch, [{y,1}]) -> 14;
+fit_args(badmatch, [{x,6}]) -> 15;
+fit_args(badmatch, [{y,8}]) -> 16;
+fit_args(badmatch, [_]) -> 17;
+fit_args(bif1_body, [{b,{erlang,hd,1}},{y,1},{x,2}]) -> 2;
+fit_args(bif1_body, [{b,{erlang,hd,1}},_,{x,0}]) -> 0;
+fit_args(bif1_body, [{b,_},{x,0},_]) -> 1;
+fit_args(bif1_body, [{b,_},{y,Arg1},{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 4;
+fit_args(bif1_body, [{b,_},{x,_},{x,_}]) -> 5;
+fit_args(bif1_body, [{b,_},_,{x,0}]) -> 3;
+fit_args(bif1_body, [{b,_},_,_]) -> 6;
+fit_args(bif2_body, [{b,_},{x,0}]) -> 0;
+fit_args(bif2_body, [{b,_},{x,1}]) -> 1;
+fit_args(bif2_body, [{b,_},{x,2}]) -> 2;
+fit_args(bif2_body, [{b,_},_]) -> 3;
+fit_args(bs_context_to_binary, [{x,0}]) -> 0;
+fit_args(bs_context_to_binary, [{x,1}]) -> 1;
+fit_args(bs_context_to_binary, [{x,2}]) -> 2;
+fit_args(bs_context_to_binary, [{y,0}]) -> 3;
+fit_args(bs_context_to_binary, [_]) -> 4;
+fit_args(bs_init_writable, []) -> 0;
+fit_args(call_bif, [{b,{erlang,iolist_to_binary,1}}]) -> 7;
+fit_args(call_bif, [{b,{erlang,error,1}}]) -> 3;
+fit_args(call_bif, [{b,{erlang,setelement,3}}]) -> 8;
+fit_args(call_bif, [{b,{erlang,'++',2}}]) -> 9;
+fit_args(call_bif, [{b,{erlang,throw,1}}]) -> 6;
+fit_args(call_bif, [{b,{erlang,error,2}}]) -> 2;
+fit_args(call_bif, [{b,{erlang,exit,1}}]) -> 5;
+fit_args(call_bif, [{b,{lists,member,2}}]) -> 10;
+fit_args(call_bif, [{b,{ets,insert,2}}]) -> 11;
+fit_args(call_bif, [{b,{erlang,get_module_info,2}}]) -> 12;
+fit_args(call_bif, [{b,{erlang,binary_to_list,1}}]) -> 13;
+fit_args(call_bif, [{b,{erlang,list_to_binary,1}}]) -> 14;
+fit_args(call_bif, [{b,{ets,delete,1}}]) -> 15;
+fit_args(call_bif, [{b,{lists,keysearch,3}}]) -> 16;
+fit_args(call_bif, [{b,{ets,lookup,2}}]) -> 17;
+fit_args(call_bif, [{b,{erlang,integer_to_list,1}}]) -> 19;
+fit_args(call_bif, [{b,{lists,reverse,2}}]) -> 18;
+fit_args(call_bif, [{b,{erlang,atom_to_list,1}}]) -> 20;
+fit_args(call_bif, [{b,{erlang,list_to_atom,1}}]) -> 21;
+fit_args(call_bif, [{b,{ets,info,2}}]) -> 22;
+fit_args(call_bif, [{b,{erlang,tuple_to_list,1}}]) -> 23;
+fit_args(call_bif, [{b,{erlang,list_to_tuple,1}}]) -> 24;
+fit_args(call_bif, [{b,{erlang,'--',2}}]) -> 26;
+fit_args(call_bif, [{b,{lists,keyfind,3}}]) -> 25;
+fit_args(call_bif, [{b,{ets,lookup_element,3}}]) -> 27;
+fit_args(call_bif, [{b,{erlang,process_flag,2}}]) -> 28;
+fit_args(call_bif, [{b,{re,run,3}}]) -> 29;
+fit_args(call_bif, [{b,{erlang,raise,3}}]) -> 1;
+fit_args(call_bif, [{b,{ets,new,2}}]) -> 30;
+fit_args(call_bif, [{b,{erlang,make_ref,0}}]) -> 32;
+fit_args(call_bif, [{b,{erlang,whereis,1}}]) -> 31;
+fit_args(call_bif, [{b,{erlang,process_info,2}}]) -> 33;
+fit_args(call_bif, [{b,{erlang,unlink,1}}]) -> 34;
+fit_args(call_bif, [{b,{erlang,exit,2}}]) -> 4;
+fit_args(call_bif, [{b,{erlang,get_stacktrace,0}}]) -> 35;
+fit_args(call_bif, [{b,{ets,delete,2}}]) -> 36;
+fit_args(call_bif, [{b,{lists,keymember,3}}]) -> 37;
+fit_args(call_bif, [{b,{erlang,now,0}}]) -> 38;
+fit_args(call_bif, [{b,{erlang,spawn_link,1}}]) -> 39;
+fit_args(call_bif, [{b,{ets,safe_fixtable,2}}]) -> 40;
+fit_args(call_bif, [{b,{ets,next,2}}]) -> 42;
+fit_args(call_bif, [{b,{erlang,fun_info,2}}]) -> 41;
+fit_args(call_bif, [{b,{erlang,monitor,2}}]) -> 43;
+fit_args(call_bif, [{b,{ets,match_object,2}}]) -> 44;
+fit_args(call_bif, [{b,{erlang,purge_module,1}}]) -> 0;
+fit_args(call_bif, [{b,_}]) -> 45;
+fit_args(case_end, [{x,0}]) -> 0;
+fit_args(case_end, [{x,1}]) -> 1;
+fit_args(case_end, [{x,2}]) -> 2;
+fit_args(case_end, [{x,3}]) -> 3;
+fit_args(case_end, [{y,2}]) -> 4;
+fit_args(case_end, [{y,1}]) -> 5;
+fit_args(case_end, [{x,4}]) -> 6;
+fit_args(case_end, [{y,3}]) -> 7;
+fit_args(case_end, [{y,4}]) -> 9;
+fit_args(case_end, [{y,0}]) -> 8;
+fit_args(case_end, [{x,5}]) -> 10;
+fit_args(case_end, [_]) -> 11;
+fit_args(catch_end, [{y,0}]) -> 0;
+fit_args(catch_end, [{y,1}]) -> 1;
+fit_args(catch_end, [{y,2}]) -> 2;
+fit_args(catch_end, [{y,3}]) -> 3;
+fit_args(catch_end, [{y,4}]) -> 4;
+fit_args(catch_end, [{y,5}]) -> 5;
+fit_args(catch_end, [{y,6}]) -> 6;
+fit_args(catch_end, [_]) -> 7;
+fit_args(deallocate_return, [1]) -> 0;
+fit_args(deallocate_return, [0]) -> 1;
+fit_args(deallocate_return, [2]) -> 2;
+fit_args(deallocate_return, [3]) -> 3;
+fit_args(deallocate_return, [4]) -> 4;
+fit_args(deallocate_return, [5]) -> 5;
+fit_args(deallocate_return, [6]) -> 6;
+fit_args(deallocate_return, [7]) -> 7;
+fit_args(deallocate_return, [8]) -> 8;
+fit_args(deallocate_return, [9]) -> 9;
+fit_args(deallocate_return, [10]) -> 10;
+fit_args(deallocate_return, [11]) -> 11;
+fit_args(deallocate_return, [_]) -> 12;
+fit_args(extract_next_element, [{x,1}]) -> 0;
+fit_args(extract_next_element, [{x,3}]) -> 1;
+fit_args(extract_next_element, [{x,2}]) -> 2;
+fit_args(extract_next_element, [{x,4}]) -> 3;
+fit_args(extract_next_element, [{x,5}]) -> 4;
+fit_args(extract_next_element, [{x,6}]) -> 5;
+fit_args(extract_next_element, [{x,255}]) -> 6;
+fit_args(extract_next_element, [{x,7}]) -> 7;
+fit_args(extract_next_element, [{y,1}]) -> 8;
+fit_args(extract_next_element, [{y,0}]) -> 9;
+fit_args(extract_next_element, [{x,8}]) -> 10;
+fit_args(extract_next_element, [{x,9}]) -> 11;
+fit_args(extract_next_element, [{y,2}]) -> 12;
+fit_args(extract_next_element, [{y,3}]) -> 13;
+fit_args(extract_next_element, [{x,10}]) -> 14;
+fit_args(extract_next_element, [{x,11}]) -> 15;
+fit_args(extract_next_element, [{y,5}]) -> 16;
+fit_args(extract_next_element, [{y,4}]) -> 17;
+fit_args(extract_next_element, [{x,12}]) -> 18;
+fit_args(extract_next_element, [{x,13}]) -> 19;
+fit_args(extract_next_element, [{x,14}]) -> 20;
+fit_args(extract_next_element, [{x,16}]) -> 21;
+fit_args(extract_next_element, [{y,6}]) -> 22;
+fit_args(extract_next_element, [{x,18}]) -> 23;
+fit_args(extract_next_element, [_]) -> 24;
+fit_args(extract_next_element2, [{x,1}]) -> 0;
+fit_args(extract_next_element2, [{x,3}]) -> 1;
+fit_args(extract_next_element2, [{x,2}]) -> 2;
+fit_args(extract_next_element2, [{x,4}]) -> 3;
+fit_args(extract_next_element2, [{x,5}]) -> 4;
+fit_args(extract_next_element2, [{x,6}]) -> 5;
+fit_args(extract_next_element2, [{x,7}]) -> 6;
+fit_args(extract_next_element2, [{x,8}]) -> 7;
+fit_args(extract_next_element2, [{x,9}]) -> 8;
+fit_args(extract_next_element2, [{x,12}]) -> 9;
+fit_args(extract_next_element2, [{x,10}]) -> 10;
+fit_args(extract_next_element2, [{x,11}]) -> 11;
+fit_args(extract_next_element2, [{x,13}]) -> 12;
+fit_args(extract_next_element2, [{x,14}]) -> 13;
+fit_args(extract_next_element2, [{y,0}]) -> 14;
+fit_args(extract_next_element2, [{x,16}]) -> 15;
+fit_args(extract_next_element2, [_]) -> 16;
+fit_args(extract_next_element3, [{x,1}]) -> 0;
+fit_args(extract_next_element3, [{x,3}]) -> 1;
+fit_args(extract_next_element3, [{x,2}]) -> 2;
+fit_args(extract_next_element3, [{x,5}]) -> 3;
+fit_args(extract_next_element3, [{x,4}]) -> 4;
+fit_args(extract_next_element3, [{x,6}]) -> 5;
+fit_args(extract_next_element3, [{x,7}]) -> 6;
+fit_args(extract_next_element3, [{x,8}]) -> 7;
+fit_args(extract_next_element3, [{x,11}]) -> 8;
+fit_args(extract_next_element3, [{x,10}]) -> 9;
+fit_args(extract_next_element3, [_]) -> 10;
+fit_args(fclearerror, []) -> 0;
+fit_args(fconv, [_,{fr,0}]) -> 0;
+fit_args(fconv, [_,{fr,_}]) -> 1;
+fit_args(fmove_1, [{x,_},{fr,_}]) -> 1;
+fit_args(fmove_1, [_,{fr,1}]) -> 0;
+fit_args(fmove_1, [_,{fr,_}]) -> 2;
+fit_args(fmove_2, [{fr,_},{x,0}]) -> 0;
+fit_args(fmove_2, [{fr,_},{x,_}]) -> 1;
+fit_args(fmove_2, [{fr,_},_]) -> 2;
+fit_args(func_info, [_,_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(get_list, [{x,0},{x,0},_]) -> 3;
+fit_args(get_list, [{x,0},{x,_},{x,_}]) -> 1;
+fit_args(get_list, [{x,0},{y,Arg1},{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 9;
+fit_args(get_list, [{x,0},_,{x,0}]) -> 5;
+fit_args(get_list, [{x,_},{x,0},{x,_}]) -> 2;
+fit_args(get_list, [{x,_},{x,_},{x,_}]) -> 0;
+fit_args(get_list, [{y,Arg0},{x,_},{x,_}]) when Arg0 >= 0, Arg0 =< 255 -> 6;
+fit_args(get_list, [{x,_},{y,Arg1},{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 8;
+fit_args(get_list, [{x,_},{y,Arg1},{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 10;
+fit_args(get_list, [_,{x,0},_]) -> 7;
+fit_args(get_list, [_,{x,_},{y,Arg2}]) when Arg2 >= 0, Arg2 =< 255 -> 4;
+fit_args(get_list, [_,_,{x,0}]) -> 11;
+fit_args(get_list, [_,_,_]) -> 12;
+fit_args(get_tuple_element, [{x,0},1,{x,0}]) -> 6;
+fit_args(get_tuple_element, [{x,0},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(get_tuple_element, [{x,0},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(get_tuple_element, [{x,0},_,{x,0}]) -> 8;
+fit_args(get_tuple_element, [{x,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 7;
+fit_args(get_tuple_element, [{y,Arg0},Arg1,{x,0}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 9;
+fit_args(get_tuple_element, [{x,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(get_tuple_element, [{y,Arg0},Arg1,{x,_}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 4;
+fit_args(get_tuple_element, [{x,_},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 5;
+fit_args(get_tuple_element, [_,0,{x,0}]) -> 2;
+fit_args(get_tuple_element, [_,_,_]) -> 10;
+fit_args(if_end, []) -> 0;
+fit_args(init, [{y,1}]) -> 0;
+fit_args(init, [{y,0}]) -> 1;
+fit_args(init, [{y,2}]) -> 2;
+fit_args(init, [{y,3}]) -> 3;
+fit_args(init, [{y,4}]) -> 4;
+fit_args(init, [{y,5}]) -> 5;
+fit_args(init, [{y,6}]) -> 6;
+fit_args(init, [{y,7}]) -> 7;
+fit_args(init, [{y,8}]) -> 8;
+fit_args(init, [{y,9}]) -> 9;
+fit_args(init, [{y,10}]) -> 10;
+fit_args(init, [{y,11}]) -> 11;
+fit_args(init, [{y,12}]) -> 12;
+fit_args(init, [{y,14}]) -> 13;
+fit_args(init, [{y,13}]) -> 14;
+fit_args(init, [{y,16}]) -> 15;
+fit_args(init, [_]) -> 16;
+fit_args(init2, [{y,Arg0},{y,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(init2, [_,_]) -> 1;
+fit_args(init3, [{y,Arg0},{y,Arg1},{y,Arg2}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(init3, [_,_,_]) -> 1;
+fit_args(int_code_end, []) -> 0;
+fit_args(is_atom, [{f,_},{x,0}]) -> 0;
+fit_args(is_atom, [{f,_},{x,1}]) -> 1;
+fit_args(is_atom, [{f,_},{x,2}]) -> 2;
+fit_args(is_atom, [{f,_},{x,3}]) -> 3;
+fit_args(is_atom, [{f,_},{x,4}]) -> 4;
+fit_args(is_atom, [{f,_},{x,5}]) -> 5;
+fit_args(is_atom, [{f,_},_]) -> 6;
+fit_args(is_bigint, [{f,_},_]) -> 0;
+fit_args(is_binary, [{f,_},{x,0}]) -> 0;
+fit_args(is_binary, [{f,_},{x,1}]) -> 1;
+fit_args(is_binary, [{f,_},{x,2}]) -> 2;
+fit_args(is_binary, [{f,_},_]) -> 3;
+fit_args(is_bitstr, [{f,_},_]) -> 0;
+fit_args(is_boolean, [{f,_},_]) -> 0;
+fit_args(is_float, [{f,_},{x,0}]) -> 0;
+fit_args(is_float, [{f,_},_]) -> 1;
+fit_args(is_function, [{f,_},{x,0}]) -> 0;
+fit_args(is_function, [{f,_},{x,1}]) -> 1;
+fit_args(is_function, [{f,_},_]) -> 2;
+fit_args(is_function2, [{f,_},_,_]) -> 0;
+fit_args(is_integer, [{f,_},{x,0}]) -> 0;
+fit_args(is_integer, [{f,_},{x,1}]) -> 1;
+fit_args(is_integer, [{f,_},{x,2}]) -> 2;
+fit_args(is_integer, [{f,_},{x,3}]) -> 3;
+fit_args(is_integer, [{f,_},{x,4}]) -> 4;
+fit_args(is_integer, [{f,_},{x,5}]) -> 5;
+fit_args(is_integer, [{f,_},{x,6}]) -> 6;
+fit_args(is_integer, [{f,_},_]) -> 7;
+fit_args(is_integer_allocate, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(is_integer_allocate, [{f,_},_,_]) -> 1;
+fit_args(is_list, [{f,_},{x,0}]) -> 0;
+fit_args(is_list, [{f,_},{x,1}]) -> 1;
+fit_args(is_list, [{f,_},{x,2}]) -> 2;
+fit_args(is_list, [{f,_},{x,3}]) -> 3;
+fit_args(is_list, [{f,_},{x,4}]) -> 4;
+fit_args(is_list, [{f,_},{x,5}]) -> 5;
+fit_args(is_list, [{f,_},{x,7}]) -> 6;
+fit_args(is_list, [{f,_},_]) -> 7;
+fit_args(is_map, [{f,_},_]) -> 0;
+fit_args(is_nil, [{f,_},{x,0}]) -> 0;
+fit_args(is_nil, [{f,_},{x,2}]) -> 1;
+fit_args(is_nil, [{f,_},{x,1}]) -> 2;
+fit_args(is_nil, [{f,_},{x,4}]) -> 3;
+fit_args(is_nil, [{f,_},{x,3}]) -> 4;
+fit_args(is_nil, [{f,_},{x,5}]) -> 5;
+fit_args(is_nil, [{f,_},{x,6}]) -> 6;
+fit_args(is_nil, [{f,_},{x,7}]) -> 7;
+fit_args(is_nil, [{f,_},{x,8}]) -> 8;
+fit_args(is_nil, [{f,_},{x,9}]) -> 9;
+fit_args(is_nil, [{f,_},{x,10}]) -> 10;
+fit_args(is_nil, [{f,_},{x,12}]) -> 11;
+fit_args(is_nil, [{f,_},{x,11}]) -> 12;
+fit_args(is_nil, [{f,_},{y,1}]) -> 13;
+fit_args(is_nil, [{f,_},{y,2}]) -> 15;
+fit_args(is_nil, [{f,_},{x,13}]) -> 14;
+fit_args(is_nil, [{f,_},{x,15}]) -> 16;
+fit_args(is_nil, [{f,_},{x,14}]) -> 17;
+fit_args(is_nil, [{f,_},{x,16}]) -> 18;
+fit_args(is_nil, [{f,_},{y,3}]) -> 19;
+fit_args(is_nil, [{f,_},{x,17}]) -> 20;
+fit_args(is_nil, [{f,_},{y,0}]) -> 21;
+fit_args(is_nil, [{f,_},{x,19}]) -> 22;
+fit_args(is_nil, [{f,_},{x,18}]) -> 23;
+fit_args(is_nil, [{f,_},{x,22}]) -> 26;
+fit_args(is_nil, [{f,_},{x,21}]) -> 25;
+fit_args(is_nil, [{f,_},{y,4}]) -> 24;
+fit_args(is_nil, [{f,_},{x,20}]) -> 28;
+fit_args(is_nil, [{f,_},{y,5}]) -> 27;
+fit_args(is_nil, [{f,_},_]) -> 29;
+fit_args(is_nonempty_list, [{f,_},{x,0}]) -> 0;
+fit_args(is_nonempty_list, [{f,_},{x,2}]) -> 1;
+fit_args(is_nonempty_list, [{f,_},{x,1}]) -> 2;
+fit_args(is_nonempty_list, [{f,_},{x,3}]) -> 3;
+fit_args(is_nonempty_list, [{f,_},{x,7}]) -> 4;
+fit_args(is_nonempty_list, [{f,_},{x,4}]) -> 5;
+fit_args(is_nonempty_list, [{f,_},{x,5}]) -> 6;
+fit_args(is_nonempty_list, [{f,_},{x,6}]) -> 7;
+fit_args(is_nonempty_list, [{f,_},{x,9}]) -> 8;
+fit_args(is_nonempty_list, [{f,_},{x,8}]) -> 9;
+fit_args(is_nonempty_list, [{f,_},{x,10}]) -> 10;
+fit_args(is_nonempty_list, [{f,_},{x,11}]) -> 11;
+fit_args(is_nonempty_list, [{f,_},{x,12}]) -> 12;
+fit_args(is_nonempty_list, [{f,_},{x,13}]) -> 13;
+fit_args(is_nonempty_list, [{f,_},{y,2}]) -> 14;
+fit_args(is_nonempty_list, [{f,_},{y,3}]) -> 15;
+fit_args(is_nonempty_list, [{f,_},{x,14}]) -> 16;
+fit_args(is_nonempty_list, [{f,_},{y,1}]) -> 17;
+fit_args(is_nonempty_list, [{f,_},{x,15}]) -> 18;
+fit_args(is_nonempty_list, [{f,_},{x,16}]) -> 19;
+fit_args(is_nonempty_list, [{f,_},{x,17}]) -> 20;
+fit_args(is_nonempty_list, [{f,_},{y,4}]) -> 22;
+fit_args(is_nonempty_list, [{f,_},{x,18}]) -> 21;
+fit_args(is_nonempty_list, [{f,_},{x,20}]) -> 23;
+fit_args(is_nonempty_list, [{f,_},{y,0}]) -> 25;
+fit_args(is_nonempty_list, [{f,_},{x,19}]) -> 24;
+fit_args(is_nonempty_list, [{f,_},{y,6}]) -> 26;
+fit_args(is_nonempty_list, [{f,_},{y,9}]) -> 27;
+fit_args(is_nonempty_list, [{f,_},{y,7}]) -> 29;
+fit_args(is_nonempty_list, [{f,_},{y,5}]) -> 28;
+fit_args(is_nonempty_list, [{f,_},{x,24}]) -> 30;
+fit_args(is_nonempty_list, [{f,_},{y,8}]) -> 32;
+fit_args(is_nonempty_list, [{f,_},{x,21}]) -> 31;
+fit_args(is_nonempty_list, [{f,_},{x,22}]) -> 33;
+fit_args(is_nonempty_list, [{f,_},{x,25}]) -> 34;
+fit_args(is_nonempty_list, [{f,_},{x,26}]) -> 35;
+fit_args(is_nonempty_list, [{f,_},_]) -> 36;
+fit_args(is_nonempty_list_allocate, [{f,_},{x,0},_]) -> 0;
+fit_args(is_nonempty_list_allocate, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(is_nonempty_list_allocate, [{f,_},_,_]) -> 2;
+fit_args(is_nonempty_list_test_heap, [{f,_},Arg1,Arg2]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(is_nonempty_list_test_heap, [{f,_},_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(is_number, [{f,_},_]) -> 0;
+fit_args(is_pid, [{f,_},{x,0}]) -> 0;
+fit_args(is_pid, [{f,_},_]) -> 1;
+fit_args(is_port, [{f,_},_]) -> 0;
+fit_args(is_reference, [{f,_},_]) -> 0;
+fit_args(is_tuple, [{f,_},{x,0}]) -> 0;
+fit_args(is_tuple, [{f,_},{x,1}]) -> 1;
+fit_args(is_tuple, [{f,_},{x,2}]) -> 2;
+fit_args(is_tuple, [{f,_},{x,3}]) -> 3;
+fit_args(is_tuple, [{f,_},{x,4}]) -> 4;
+fit_args(is_tuple, [{f,_},{x,7}]) -> 5;
+fit_args(is_tuple, [{f,_},{x,5}]) -> 6;
+fit_args(is_tuple, [{f,_},{y,4}]) -> 7;
+fit_args(is_tuple, [{f,_},{x,6}]) -> 8;
+fit_args(is_tuple, [{f,_},_]) -> 9;
+fit_args(is_tuple_of_arity, [{f,_},{x,0},2]) -> 0;
+fit_args(is_tuple_of_arity, [{f,_},{x,0},_]) -> 2;
+fit_args(is_tuple_of_arity, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(is_tuple_of_arity, [{f,_},{y,Arg1},Arg2]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(is_tuple_of_arity, [{f,_},_,_]) -> 4;
+fit_args(jump, [{f,_}]) -> 0;
+fit_args(l_allocate, [1]) -> 0;
+fit_args(l_allocate, [0]) -> 1;
+fit_args(l_allocate, [2]) -> 2;
+fit_args(l_allocate, [3]) -> 3;
+fit_args(l_allocate, [4]) -> 4;
+fit_args(l_allocate, [5]) -> 5;
+fit_args(l_allocate, [6]) -> 6;
+fit_args(l_allocate, [7]) -> 7;
+fit_args(l_allocate, [8]) -> 8;
+fit_args(l_allocate, [9]) -> 9;
+fit_args(l_allocate, [_]) -> 10;
+fit_args(l_allocate_zero, [2]) -> 0;
+fit_args(l_allocate_zero, [1]) -> 1;
+fit_args(l_allocate_zero, [3]) -> 2;
+fit_args(l_allocate_zero, [4]) -> 3;
+fit_args(l_allocate_zero, [6]) -> 4;
+fit_args(l_allocate_zero, [5]) -> 5;
+fit_args(l_allocate_zero, [7]) -> 6;
+fit_args(l_allocate_zero, [8]) -> 7;
+fit_args(l_allocate_zero, [9]) -> 8;
+fit_args(l_allocate_zero, [_]) -> 9;
+fit_args(l_apply, []) -> 0;
+fit_args(l_apply_fun, []) -> 0;
+fit_args(l_apply_fun_last, [_]) -> 0;
+fit_args(l_apply_fun_only, []) -> 0;
+fit_args(l_apply_last, [_]) -> 0;
+fit_args(l_apply_only, []) -> 0;
+fit_args(l_band, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_band, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_band, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_bif1, [{f,_},{b,{erlang,tuple_size,1}},{x,0},_]) -> 1;
+fit_args(l_bif1, [{f,_},{b,_},{x,_},{x,_}]) -> 0;
+fit_args(l_bif1, [{f,_},{b,_},_,_]) -> 2;
+fit_args(l_bif2, [{f,_},{b,{erlang,element,2}},_]) -> 0;
+fit_args(l_bif2, [{f,_},{b,{erlang,'=:=',2}},_]) -> 1;
+fit_args(l_bif2, [{f,_},{b,{erlang,'=<',2}},_]) -> 2;
+fit_args(l_bif2, [{f,_},{b,{erlang,'and',2}},_]) -> 3;
+fit_args(l_bif2, [{f,_},{b,{erlang,'or',2}},_]) -> 4;
+fit_args(l_bif2, [{f,_},{b,{erlang,'==',2}},_]) -> 5;
+fit_args(l_bif2, [{f,_},{b,_},_]) -> 6;
+fit_args(l_bor, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bor, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_bor, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_bs_add, [{f,_},1,_]) -> 0;
+fit_args(l_bs_add, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_bs_append, [{f,_},Arg1,Arg2,Arg3,{x,0}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_bs_append, [{f,_},Arg1,Arg2,Arg3,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_append, [{f,_},_,Arg2,Arg3,_]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 2;
+fit_args(l_bs_get_binary2, [{f,_},{x,_},Arg2,_,Arg4,0,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 1;
+fit_args(l_bs_get_binary2, [{f,_},_,Arg2,{x,_},Arg4,0,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 0;
+fit_args(l_bs_get_binary2, [{f,_},_,Arg2,_,Arg4,Arg5,_]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255, Arg5 >= 0, Arg5 =< 255 -> 2;
+fit_args(l_bs_get_binary_all2, [{f,_},{x,0},Arg2,Arg3,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_bs_get_binary_all2, [{f,_},{x,_},Arg2,Arg3,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_get_binary_all2, [{f,_},_,Arg2,Arg3,_]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 2;
+fit_args(l_bs_get_binary_all_reuse, [{x,0},{f,_},1]) -> 1;
+fit_args(l_bs_get_binary_all_reuse, [_,{f,_},8]) -> 0;
+fit_args(l_bs_get_binary_all_reuse, [_,{f,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_bs_get_binary_imm2, [{f,_},{x,0},Arg2,_,Arg4,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 1;
+fit_args(l_bs_get_binary_imm2, [{f,_},{x,_},Arg2,Arg3,0,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_get_binary_imm2, [{f,_},_,Arg2,_,Arg4,_]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 2;
+fit_args(l_bs_get_float2, [{f,_},_,Arg2,_,Arg4,Arg5,_]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255, Arg5 >= 0, Arg5 =< 255 -> 0;
+fit_args(l_bs_get_integer, [{f,_},Arg1,Arg2,Arg3,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_get_integer, [{f,_},Arg1,Arg2,Arg3,_]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_bs_get_integer_16, [_,{f,_},_]) -> 0;
+fit_args(l_bs_get_integer_32, [{x,0},{f,_},Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_bs_get_integer_32, [{x,_},{f,_},Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_get_integer_32, [_,{f,_},Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_bs_get_integer_8, [{x,0},{f,_},{x,_}]) -> 0;
+fit_args(l_bs_get_integer_8, [{x,_},{f,_},{x,_}]) -> 1;
+fit_args(l_bs_get_integer_8, [_,{f,_},_]) -> 2;
+fit_args(l_bs_get_integer_imm, [_,Arg1,Arg2,{f,_},Arg4,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 0;
+fit_args(l_bs_get_integer_imm, [_,_,Arg2,{f,_},Arg4,_]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 1;
+fit_args(l_bs_get_integer_small_imm, [{x,0},Arg1,{f,_},Arg3,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_get_integer_small_imm, [{x,_},Arg1,{f,_},Arg3,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_bs_get_integer_small_imm, [_,_,{f,_},Arg3,_]) when Arg3 >= 0, Arg3 =< 255 -> 2;
+fit_args(l_bs_get_utf16, [{x,0},{f,_},Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_bs_get_utf16, [{x,_},{f,_},Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_get_utf16, [_,{f,_},Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_bs_get_utf8, [{x,_},{f,_},{x,_}]) -> 0;
+fit_args(l_bs_get_utf8, [_,{f,_},_]) -> 1;
+fit_args(l_bs_init, [_,_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_init_bits, [_,_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_init_bits_fail, [_,{f,_},Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_init_fail, [Arg0,{f,_},Arg2,{x,_}]) when Arg0 >= 0, Arg0 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_init_fail, [_,{f,_},Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_bs_init_heap_bin, [Arg0,Arg1,Arg2,_]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_init_heap_bin, [_,_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_bs_match_string, [{x,1},{f,_},_,{str,_}]) -> 0;
+fit_args(l_bs_match_string, [{x,0},{f,_},_,{str,_}]) -> 2;
+fit_args(l_bs_match_string, [{x,_},{f,_},Arg2,{str,_}]) when Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(l_bs_match_string, [_,{f,_},8,{str,_}]) -> 1;
+fit_args(l_bs_match_string, [_,{f,_},_,{str,_}]) -> 4;
+fit_args(l_bs_private_append, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bs_put_string, [1,{str,_}]) -> 0;
+fit_args(l_bs_put_string, [4,{str,_}]) -> 1;
+fit_args(l_bs_put_string, [_,{str,_}]) -> 2;
+fit_args(l_bs_put_utf16, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bs_put_utf8, [{f,_},_]) -> 0;
+fit_args(l_bs_restore2, [{x,0},0]) -> 1;
+fit_args(l_bs_restore2, [{x,0},1]) -> 2;
+fit_args(l_bs_restore2, [{x,_},Arg1]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bs_restore2, [_,_]) -> 3;
+fit_args(l_bs_save2, [{x,0},1]) -> 1;
+fit_args(l_bs_save2, [{x,_},Arg1]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bs_save2, [_,_]) -> 2;
+fit_args(l_bs_skip_bits2, [{f,_},_,_,Arg3]) when Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_bs_skip_bits_all2, [{f,_},{x,2},8]) -> 0;
+fit_args(l_bs_skip_bits_all2, [{f,_},{x,3},8]) -> 1;
+fit_args(l_bs_skip_bits_all2, [{f,_},_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_bs_skip_bits_imm2, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_skip_bits_imm2, [{f,_},_,_]) -> 1;
+fit_args(l_bs_start_match2, [{x,0},{f,_},1,0,{x,1}]) -> 0;
+fit_args(l_bs_start_match2, [{x,0},{f,_},Arg2,Arg3,{x,0}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 2;
+fit_args(l_bs_start_match2, [_,{f,_},Arg2,Arg3,{x,0}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 3;
+fit_args(l_bs_start_match2, [_,{f,_},Arg2,Arg3,{x,_}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_bs_start_match2, [_,{f,_},Arg2,_,_]) when Arg2 >= 0, Arg2 =< 255 -> 4;
+fit_args(l_bs_test_tail_imm2, [{f,_},_,_]) -> 0;
+fit_args(l_bs_test_unit, [{f,_},_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_bs_test_unit_8, [{f,_},{x,0}]) -> 0;
+fit_args(l_bs_test_unit_8, [{f,_},{x,3}]) -> 1;
+fit_args(l_bs_test_unit_8, [{f,_},{x,1}]) -> 2;
+fit_args(l_bs_test_unit_8, [{f,_},_]) -> 3;
+fit_args(l_bs_test_zero_tail2, [{f,_},{x,1}]) -> 0;
+fit_args(l_bs_test_zero_tail2, [{f,_},{x,2}]) -> 1;
+fit_args(l_bs_test_zero_tail2, [{f,_},{x,0}]) -> 2;
+fit_args(l_bs_test_zero_tail2, [{f,_},{x,3}]) -> 3;
+fit_args(l_bs_test_zero_tail2, [{f,_},{x,4}]) -> 4;
+fit_args(l_bs_test_zero_tail2, [{f,_},_]) -> 5;
+fit_args(l_bs_utf16_size, [_,_]) -> 0;
+fit_args(l_bs_utf8_size, [_,_]) -> 0;
+fit_args(l_bs_validate_unicode, [{f,_},_]) -> 0;
+fit_args(l_bs_validate_unicode_retract, [{f,_}]) -> 0;
+fit_args(l_bsl, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bsl, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_bsl, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_bsr, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_bsr, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_bxor, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_call, [{f,_}]) -> 0;
+fit_args(l_call_ext, [{e,{lists,reverse,1}}]) -> 0;
+fit_args(l_call_ext, [{e,{asn1ct_gen,emit,1}}]) -> 1;
+fit_args(l_call_ext, [{e,{file,close,1}}]) -> 2;
+fit_args(l_call_ext, [{e,{lists,foreach,2}}]) -> 3;
+fit_args(l_call_ext, [{e,{lists,foldl,3}}]) -> 4;
+fit_args(l_call_ext, [{e,{lists,sort,1}}]) -> 5;
+fit_args(l_call_ext, [{e,{file,open,2}}]) -> 6;
+fit_args(l_call_ext, [{e,{lists,map,2}}]) -> 7;
+fit_args(l_call_ext, [{e,{filename,join,2}}]) -> 8;
+fit_args(l_call_ext, [{e,{lists,flatten,1}}]) -> 9;
+fit_args(l_call_ext, [{e,{ordsets,union,2}}]) -> 10;
+fit_args(l_call_ext, [{e,{lists,concat,1}}]) -> 11;
+fit_args(l_call_ext, [{e,{file,delete,1}}]) -> 13;
+fit_args(l_call_ext, [{e,{test_server,timetrap,1}}]) -> 12;
+fit_args(l_call_ext, [{e,{test_server,timetrap_cancel,1}}]) -> 14;
+fit_args(l_call_ext, [{e,{dict,find,2}}]) -> 16;
+fit_args(l_call_ext, [{e,{mnesia_lib,set,2}}]) -> 15;
+fit_args(l_call_ext, [{e,{lists,mapfoldl,3}}]) -> 17;
+fit_args(l_call_ext, [{e,{dict,new,0}}]) -> 18;
+fit_args(l_call_ext, [{e,{test_server,lookup_config,2}}]) -> 19;
+fit_args(l_call_ext, [{e,{erl_syntax,type,1}}]) -> 20;
+fit_args(l_call_ext, [{e,{erlang,binary_to_term,1}}]) -> 21;
+fit_args(l_call_ext, [{e,{dict,store,3}}]) -> 22;
+fit_args(l_call_ext, [{e,{prettypr,floating,1}}]) -> 23;
+fit_args(l_call_ext, [{e,{proplists,get_value,2}}]) -> 24;
+fit_args(l_call_ext, [{e,{erlang,list_to_integer,1}}]) -> 25;
+fit_args(l_call_ext, [{e,{filename,join,1}}]) -> 26;
+fit_args(l_call_ext, [{e,{lists,usort,1}}]) -> 27;
+fit_args(l_call_ext, [{e,{proplists,get_value,3}}]) -> 28;
+fit_args(l_call_ext, [{e,{sofs,to_external,1}}]) -> 29;
+fit_args(l_call_ext, [{e,{lists,filter,2}}]) -> 30;
+fit_args(l_call_ext, [{e,{ordsets,from_list,1}}]) -> 32;
+fit_args(l_call_ext, [{e,{string,tokens,2}}]) -> 31;
+fit_args(l_call_ext, [{e,{asn1_db,dbget,2}}]) -> 34;
+fit_args(l_call_ext, [{e,{prettypr,beside,2}}]) -> 33;
+fit_args(l_call_ext, [{e,{lists,append,1}}]) -> 35;
+fit_args(l_call_ext, [{e,{erlang,term_to_binary,1}}]) -> 36;
+fit_args(l_call_ext, [{e,{lists,last,1}}]) -> 38;
+fit_args(l_call_ext, [{e,{erlang,put,2}}]) -> 37;
+fit_args(l_call_ext, [{e,{lists,delete,2}}]) -> 39;
+fit_args(l_call_ext, [{e,{lists,keydelete,3}}]) -> 40;
+fit_args(l_call_ext, [{e,{unicode,characters_to_binary,1}}]) -> 41;
+fit_args(l_call_ext, [{e,{erlang,max,2}}]) -> 42;
+fit_args(l_call_ext, [{e,{file,read,2}}]) -> 43;
+fit_args(l_call_ext, [{e,{file,write,2}}]) -> 47;
+fit_args(l_call_ext, [{e,{ordsets,subtract,2}}]) -> 46;
+fit_args(l_call_ext, [{e,{gb_trees,lookup,2}}]) -> 45;
+fit_args(l_call_ext, [{e,{lists,duplicate,2}}]) -> 44;
+fit_args(l_call_ext, [{e,{filename,basename,1}}]) -> 48;
+fit_args(l_call_ext, [{e,{file,read_file,1}}]) -> 50;
+fit_args(l_call_ext, [{e,{gb_trees,empty,0}}]) -> 49;
+fit_args(l_call_ext, [{e,{file,read_file_info,1}}]) -> 51;
+fit_args(l_call_ext, [{e,{io,format,3}}]) -> 52;
+fit_args(l_call_ext, [{e,{filename,dirname,1}}]) -> 53;
+fit_args(l_call_ext, [{e,{file,position,2}}]) -> 56;
+fit_args(l_call_ext, [{e,{os,type,0}}]) -> 55;
+fit_args(l_call_ext, [{e,{cerl,get_ann,1}}]) -> 54;
+fit_args(l_call_ext, [{e,{file,make_dir,1}}]) -> 59;
+fit_args(l_call_ext, [{e,{erl_syntax,atom,1}}]) -> 58;
+fit_args(l_call_ext, [{e,{ssh_channel,cache_lookup,2}}]) -> 57;
+fit_args(l_call_ext, [{e,{orddict,find,2}}]) -> 60;
+fit_args(l_call_ext, [{e,{asn1ct_gen,mk_var,1}}]) -> 63;
+fit_args(l_call_ext, [{e,{sofs,family_union,2}}]) -> 62;
+fit_args(l_call_ext, [{e,{mnesia_lib,exists,1}}]) -> 61;
+fit_args(l_call_ext, [{e,{file,rename,2}}]) -> 67;
+fit_args(l_call_ext, [{e,{gb_trees,get,2}}]) -> 66;
+fit_args(l_call_ext, [{e,{asn1ct_gen,get_inner,1}}]) -> 65;
+fit_args(l_call_ext, [{e,{file,get_cwd,0}}]) -> 64;
+fit_args(l_call_ext, [{e,{lists,dropwhile,2}}]) -> 69;
+fit_args(l_call_ext, [{e,{lists,split,2}}]) -> 68;
+fit_args(l_call_ext, [{e,{mnesia_lib,cs_to_storage_type,2}}]) -> 73;
+fit_args(l_call_ext, [{e,{lists,splitwith,2}}]) -> 72;
+fit_args(l_call_ext, [{e,{test_server,fail,1}}]) -> 71;
+fit_args(l_call_ext, [{e,{unicode,characters_to_list,1}}]) -> 70;
+fit_args(l_call_ext, [{e,{sofs,relation,1}}]) -> 79;
+fit_args(l_call_ext, [{e,{mnesia_monitor,use_dir,0}}]) -> 78;
+fit_args(l_call_ext, [{e,{sets,is_element,2}}]) -> 77;
+fit_args(l_call_ext, [{e,{lists,sublist,3}}]) -> 76;
+fit_args(l_call_ext, [{e,{gb_trees,insert,3}}]) -> 75;
+fit_args(l_call_ext, [{e,{random,uniform,1}}]) -> 74;
+fit_args(l_call_ext, [{e,{mnesia_schema,list2cs,1}}]) -> 84;
+fit_args(l_call_ext, [{e,{gb_trees,from_orddict,1}}]) -> 83;
+fit_args(l_call_ext, [{e,{gb_trees,to_list,1}}]) -> 82;
+fit_args(l_call_ext, [{e,{gb_sets,empty,0}}]) -> 81;
+fit_args(l_call_ext, [{e,{dict,fetch,2}}]) -> 80;
+fit_args(l_call_ext, [{e,_}]) -> 85;
+fit_args(l_call_ext_last, [{e,_},1]) -> 0;
+fit_args(l_call_ext_last, [{e,_},0]) -> 1;
+fit_args(l_call_ext_last, [{e,_},2]) -> 2;
+fit_args(l_call_ext_last, [{e,_},3]) -> 3;
+fit_args(l_call_ext_last, [{e,_},4]) -> 4;
+fit_args(l_call_ext_last, [{e,_},5]) -> 5;
+fit_args(l_call_ext_last, [{e,_},_]) -> 6;
+fit_args(l_call_ext_only, [{e,{gen_server,call,3}}]) -> 0;
+fit_args(l_call_ext_only, [{e,{ssh_bits,encode,2}}]) -> 1;
+fit_args(l_call_ext_only, [{e,{io,format,3}}]) -> 2;
+fit_args(l_call_ext_only, [{e,{asn1ct_gen,emit,1}}]) -> 3;
+fit_args(l_call_ext_only, [{e,_}]) -> 4;
+fit_args(l_call_fun, [1]) -> 0;
+fit_args(l_call_fun, [2]) -> 1;
+fit_args(l_call_fun, [3]) -> 2;
+fit_args(l_call_fun, [0]) -> 3;
+fit_args(l_call_fun, [Arg0]) when Arg0 >= 0, Arg0 =< 255 -> 4;
+fit_args(l_call_fun_last, [Arg0,Arg1]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_call_fun_last, [Arg0,_]) when Arg0 >= 0, Arg0 =< 255 -> 1;
+fit_args(l_call_last, [{f,_},2]) -> 0;
+fit_args(l_call_last, [{f,_},0]) -> 1;
+fit_args(l_call_last, [{f,_},3]) -> 2;
+fit_args(l_call_last, [{f,_},1]) -> 3;
+fit_args(l_call_last, [{f,_},4]) -> 4;
+fit_args(l_call_last, [{f,_},6]) -> 6;
+fit_args(l_call_last, [{f,_},5]) -> 5;
+fit_args(l_call_last, [{f,_},7]) -> 7;
+fit_args(l_call_last, [{f,_},8]) -> 8;
+fit_args(l_call_last, [{f,_},9]) -> 9;
+fit_args(l_call_last, [{f,_},10]) -> 10;
+fit_args(l_call_last, [{f,_},_]) -> 11;
+fit_args(l_call_only, [{f,_}]) -> 0;
+fit_args(l_catch, [{y,0},_]) -> 0;
+fit_args(l_catch, [{y,1},_]) -> 1;
+fit_args(l_catch, [{y,2},_]) -> 2;
+fit_args(l_catch, [{y,3},_]) -> 3;
+fit_args(l_catch, [{y,4},_]) -> 4;
+fit_args(l_catch, [{y,5},_]) -> 5;
+fit_args(l_catch, [{y,6},_]) -> 6;
+fit_args(l_catch, [_,_]) -> 7;
+fit_args(l_element, [{x,0},{x,_},{x,_}]) -> 1;
+fit_args(l_element, [{x,_},{x,0},{x,_}]) -> 0;
+fit_args(l_element, [{x,_},{x,_},{x,_}]) -> 3;
+fit_args(l_element, [_,_,{x,0}]) -> 2;
+fit_args(l_element, [_,_,_]) -> 4;
+fit_args(l_fadd, [{fr,_},{fr,_},{fr,_}]) -> 0;
+fit_args(l_fast_element, [{x,0},2,{x,0}]) -> 0;
+fit_args(l_fast_element, [{x,_},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(l_fast_element, [_,Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_fast_element, [_,Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_fast_element, [_,_,_]) -> 4;
+fit_args(l_fcheckerror, []) -> 0;
+fit_args(l_fdiv, [{fr,_},{fr,_},{fr,_}]) -> 0;
+fit_args(l_fetch, [{i,Arg0},{x,_}]) when Arg0 >= -128, Arg0 =< 127 -> 5;
+fit_args(l_fetch, [{i,Arg0},{y,Arg1}]) when Arg0 >= -128, Arg0 =< 127, Arg1 >= 0, Arg1 =< 255 -> 10;
+fit_args(l_fetch, [{x,0},_]) -> 0;
+fit_args(l_fetch, [{x,1},_]) -> 9;
+fit_args(l_fetch, [{x,2},_]) -> 12;
+fit_args(l_fetch, [{x,4},_]) -> 13;
+fit_args(l_fetch, [{x,3},_]) -> 14;
+fit_args(l_fetch, [{x,5},_]) -> 15;
+fit_args(l_fetch, [{y,0},_]) -> 18;
+fit_args(l_fetch, [{x,_},{i,Arg1}]) when Arg1 >= -128, Arg1 =< 127 -> 3;
+fit_args(l_fetch, [{y,Arg0},{i,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= -128, Arg1 =< 127 -> 8;
+fit_args(l_fetch, [{x,_},{x,_}]) -> 2;
+fit_args(l_fetch, [{x,_},{y,Arg1}]) when Arg1 >= 0, Arg1 =< 255 -> 4;
+fit_args(l_fetch, [{y,Arg0},{y,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 6;
+fit_args(l_fetch, [{y,Arg0},{x,_}]) when Arg0 >= 0, Arg0 =< 255 -> 7;
+fit_args(l_fetch, [_,{x,0}]) -> 1;
+fit_args(l_fetch, [_,{x,1}]) -> 11;
+fit_args(l_fetch, [_,{x,4}]) -> 16;
+fit_args(l_fetch, [_,{x,2}]) -> 17;
+fit_args(l_fetch, [_,{x,3}]) -> 19;
+fit_args(l_fetch, [_,{x,5}]) -> 20;
+fit_args(l_fetch, [_,{y,0}]) -> 21;
+fit_args(l_fetch, [_,_]) -> 22;
+fit_args(l_fmul, [{fr,_},{fr,_},{fr,_}]) -> 0;
+fit_args(l_fnegate, [{fr,_},{fr,_}]) -> 0;
+fit_args(l_fsub, [{fr,_},{fr,_},{fr,_}]) -> 0;
+fit_args(l_gc_bif1, [{f,_},{b,{erlang,byte_size,1}},{x,_},Arg3,{x,0}]) when Arg3 >= 0, Arg3 =< 255 -> 2;
+fit_args(l_gc_bif1, [{f,_},{b,{erlang,length,1}},_,Arg3,{x,0}]) when Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_gc_bif1, [{f,_},{b,{erlang,length,1}},_,Arg3,{y,Arg4}]) when Arg3 >= 0, Arg3 =< 255, Arg4 >= 0, Arg4 =< 255 -> 4;
+fit_args(l_gc_bif1, [{f,_},{b,_},{x,0},1,{x,0}]) -> 3;
+fit_args(l_gc_bif1, [{f,_},{b,_},_,Arg3,{x,0}]) when Arg3 >= 0, Arg3 =< 255 -> 5;
+fit_args(l_gc_bif1, [{f,_},{b,_},_,Arg3,{x,_}]) when Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_gc_bif1, [{f,_},{b,_},_,Arg3,_]) when Arg3 >= 0, Arg3 =< 255 -> 6;
+fit_args(l_gc_bif2, [{f,_},{b,_},Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_gc_bif3, [{f,_},{b,_},_,Arg3,_]) when Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_get, [{a,asn1_module},{y,0}]) -> 0;
+fit_args(l_get, [_,{x,0}]) -> 1;
+fit_args(l_get, [_,{x,1}]) -> 2;
+fit_args(l_get, [_,{x,2}]) -> 3;
+fit_args(l_get, [_,_]) -> 4;
+fit_args(l_hibernate, []) -> 0;
+fit_args(l_increment, [{x,0},Arg1,Arg2,{x,_}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 5;
+fit_args(l_increment, [{x,0},_,Arg2,{x,0}]) when Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(l_increment, [{x,0},_,Arg2,{y,Arg3}]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 7;
+fit_args(l_increment, [{x,_},Arg1,Arg2,_]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_increment, [{y,Arg0},Arg1,Arg2,_]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_increment, [{x,_},_,Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 6;
+fit_args(l_increment, [_,4294967295,Arg2,{x,0}]) when Arg2 >= 0, Arg2 =< 255 -> 4;
+fit_args(l_increment, [_,4294967295,Arg2,{x,_}]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_increment, [_,_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 8;
+fit_args(l_int_bnot, [{f,_},_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_int_div, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_int_div, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_int_div, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_is_eq, [{f,_}]) -> 0;
+fit_args(l_is_eq_exact, [{f,_}]) -> 0;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,10},{a,ber}]) -> 23;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,1},_]) -> 0;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,0},_]) -> 1;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,3},_]) -> 2;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,2},_]) -> 3;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,4},_]) -> 5;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,5},_]) -> 6;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,6},_]) -> 7;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,7},_]) -> 8;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,8},_]) -> 9;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,9},_]) -> 10;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,255},_]) -> 11;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,10},_]) -> 12;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,11},_]) -> 13;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,1},_]) -> 14;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,12},_]) -> 15;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,0},_]) -> 16;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,13},_]) -> 17;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,3},_]) -> 18;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,2},_]) -> 19;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,4},_]) -> 20;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,14},_]) -> 21;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,5},_]) -> 22;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,16},_]) -> 24;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,15},_]) -> 25;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,17},_]) -> 26;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,18},_]) -> 28;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,19},_]) -> 29;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,6},_]) -> 30;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,22},_]) -> 31;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,7},_]) -> 32;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,20},_]) -> 33;
+fit_args(l_is_eq_exact_immed, [{f,_},{y,8},_]) -> 34;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,23},_]) -> 35;
+fit_args(l_is_eq_exact_immed, [{f,_},{x,_},{i,Arg2}]) when Arg2 >= -128, Arg2 =< 127 -> 4;
+fit_args(l_is_eq_exact_immed, [{f,_},_,{a,asn1_NOVALUE}]) -> 27;
+fit_args(l_is_eq_exact_immed, [{f,_},_,_]) -> 36;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,0},_]) -> 0;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,1},_]) -> 1;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,4},_]) -> 2;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,2},_]) -> 3;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,3},_]) -> 4;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,5},_]) -> 5;
+fit_args(l_is_eq_exact_literal, [{f,_},{x,6},_]) -> 6;
+fit_args(l_is_eq_exact_literal, [{f,_},_,_]) -> 7;
+fit_args(l_is_function2, [{f,_},{x,0},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_is_function2, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_is_function2, [{f,_},_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_is_ge, [{f,_}]) -> 0;
+fit_args(l_is_lt, [{f,_}]) -> 0;
+fit_args(l_is_ne, [{f,_}]) -> 0;
+fit_args(l_is_ne_exact, [{f,_}]) -> 0;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,0},_]) -> 0;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,1},_]) -> 1;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,2},_]) -> 2;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,3},_]) -> 3;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,4},_]) -> 5;
+fit_args(l_is_ne_exact_immed, [{f,_},{y,0},_]) -> 6;
+fit_args(l_is_ne_exact_immed, [{f,_},{y,2},_]) -> 8;
+fit_args(l_is_ne_exact_immed, [{f,_},{y,1},_]) -> 9;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,5},_]) -> 10;
+fit_args(l_is_ne_exact_immed, [{f,_},{x,_},{i,Arg2}]) when Arg2 >= -128, Arg2 =< 127 -> 7;
+fit_args(l_is_ne_exact_immed, [{f,_},_,{a,true}]) -> 4;
+fit_args(l_is_ne_exact_immed, [{f,_},_,_]) -> 11;
+fit_args(l_is_ne_exact_literal, [{f,_},_,_]) -> 0;
+fit_args(l_jump_on_val, [{x,0},{f,_},Arg2,Arg3]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_jump_on_val, [{x,_},{f,_},Arg2,Arg3]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_jump_on_val, [_,{f,_},_,_]) -> 2;
+fit_args(l_loop_rec, [{f,_}]) -> 0;
+fit_args(l_m_div, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_make_export, [{e,_}]) -> 0;
+fit_args(l_make_fun, [{fu,_}]) -> 0;
+fit_args(l_minus, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_minus, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_minus, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_move_call, [{x,2},{f,_}]) -> 0;
+fit_args(l_move_call, [{x,1},{f,_}]) -> 1;
+fit_args(l_move_call, [{y,2},{f,_}]) -> 2;
+fit_args(l_move_call, [{y,0},{f,_}]) -> 3;
+fit_args(l_move_call, [{y,1},{f,_}]) -> 4;
+fit_args(l_move_call, [{y,3},{f,_}]) -> 5;
+fit_args(l_move_call, [{x,3},{f,_}]) -> 6;
+fit_args(l_move_call, [{y,5},{f,_}]) -> 7;
+fit_args(l_move_call, [{y,4},{f,_}]) -> 8;
+fit_args(l_move_call, [{y,6},{f,_}]) -> 10;
+fit_args(l_move_call, [{x,4},{f,_}]) -> 11;
+fit_args(l_move_call, [{x,5},{f,_}]) -> 12;
+fit_args(l_move_call, [nil,{f,_}]) -> 13;
+fit_args(l_move_call, [{y,7},{f,_}]) -> 14;
+fit_args(l_move_call, [{a,foo},{f,_}]) -> 17;
+fit_args(l_move_call, [{x,6},{f,_}]) -> 18;
+fit_args(l_move_call, [{y,12},{f,_}]) -> 19;
+fit_args(l_move_call, [{a,endDocument},{f,_}]) -> 20;
+fit_args(l_move_call, [{a,ets},{f,_}]) -> 23;
+fit_args(l_move_call, [{a,schema},{f,_}]) -> 22;
+fit_args(l_move_call, [{y,8},{f,_}]) -> 24;
+fit_args(l_move_call, [{a,false},{f,_}]) -> 25;
+fit_args(l_move_call, [{smallint,1},{f,_}]) -> 9;
+fit_args(l_move_call, [{smallint,0},{f,_}]) -> 15;
+fit_args(l_move_call, [{smallint,2},{f,_}]) -> 16;
+fit_args(l_move_call, [{smallint,3},{f,_}]) -> 21;
+fit_args(l_move_call, [_,{f,_}]) -> 26;
+fit_args(l_move_call_ext, [{a,funky},{e,{estone_SUITE,req,2}}]) -> 32;
+fit_args(l_move_call_ext, [{a,auto_repair},{e,{mnesia_monitor,get_env,1}}]) -> 36;
+fit_args(l_move_call_ext, [{y,0},{e,_}]) -> 3;
+fit_args(l_move_call_ext, [{y,1},{e,_}]) -> 4;
+fit_args(l_move_call_ext, [{y,2},{e,_}]) -> 5;
+fit_args(l_move_call_ext, [{y,3},{e,_}]) -> 6;
+fit_args(l_move_call_ext, [{y,4},{e,_}]) -> 7;
+fit_args(l_move_call_ext, [{x,2},{e,_}]) -> 9;
+fit_args(l_move_call_ext, [{x,1},{e,_}]) -> 10;
+fit_args(l_move_call_ext, [{y,6},{e,_}]) -> 13;
+fit_args(l_move_call_ext, [{x,3},{e,_}]) -> 16;
+fit_args(l_move_call_ext, [{y,5},{e,_}]) -> 17;
+fit_args(l_move_call_ext, [nil,{e,_}]) -> 20;
+fit_args(l_move_call_ext, [{y,7},{e,_}]) -> 24;
+fit_args(l_move_call_ext, [{x,4},{e,_}]) -> 26;
+fit_args(l_move_call_ext, [{smallint,0},{e,{lists,seq,2}}]) -> 15;
+fit_args(l_move_call_ext, [{smallint,1},{e,_}]) -> 8;
+fit_args(l_move_call_ext, [_,{e,{re,split,3}}]) -> 0;
+fit_args(l_move_call_ext, [_,{e,{re,replace,4}}]) -> 1;
+fit_args(l_move_call_ext, [_,{e,{io,format,2}}]) -> 2;
+fit_args(l_move_call_ext, [_,{e,{io_lib,format,2}}]) -> 11;
+fit_args(l_move_call_ext, [_,{e,{asn1ct_gen,emit,1}}]) -> 12;
+fit_args(l_move_call_ext, [_,{e,{erlang,put,2}}]) -> 14;
+fit_args(l_move_call_ext, [_,{e,{prettypr,text,1}}]) -> 18;
+fit_args(l_move_call_ext, [_,{e,{proplists,get_value,3}}]) -> 19;
+fit_args(l_move_call_ext, [_,{e,{test_server,seconds,1}}]) -> 21;
+fit_args(l_move_call_ext, [_,{e,{asn1ct_name,new,1}}]) -> 22;
+fit_args(l_move_call_ext, [_,{e,{proplists,get_value,2}}]) -> 23;
+fit_args(l_move_call_ext, [_,{e,{mnesia_lib,verbose,2}}]) -> 25;
+fit_args(l_move_call_ext, [_,{e,{io,format,1}}]) -> 27;
+fit_args(l_move_call_ext, [_,{e,{lists,duplicate,2}}]) -> 28;
+fit_args(l_move_call_ext, [_,{e,{erlang,system_info,1}}]) -> 29;
+fit_args(l_move_call_ext, [_,{e,{erlang,erase,1}}]) -> 30;
+fit_args(l_move_call_ext, [_,{e,{lists,seq,2}}]) -> 31;
+fit_args(l_move_call_ext, [_,{e,{mnesia_lib,dbg_out,2}}]) -> 33;
+fit_args(l_move_call_ext, [_,{e,{erlang,binary_to_term,1}}]) -> 34;
+fit_args(l_move_call_ext, [_,{e,{test_server,lookup_config,2}}]) -> 35;
+fit_args(l_move_call_ext, [_,{e,{io,fwrite,2}}]) -> 37;
+fit_args(l_move_call_ext, [_,{e,_}]) -> 38;
+fit_args(l_move_call_ext_last, [{e,_},0,_]) -> 1;
+fit_args(l_move_call_ext_last, [{e,_},1,_]) -> 2;
+fit_args(l_move_call_ext_last, [{e,_},2,_]) -> 3;
+fit_args(l_move_call_ext_last, [{e,_},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_move_call_ext_last, [{e,_},_,_]) -> 4;
+fit_args(l_move_call_ext_only, [{e,{erlang,nif_error,1}},{a,undef}]) -> 2;
+fit_args(l_move_call_ext_only, [{e,{lists,reverse,1}},{x,_}]) -> 3;
+fit_args(l_move_call_ext_only, [{e,{erlang,get_module_info,1}},_]) -> 0;
+fit_args(l_move_call_ext_only, [{e,{io_lib,format,2}},_]) -> 1;
+fit_args(l_move_call_ext_only, [{e,{io,format,2}},_]) -> 5;
+fit_args(l_move_call_ext_only, [{e,_},{x,2}]) -> 4;
+fit_args(l_move_call_ext_only, [{e,_},{x,1}]) -> 6;
+fit_args(l_move_call_ext_only, [{e,_},_]) -> 7;
+fit_args(l_move_call_last, [{f,_},1,_]) -> 1;
+fit_args(l_move_call_last, [{f,_},2,_]) -> 3;
+fit_args(l_move_call_last, [{f,_},0,_]) -> 4;
+fit_args(l_move_call_last, [{f,_},3,_]) -> 5;
+fit_args(l_move_call_last, [{f,_},5,_]) -> 6;
+fit_args(l_move_call_last, [{f,_},4,_]) -> 7;
+fit_args(l_move_call_last, [{f,_},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_move_call_last, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_move_call_last, [{f,_},_,_]) -> 8;
+fit_args(l_move_call_only, [{f,_},{x,2}]) -> 0;
+fit_args(l_move_call_only, [{f,_},{x,1}]) -> 1;
+fit_args(l_move_call_only, [{f,_},{x,4}]) -> 2;
+fit_args(l_move_call_only, [{f,_},{x,3}]) -> 3;
+fit_args(l_move_call_only, [{f,_},{x,5}]) -> 4;
+fit_args(l_move_call_only, [{f,_},{x,6}]) -> 5;
+fit_args(l_move_call_only, [{f,_},{x,7}]) -> 6;
+fit_args(l_move_call_only, [{f,_},nil]) -> 7;
+fit_args(l_move_call_only, [{f,_},{x,8}]) -> 8;
+fit_args(l_move_call_only, [{f,_},{x,9}]) -> 10;
+fit_args(l_move_call_only, [{f,_},{x,10}]) -> 11;
+fit_args(l_move_call_only, [{f,_},{smallint,1}]) -> 9;
+fit_args(l_move_call_only, [{f,_},_]) -> 12;
+fit_args(l_new_bs_put_binary, [{f,_},_,Arg2,Arg3,_]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_new_bs_put_binary_all, [{f,_},_,8]) -> 0;
+fit_args(l_new_bs_put_binary_all, [{f,_},_,Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_new_bs_put_binary_imm, [{f,_},_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_new_bs_put_float, [{f,_},_,Arg2,Arg3,_]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(l_new_bs_put_float_imm, [{f,_},64,0,{x,0}]) -> 0;
+fit_args(l_new_bs_put_float_imm, [{f,_},_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_new_bs_put_integer, [{f,_},_,1,0,_]) -> 0;
+fit_args(l_new_bs_put_integer, [{f,_},_,Arg2,Arg3,_]) when Arg2 >= 0, Arg2 =< 255, Arg3 >= 0, Arg3 =< 255 -> 1;
+fit_args(l_new_bs_put_integer_imm, [{f,_},Arg1,Arg2,_]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_new_bs_put_integer_imm, [{f,_},_,0,{smallint,0}]) -> 1;
+fit_args(l_new_bs_put_integer_imm, [{f,_},_,Arg2,_]) when Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_plus, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_plus, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_plus, [{f,_},Arg1,{y,Arg2}]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 2;
+fit_args(l_plus, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 3;
+fit_args(l_put_tuple, [{x,0},2]) -> 1;
+fit_args(l_put_tuple, [{x,0},3]) -> 2;
+fit_args(l_put_tuple, [{x,0},4]) -> 3;
+fit_args(l_put_tuple, [{x,0},5]) -> 4;
+fit_args(l_put_tuple, [{x,0},Arg1]) when Arg1 >= 0, Arg1 =< 255 -> 5;
+fit_args(l_put_tuple, [{x,_},Arg1]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_put_tuple, [{y,Arg0},Arg1]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 6;
+fit_args(l_put_tuple, [_,_]) -> 7;
+fit_args(l_recv_set, []) -> 0;
+fit_args(l_rem, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_rem, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_rem, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_select_tuple_arity, [{x,0},{f,_},6]) -> 0;
+fit_args(l_select_tuple_arity, [{x,0},{f,_},8]) -> 2;
+fit_args(l_select_tuple_arity, [{x,0},{f,_},10]) -> 3;
+fit_args(l_select_tuple_arity, [{x,_},{f,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(l_select_tuple_arity, [_,{f,_},_]) -> 4;
+fit_args(l_select_tuple_arity2, [{x,0},{f,_},Arg2,{f,_},Arg4,{f,_}]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 0;
+fit_args(l_select_tuple_arity2, [{x,_},{f,_},Arg2,{f,_},Arg4,{f,_}]) when Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 1;
+fit_args(l_select_tuple_arity2, [{y,Arg0},{f,_},Arg2,{f,_},Arg4,{f,_}]) when Arg0 >= 0, Arg0 =< 255, Arg2 >= 0, Arg2 =< 255, Arg4 >= 0, Arg4 =< 255 -> 2;
+fit_args(l_select_tuple_arity2, [_,{f,_},_,{f,_},_,{f,_}]) -> 3;
+fit_args(l_select_val2, [{x,0},{f,_},{a,false},{f,_},{a,true},{f,_}]) -> 0;
+fit_args(l_select_val2, [{x,0},{f,_},{a,true},{f,_},{a,false},{f,_}]) -> 1;
+fit_args(l_select_val2, [{x,9},{f,_},{a,atom},{f,_},{a,var},{f,_}]) -> 13;
+fit_args(l_select_val2, [{x,1},{f,_},_,{f,_},_,{f,_}]) -> 3;
+fit_args(l_select_val2, [{x,0},{f,_},_,{f,_},_,{f,_}]) -> 4;
+fit_args(l_select_val2, [{x,2},{f,_},_,{f,_},_,{f,_}]) -> 6;
+fit_args(l_select_val2, [{x,3},{f,_},_,{f,_},_,{f,_}]) -> 7;
+fit_args(l_select_val2, [{x,4},{f,_},_,{f,_},_,{f,_}]) -> 9;
+fit_args(l_select_val2, [{x,5},{f,_},_,{f,_},_,{f,_}]) -> 10;
+fit_args(l_select_val2, [{x,6},{f,_},_,{f,_},_,{f,_}]) -> 11;
+fit_args(l_select_val2, [{x,7},{f,_},_,{f,_},_,{f,_}]) -> 12;
+fit_args(l_select_val2, [{x,8},{f,_},_,{f,_},_,{f,_}]) -> 14;
+fit_args(l_select_val2, [{y,1},{f,_},_,{f,_},_,{f,_}]) -> 15;
+fit_args(l_select_val2, [{x,_},{f,_},{i,Arg2},{f,_},{i,Arg4},{f,_}]) when Arg2 >= -128, Arg2 =< 127, Arg4 >= -128, Arg4 =< 127 -> 2;
+fit_args(l_select_val2, [_,{f,_},{a,true},{f,_},{a,false},{f,_}]) -> 5;
+fit_args(l_select_val2, [_,{f,_},{a,false},{f,_},{a,true},{f,_}]) -> 8;
+fit_args(l_select_val2, [_,{f,_},_,{f,_},_,{f,_}]) -> 16;
+fit_args(l_select_val_atoms, [{x,0},{f,_},_]) -> 1;
+fit_args(l_select_val_atoms, [{x,_},{f,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_select_val_atoms, [_,{f,_},_]) -> 2;
+fit_args(l_select_val_smallints, [{x,0},{f,_},_]) -> 1;
+fit_args(l_select_val_smallints, [{x,_},{f,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(l_select_val_smallints, [_,{f,_},_]) -> 2;
+fit_args(l_times, [{f,_},Arg1,{x,0}]) when Arg1 >= 0, Arg1 =< 255 -> 1;
+fit_args(l_times, [{f,_},Arg1,{x,_}]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(l_times, [{f,_},Arg1,_]) when Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(l_trim, [1]) -> 0;
+fit_args(l_trim, [2]) -> 1;
+fit_args(l_trim, [3]) -> 2;
+fit_args(l_trim, [4]) -> 3;
+fit_args(l_trim, [5]) -> 4;
+fit_args(l_trim, [6]) -> 5;
+fit_args(l_trim, [7]) -> 6;
+fit_args(l_trim, [8]) -> 7;
+fit_args(l_trim, [9]) -> 8;
+fit_args(l_trim, [11]) -> 9;
+fit_args(l_trim, [10]) -> 10;
+fit_args(l_trim, [_]) -> 11;
+fit_args(l_wait_timeout, [{f,_},1000]) -> 0;
+fit_args(l_wait_timeout, [{f,_},1]) -> 1;
+fit_args(l_wait_timeout, [{f,_},_]) -> 2;
+fit_args(l_yield, []) -> 0;
+fit_args(loop_rec_end, [{f,_}]) -> 0;
+fit_args(move, [{x,0},_]) -> 4;
+fit_args(move, [{x,_},{y,Arg1}]) when Arg1 >= 0, Arg1 =< 255 -> 3;
+fit_args(move, [{y,Arg0},{y,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 7;
+fit_args(move, [_,{x,1}]) -> 0;
+fit_args(move, [_,{x,0}]) -> 1;
+fit_args(move, [_,{x,2}]) -> 2;
+fit_args(move, [_,{x,3}]) -> 5;
+fit_args(move, [_,{x,4}]) -> 6;
+fit_args(move, [_,{x,5}]) -> 8;
+fit_args(move, [_,{x,6}]) -> 9;
+fit_args(move, [_,{x,7}]) -> 10;
+fit_args(move, [_,{x,8}]) -> 11;
+fit_args(move, [_,{x,10}]) -> 12;
+fit_args(move, [_,{x,9}]) -> 13;
+fit_args(move, [_,_]) -> 14;
+fit_args(move2, [{x,0},{x,_},{x,0},{x,_}]) -> 9;
+fit_args(move2, [{x,0},{x,_},{x,_},{x,0}]) -> 6;
+fit_args(move2, [{x,0},{y,Arg1},{x,_},{y,Arg3}]) when Arg1 >= 0, Arg1 =< 255, Arg3 >= 0, Arg3 =< 255 -> 4;
+fit_args(move2, [{x,0},{x,_},{x,_},{x,_}]) -> 8;
+fit_args(move2, [{x,_},{x,0},{x,_},{x,_}]) -> 5;
+fit_args(move2, [{x,_},{y,Arg1},{x,0},{y,Arg3}]) when Arg1 >= 0, Arg1 =< 255, Arg3 >= 0, Arg3 =< 255 -> 3;
+fit_args(move2, [{x,_},{x,_},{x,0},{x,_}]) -> 7;
+fit_args(move2, [{x,_},{y,Arg1},{x,_},{y,Arg3}]) when Arg1 >= 0, Arg1 =< 255, Arg3 >= 0, Arg3 =< 255 -> 0;
+fit_args(move2, [{y,Arg0},{x,_},{y,Arg2},_]) when Arg0 >= 0, Arg0 =< 255, Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(move2, [{x,_},{x,_},{x,_},_]) -> 2;
+fit_args(move2, [_,_,_,_]) -> 10;
+fit_args(move_deallocate_return, [{a,ok},_]) -> 1;
+fit_args(move_deallocate_return, [{x,_},Arg1]) when Arg1 >= 0, Arg1 =< 255 -> 0;
+fit_args(move_deallocate_return, [{y,Arg0},Arg1]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(move_deallocate_return, [_,0]) -> 3;
+fit_args(move_deallocate_return, [_,1]) -> 4;
+fit_args(move_deallocate_return, [_,2]) -> 5;
+fit_args(move_deallocate_return, [_,3]) -> 6;
+fit_args(move_deallocate_return, [_,4]) -> 7;
+fit_args(move_deallocate_return, [_,5]) -> 8;
+fit_args(move_deallocate_return, [_,_]) -> 9;
+fit_args(move_jump, [{f,_},{x,1}]) -> 0;
+fit_args(move_jump, [{f,_},{x,2}]) -> 1;
+fit_args(move_jump, [{f,_},nil]) -> 2;
+fit_args(move_jump, [{f,_},{x,4}]) -> 3;
+fit_args(move_jump, [{f,_},{y,2}]) -> 4;
+fit_args(move_jump, [{f,_},{y,1}]) -> 5;
+fit_args(move_jump, [{f,_},{x,3}]) -> 6;
+fit_args(move_jump, [{f,_},{y,0}]) -> 7;
+fit_args(move_jump, [{f,_},{y,3}]) -> 8;
+fit_args(move_jump, [{f,_},{a,true}]) -> 9;
+fit_args(move_jump, [{f,_},{a,false}]) -> 10;
+fit_args(move_jump, [{f,_},{a,asn1_NOVALUE}]) -> 11;
+fit_args(move_jump, [{f,_},{y,4}]) -> 12;
+fit_args(move_jump, [{f,_},{smallint,0}]) -> 13;
+fit_args(move_jump, [{f,_},_]) -> 14;
+fit_args(move_return, [{a,true}]) -> 0;
+fit_args(move_return, [{x,1}]) -> 1;
+fit_args(move_return, [{x,2}]) -> 2;
+fit_args(move_return, [nil]) -> 3;
+fit_args(move_return, [{a,false}]) -> 4;
+fit_args(move_return, [{a,ok}]) -> 5;
+fit_args(move_return, [{x,3}]) -> 6;
+fit_args(move_return, [{x,4}]) -> 7;
+fit_args(move_return, [{a,undefined}]) -> 11;
+fit_args(move_return, [{x,5}]) -> 12;
+fit_args(move_return, [{a,error}]) -> 13;
+fit_args(move_return, [{a,none}]) -> 16;
+fit_args(move_return, [{a,no}]) -> 15;
+fit_args(move_return, [{a,nomatch}]) -> 19;
+fit_args(move_return, [{a,ignore}]) -> 20;
+fit_args(move_return, [{x,6}]) -> 22;
+fit_args(move_return, [{smallint,1}]) -> 8;
+fit_args(move_return, [{smallint,0}]) -> 9;
+fit_args(move_return, [{smallint,2}]) -> 10;
+fit_args(move_return, [{smallint,3}]) -> 14;
+fit_args(move_return, [{smallint,4}]) -> 17;
+fit_args(move_return, [{smallint,8}]) -> 18;
+fit_args(move_return, [{smallint,16}]) -> 21;
+fit_args(move_return, [{smallint,5}]) -> 24;
+fit_args(move_return, [{smallint,64}]) -> 23;
+fit_args(move_return, [_]) -> 25;
+fit_args(node, [{x,0}]) -> 0;
+fit_args(node, [{x,1}]) -> 1;
+fit_args(node, [{x,2}]) -> 2;
+fit_args(node, [{x,3}]) -> 3;
+fit_args(node, [_]) -> 4;
+fit_args(on_load, []) -> 0;
+fit_args(put_list, [{x,0},{x,3},{x,8}]) -> 12;
+fit_args(put_list, [{x,0},_,{y,0}]) -> 8;
+fit_args(put_list, [{x,_},nil,{x,_}]) -> 6;
+fit_args(put_list, [{x,_},{x,_},{x,_}]) -> 2;
+fit_args(put_list, [{x,_},_,{y,Arg2}]) when Arg2 >= 0, Arg2 =< 255 -> 11;
+fit_args(put_list, [_,{x,0},_]) -> 9;
+fit_args(put_list, [_,nil,_]) -> 13;
+fit_args(put_list, [_,_,{x,0}]) -> 0;
+fit_args(put_list, [_,_,{x,1}]) -> 1;
+fit_args(put_list, [_,_,{x,2}]) -> 3;
+fit_args(put_list, [_,_,{x,3}]) -> 4;
+fit_args(put_list, [_,_,{x,4}]) -> 5;
+fit_args(put_list, [_,_,{x,5}]) -> 7;
+fit_args(put_list, [_,_,{x,6}]) -> 10;
+fit_args(put_list, [_,_,_]) -> 14;
+fit_args(raise, [{x,2},{x,1}]) -> 0;
+fit_args(raise, [_,_]) -> 1;
+fit_args(recv_mark, [{f,_}]) -> 0;
+fit_args(remove_message, []) -> 0;
+fit_args(return, []) -> 0;
+fit_args(self, [{x,0}]) -> 0;
+fit_args(self, [{x,1}]) -> 1;
+fit_args(self, [{x,2}]) -> 2;
+fit_args(self, [{x,3}]) -> 3;
+fit_args(self, [{y,0}]) -> 4;
+fit_args(self, [_]) -> 5;
+fit_args(send, []) -> 0;
+fit_args(set_tuple_element, [{y,Arg0},{x,0},Arg2]) when Arg0 >= 0, Arg0 =< 255, Arg2 >= 0, Arg2 =< 255 -> 0;
+fit_args(set_tuple_element, [_,{x,0},_]) -> 1;
+fit_args(set_tuple_element, [_,_,_]) -> 2;
+fit_args(system_limit, [{f,_}]) -> 0;
+fit_args(test_arity, [{f,_},{x,0},2]) -> 0;
+fit_args(test_arity, [{f,_},{x,0},_]) -> 2;
+fit_args(test_arity, [{f,_},{x,_},Arg2]) when Arg2 >= 0, Arg2 =< 255 -> 1;
+fit_args(test_arity, [{f,_},{y,Arg1},Arg2]) when Arg1 >= 0, Arg1 =< 255, Arg2 >= 0, Arg2 =< 255 -> 3;
+fit_args(test_arity, [{f,_},_,_]) -> 4;
+fit_args(test_heap, [HeapNeeded,Live]) when HeapNeeded >= 0, HeapNeeded =< 255, Live >= 0, Live =< 255 -> 0;
+fit_args(test_heap, [_,Live]) when Live >= 0, Live =< 255 -> 1;
+fit_args(test_heap_1_put_list, [2,{y,0}]) -> 0;
+fit_args(test_heap_1_put_list, [2,_]) -> 1;
+fit_args(test_heap_1_put_list, [Arg0,{i,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= -128, Arg1 =< 127 -> 3;
+fit_args(test_heap_1_put_list, [Arg0,{y,Arg1}]) when Arg0 >= 0, Arg0 =< 255, Arg1 >= 0, Arg1 =< 255 -> 2;
+fit_args(test_heap_1_put_list, [_,_]) -> 4;
+fit_args(timeout, []) -> 0;
+fit_args(try_case_end, [{x,0}]) -> 0;
+fit_args(try_case_end, [_]) -> 1;
+fit_args(try_end, [{y,0}]) -> 0;
+fit_args(try_end, [{y,1}]) -> 1;
+fit_args(try_end, [{y,2}]) -> 2;
+fit_args(try_end, [{y,4}]) -> 3;
+fit_args(try_end, [{y,3}]) -> 5;
+fit_args(try_end, [{y,5}]) -> 4;
+fit_args(try_end, [{y,6}]) -> 6;
+fit_args(try_end, [_]) -> 7;
+fit_args(wait, [{f,_}]) -> 0;
+fit_args(wait_timeout, [{f,_},_]) -> 0;
+fit_args(Op, As) -> erlang:error({nofit,Op,As}).
+
+var_args(move, 0) -> [t,{x,1}];
+var_args(move, 1) -> [t,{x,0}];
+var_args(l_call, 0) -> [f];
+var_args(test_heap, 0) -> [u8,u8];
+var_args(move, 2) -> [t,{x,2}];
+var_args(badmatch, 0) -> [{x,0}];
+var_args(move, 3) -> [x8,y8];
+var_args(l_put_tuple, 0) -> [x8,u8];
+var_args(move, 4) -> [{x,0},t];
+var_args(move2, 1) -> [y8,x8,y8,t];
+var_args(get_tuple_element, 0) -> [{x,0},u8,x8];
+var_args(move2, 0) -> [x8,y8,x8,y8];
+var_args(put_list, 0) -> [t,t,{x,0}];
+var_args(is_tuple_of_arity, 1) -> [f,x8,u8];
+var_args(get_tuple_element, 1) -> [x8,u8,x8];
+var_args(l_call_only, 0) -> [f];
+var_args(call_bif, 7) -> [{b,{erlang,iolist_to_binary,1}}];
+var_args(l_bs_start_match2, 0) -> [{x,0},f,{u8,1},{u,0},{x,1}];
+var_args(l_bs_test_zero_tail2, 0) -> [f,{x,1}];
+var_args(l_bs_match_string, 0) -> [{x,1},f,u32,str];
+var_args(l_is_eq_exact_immed, 0) -> [f,{x,1},t];
+var_args(put_list, 1) -> [t,t,{x,1}];
+var_args(is_tuple_of_arity, 0) -> [f,{x,0},{u,2}];
+var_args(l_is_eq_exact_immed, 1) -> [f,{x,0},t];
+var_args(get_list, 0) -> [x8,x8,x8];
+var_args(l_put_tuple, 1) -> [{x,0},{u,2}];
+var_args(move, 5) -> [t,{x,3}];
+var_args(l_call_ext, 85) -> [e];
+var_args(l_move_call_ext, 0) -> [t,{e,{re,split,3}}];
+var_args(return, 0) -> [];
+var_args(move2, 2) -> [x8,x8,x8,t];
+var_args(l_is_ge, 0) -> [f];
+var_args(l_move_call_last, 0) -> [f,u8,y8];
+var_args(l_make_fun, 0) -> [fu];
+var_args(is_tuple_of_arity, 2) -> [f,{x,0},u32];
+var_args(extract_next_element2, 0) -> [{x,1}];
+var_args(move_deallocate_return, 0) -> [x8,u8];
+var_args(call_bif, 3) -> [{b,{erlang,error,1}}];
+var_args(l_allocate, 0) -> [{u,1}];
+var_args(l_fetch, 0) -> [{x,0},t];
+var_args(l_trim, 0) -> [{u,1}];
+var_args(is_nil, 0) -> [f,{x,0}];
+var_args(is_nonempty_list, 0) -> [f,{x,0}];
+var_args(move_return, 25) -> [t];
+var_args(l_move_call_ext, 1) -> [t,{e,{re,replace,4}}];
+var_args(deallocate_return, 0) -> [{u,1}];
+var_args(case_end, 0) -> [{x,0}];
+var_args(get_list, 1) -> [{x,0},x8,x8];
+var_args(l_allocate, 1) -> [{u,0}];
+var_args(l_fetch, 1) -> [t,{x,0}];
+var_args(jump, 0) -> [f];
+var_args(extract_next_element, 0) -> [{x,1}];
+var_args(put_list, 3) -> [t,t,{x,2}];
+var_args(l_is_eq_exact_immed, 2) -> [f,{x,3},t];
+var_args(move2, 3) -> [x8,y8,{x,0},y8];
+var_args(l_fetch, 2) -> [x8,x8];
+var_args(l_is_eq_exact, 0) -> [f];
+var_args(call_bif, 8) -> [{b,{erlang,setelement,3}}];
+var_args(l_allocate, 2) -> [{u,2}];
+var_args(l_is_eq_exact_immed, 3) -> [f,{x,2},t];
+var_args(get_tuple_element, 2) -> [t,{u,0},{x,0}];
+var_args(l_move_call, 26) -> [t,f];
+var_args(deallocate_return, 1) -> [{u,0}];
+var_args(move_return, 0) -> [{a,true}];
+var_args(init2, 0) -> [y8,y8];
+var_args(get_tuple_element, 3) -> [{x,0},u8,y8];
+var_args(put_list, 2) -> [x8,x8,x8];
+var_args(init, 0) -> [{y,1}];
+var_args(move2, 4) -> [{x,0},y8,x8,y8];
+var_args(l_is_eq_exact_immed, 4) -> [f,x8,i8];
+var_args(call_bif, 9) -> [{b,{erlang,'++',2}}];
+var_args(l_fetch, 3) -> [x8,i8];
+var_args(deallocate_return, 2) -> [{u,2}];
+var_args(extract_next_element, 1) -> [{x,3}];
+var_args(is_nonempty_list, 1) -> [f,{x,2}];
+var_args(put_list, 4) -> [t,t,{x,3}];
+var_args(l_put_tuple, 2) -> [{x,0},{u,3}];
+var_args(l_allocate, 3) -> [{u,3}];
+var_args(is_tuple_of_arity, 3) -> [f,y8,u8];
+var_args(move2, 5) -> [x8,{x,0},x8,x8];
+var_args(init, 1) -> [{y,0}];
+var_args(get_tuple_element, 4) -> [y8,u8,x8];
+var_args(l_fetch, 4) -> [x8,y8];
+var_args(init3, 0) -> [y8,y8,y8];
+var_args(get_list, 2) -> [x8,{x,0},x8];
+var_args(l_move_call_ext, 38) -> [t,e];
+var_args(allocate_init, 0) -> [u32,{y,0}];
+var_args(l_is_eq_exact_immed, 5) -> [f,{x,4},t];
+var_args(l_trim, 1) -> [{u,2}];
+var_args(test_heap_1_put_list, 0) -> [{u,2},{y,0}];
+var_args(l_is_lt, 0) -> [f];
+var_args(l_is_eq_exact_literal, 0) -> [f,{x,0},t];
+var_args(call_bif, 6) -> [{b,{erlang,throw,1}}];
+var_args(call_bif, 45) -> [b];
+var_args(l_allocate_zero, 0) -> [{u,2}];
+var_args(allocate_heap, 0) -> [u8,u8,u8];
+var_args(is_tuple, 0) -> [f,{x,0}];
+var_args(move_return, 1) -> [{x,1}];
+var_args(is_nonempty_list, 2) -> [f,{x,1}];
+var_args(l_allocate_zero, 1) -> [{u,1}];
+var_args(move, 6) -> [t,{x,4}];
+var_args(l_call_last, 0) -> [f,{u,2}];
+var_args(init, 2) -> [{y,2}];
+var_args(l_gc_bif1, 0) -> [f,b,t,u8,x8];
+var_args(deallocate_return, 3) -> [{u,3}];
+var_args(get_tuple_element, 5) -> [x8,u8,y8];
+var_args(l_increment, 0) -> [x8,u8,u8,t];
+var_args(call_bif, 2) -> [{b,{erlang,error,2}}];
+var_args(is_nonempty_list_allocate, 0) -> [f,{x,0},u32];
+var_args(l_select_val_atoms, 0) -> [x8,f,u8];
+var_args(l_move_call, 0) -> [{x,2},f];
+var_args(l_is_eq_exact_immed, 6) -> [f,{x,5},t];
+var_args(call_bif, 5) -> [{b,{erlang,exit,1}}];
+var_args(move_deallocate_return, 1) -> [{a,ok},u32];
+var_args(is_nonempty_list, 3) -> [f,{x,3}];
+var_args(extract_next_element, 2) -> [{x,2}];
+var_args(is_list, 0) -> [f,{x,0}];
+var_args(l_select_val2, 3) -> [{x,1},f,t,f,t,f];
+var_args(l_fetch, 5) -> [i8,x8];
+var_args(extract_next_element3, 0) -> [{x,1}];
+var_args(is_nil, 1) -> [f,{x,2}];
+var_args(move_deallocate_return, 2) -> [y8,u8];
+var_args(l_call_last, 1) -> [f,{u,0}];
+var_args(l_trim, 2) -> [{u,3}];
+var_args(l_call_last, 2) -> [f,{u,3}];
+var_args(get_list, 3) -> [{x,0},{x,0},t];
+var_args(l_select_val2, 0) -> [{x,0},f,{a,false},f,{a,true},f];
+var_args(l_move_call_only, 12) -> [f,t];
+var_args(is_nil, 2) -> [f,{x,1}];
+var_args(move2, 6) -> [{x,0},x8,x8,{x,0}];
+var_args(l_allocate, 4) -> [{u,4}];
+var_args(l_move_call_only, 0) -> [f,{x,2}];
+var_args(extract_next_element2, 1) -> [{x,3}];
+var_args(move_return, 2) -> [{x,2}];
+var_args(test_arity, 0) -> [f,{x,0},{u,2}];
+var_args(move2, 7) -> [x8,x8,{x,0},x8];
+var_args(l_call_ext, 0) -> [{e,{lists,reverse,1}}];
+var_args(l_new_bs_put_integer_imm, 0) -> [f,u8,u8,t];
+var_args(l_select_val2, 4) -> [{x,0},f,t,f,t,f];
+var_args(l_move_call_only, 1) -> [f,{x,1}];
+var_args(l_select_val2, 1) -> [{x,0},f,{a,true},f,{a,false},f];
+var_args(remove_message, 0) -> [];
+var_args(init, 3) -> [{y,3}];
+var_args(l_allocate_zero, 2) -> [{u,3}];
+var_args(l_plus, 0) -> [f,u8,x8];
+var_args(l_catch, 0) -> [{y,0},t];
+var_args(deallocate_return, 4) -> [{u,4}];
+var_args(is_nonempty_list, 4) -> [f,{x,7}];
+var_args(bif1_body, 0) -> [{b,{erlang,hd,1}},t,{x,0}];
+var_args(l_put_tuple, 3) -> [{x,0},{u,4}];
+var_args(extract_next_element, 3) -> [{x,4}];
+var_args(l_is_eq_exact_immed, 7) -> [f,{x,6},t];
+var_args(move_jump, 14) -> [f,t];
+var_args(move, 7) -> [y8,y8];
+var_args(l_allocate_zero, 3) -> [{u,4}];
+var_args(l_move_call_only, 2) -> [f,{x,4}];
+var_args(l_select_tuple_arity2, 0) -> [{x,0},f,u8,f,u8,f];
+var_args(l_bs_start_match2, 1) -> [t,f,u8,u8,x8];
+var_args(catch_end, 0) -> [{y,0}];
+var_args(move_return, 3) -> [nil];
+var_args(is_nonempty_list, 5) -> [f,{x,4}];
+var_args(l_is_eq_exact_immed, 8) -> [f,{x,7},t];
+var_args(l_call_last, 3) -> [f,{u,1}];
+var_args(l_move_call_only, 3) -> [f,{x,3}];
+var_args(l_call_last, 4) -> [f,{u,4}];
+var_args(get_list, 4) -> [t,x8,y8];
+var_args(move_return, 4) -> [{a,false}];
+var_args(move, 8) -> [t,{x,5}];
+var_args(test_arity, 1) -> [f,x8,u8];
+var_args(move_return, 5) -> [{a,ok}];
+var_args(is_nonempty_list, 6) -> [f,{x,5}];
+var_args(l_call_fun, 0) -> [{u8,1}];
+var_args(l_increment, 1) -> [y8,u8,u8,t];
+var_args(put_list, 5) -> [t,t,{x,4}];
+var_args(init, 4) -> [{y,4}];
+var_args(l_is_eq, 0) -> [f];
+var_args(l_select_val2, 2) -> [x8,f,i8,f,i8,f];
+var_args(l_move_call_ext, 2) -> [t,{e,{io,format,2}}];
+var_args(l_call_ext_only, 4) -> [e];
+var_args(l_bs_get_binary_all_reuse, 0) -> [t,f,{u8,8}];
+var_args(send, 0) -> [];
+var_args(set_tuple_element, 0) -> [y8,{x,0},u8];
+var_args(bif2_body, 0) -> [b,{x,0}];
+var_args(extract_next_element2, 2) -> [{x,2}];
+var_args(l_move_call, 1) -> [{x,1},f];
+var_args(l_catch, 1) -> [{y,1},t];
+var_args(is_nil, 3) -> [f,{x,4}];
+var_args(move_deallocate_return, 3) -> [t,{u,0}];
+var_args(call_bif, 10) -> [{b,{lists,member,2}}];
+var_args(extract_next_element2, 3) -> [{x,4}];
+var_args(badmatch, 1) -> [{x,3}];
+var_args(is_nonempty_list, 7) -> [f,{x,6}];
+var_args(l_increment, 2) -> [t,{u,4294967295},u8,x8];
+var_args(l_is_eq_exact_immed, 9) -> [f,{x,8},t];
+var_args(case_end, 1) -> [{x,1}];
+var_args(extract_next_element, 4) -> [{x,5}];
+var_args(l_trim, 3) -> [{u,4}];
+var_args(l_move_call_ext_last, 0) -> [e,u8,y8];
+var_args(is_nonempty_list, 8) -> [f,{x,9}];
+var_args(l_move_call_last, 1) -> [f,{u,1},t];
+var_args(badmatch, 2) -> [{x,2}];
+var_args(deallocate_return, 5) -> [{u,5}];
+var_args(l_fetch, 6) -> [y8,y8];
+var_args(l_select_val_atoms, 1) -> [{x,0},f,u32];
+var_args(l_bs_add, 0) -> [f,{u8,1},t];
+var_args(l_allocate, 5) -> [{u,5}];
+var_args(l_select_val_smallints, 0) -> [x8,f,u8];
+var_args(l_move_call, 2) -> [{y,2},f];
+var_args(l_select_tuple_arity2, 1) -> [x8,f,u8,f,u8,f];
+var_args(is_nonempty_list, 9) -> [f,{x,8}];
+var_args(l_bs_test_zero_tail2, 1) -> [f,{x,2}];
+var_args(l_loop_rec, 0) -> [f];
+var_args(l_move_call_ext, 3) -> [{y,0},e];
+var_args(is_nil, 4) -> [f,{x,3}];
+var_args(l_is_ne_exact_immed, 0) -> [f,{x,0},t];
+var_args(l_increment, 3) -> [{x,0},u32,u8,{x,0}];
+var_args(l_is_ne, 0) -> [f];
+var_args(l_move_call, 3) -> [{y,0},f];
+var_args(l_plus, 1) -> [f,u8,{x,0}];
+var_args(catch_end, 1) -> [{y,1}];
+var_args(l_move_call, 4) -> [{y,1},f];
+var_args(init, 5) -> [{y,5}];
+var_args(l_call_last, 6) -> [f,{u,6}];
+var_args(l_call_last, 5) -> [f,{u,5}];
+var_args(l_minus, 0) -> [f,u8,x8];
+var_args(l_move_call_ext, 4) -> [{y,1},e];
+var_args(l_bs_match_string, 1) -> [t,f,{u,8},str];
+var_args(l_allocate_zero, 4) -> [{u,6}];
+var_args(extract_next_element, 5) -> [{x,6}];
+var_args(l_select_val2, 6) -> [{x,2},f,t,f,t,f];
+var_args(l_bs_init_heap_bin, 0) -> [u8,u8,u8,t];
+var_args(l_allocate_zero, 5) -> [{u,5}];
+var_args(l_bs_start_match2, 2) -> [{x,0},f,u8,u8,{x,0}];
+var_args(l_fetch, 7) -> [y8,x8];
+var_args(l_call_ext_last, 0) -> [e,{u,1}];
+var_args(is_nonempty_list_allocate, 1) -> [f,x8,u8];
+var_args(l_bs_restore2, 0) -> [x8,u8];
+var_args(loop_rec_end, 0) -> [f];
+var_args(call_bif, 11) -> [{b,{ets,insert,2}}];
+var_args(l_bs_get_utf16, 0) -> [x8,f,u8,x8];
+var_args(l_fast_element, 1) -> [t,u8,x8];
+var_args(l_gc_bif1, 1) -> [f,{b,{erlang,length,1}},t,u8,{x,0}];
+var_args(l_trim, 4) -> [{u,5}];
+var_args(move, 9) -> [t,{x,6}];
+var_args(wait, 0) -> [f];
+var_args(l_is_eq_exact_immed, 10) -> [f,{x,9},t];
+var_args(extract_next_element2, 4) -> [{x,5}];
+var_args(is_atom, 0) -> [f,{x,0}];
+var_args(call_bif, 12) -> [{b,{erlang,get_module_info,2}}];
+var_args(int_code_end, 0) -> [];
+var_args(l_call_fun_last, 0) -> [u8,u8];
+var_args(l_move_call_ext_only, 0) -> [{e,{erlang,get_module_info,1}},t];
+var_args(get_tuple_element, 6) -> [{x,0},{u,1},{x,0}];
+var_args(move_deallocate_return, 4) -> [t,{u,1}];
+var_args(bs_context_to_binary, 0) -> [{x,0}];
+var_args(init, 6) -> [{y,6}];
+var_args(l_move_call_ext, 5) -> [{y,2},e];
+var_args(extract_next_element, 6) -> [{x,255}];
+var_args(self, 0) -> [{x,0}];
+var_args(is_nil, 5) -> [f,{x,5}];
+var_args(l_move_call_ext, 6) -> [{y,3},e];
+var_args(l_call_ext_last, 1) -> [e,{u,0}];
+var_args(l_call_fun, 1) -> [{u8,2}];
+var_args(l_is_eq_exact_immed, 11) -> [f,{x,255},t];
+var_args(l_move_call, 5) -> [{y,3},f];
+var_args(l_is_ne_exact_immed, 1) -> [f,{x,1},t];
+var_args(is_tuple, 1) -> [f,{x,1}];
+var_args(extract_next_element, 7) -> [{x,7}];
+var_args(l_move_call_last, 2) -> [f,u8,x8];
+var_args(l_times, 0) -> [f,u8,x8];
+var_args(l_bs_test_unit_8, 0) -> [f,{x,0}];
+var_args(l_allocate, 6) -> [{u,6}];
+var_args(badmatch, 3) -> [{x,1}];
+var_args(l_move_call_ext_only, 1) -> [{e,{io_lib,format,2}},t];
+var_args(l_bs_test_zero_tail2, 2) -> [f,{x,0}];
+var_args(l_move_call_ext, 7) -> [{y,4},e];
+var_args(l_move_call_ext, 8) -> [{smallint,1},e];
+var_args(move_return, 6) -> [{x,3}];
+var_args(l_put_tuple, 4) -> [{x,0},{u,5}];
+var_args(call_bif, 13) -> [{b,{erlang,binary_to_list,1}}];
+var_args(l_catch, 2) -> [{y,2},t];
+var_args(bif1_body, 1) -> [b,{x,0},t];
+var_args(l_select_val_smallints, 1) -> [{x,0},f,u32];
+var_args(raise, 0) -> [{x,2},{x,1}];
+var_args(call_bif, 14) -> [{b,{erlang,list_to_binary,1}}];
+var_args(is_nil, 6) -> [f,{x,6}];
+var_args(l_move_call, 6) -> [{x,3},f];
+var_args(l_move_call_ext, 9) -> [{x,2},e];
+var_args(l_select_val2, 7) -> [{x,3},f,t,f,t,f];
+var_args(is_integer, 0) -> [f,{x,0}];
+var_args(extract_next_element3, 1) -> [{x,3}];
+var_args(l_minus, 1) -> [f,u8,{x,0}];
+var_args(is_nonempty_list, 10) -> [f,{x,10}];
+var_args(call_bif, 15) -> [{b,{ets,delete,1}}];
+var_args(l_bs_save2, 0) -> [x8,u8];
+var_args(l_call_ext_last, 2) -> [e,{u,2}];
+var_args(extract_next_element, 8) -> [{y,1}];
+var_args(l_call_ext, 1) -> [{e,{asn1ct_gen,emit,1}}];
+var_args(l_new_bs_put_binary_all, 0) -> [f,t,{u8,8}];
+var_args(l_move_call_ext_only, 7) -> [e,t];
+var_args(is_nil, 7) -> [f,{x,7}];
+var_args(deallocate_return, 6) -> [{u,6}];
+var_args(l_move_call_only, 4) -> [f,{x,5}];
+var_args(self, 1) -> [{x,1}];
+var_args(l_call_ext, 2) -> [{e,{file,close,1}}];
+var_args(l_select_val2, 5) -> [t,f,{a,true},f,{a,false},f];
+var_args(case_end, 2) -> [{x,2}];
+var_args(allocate_heap_zero, 0) -> [u8,u8,u8];
+var_args(call_bif, 16) -> [{b,{lists,keysearch,3}}];
+var_args(is_nonempty_list, 11) -> [f,{x,11}];
+var_args(extract_next_element2, 5) -> [{x,6}];
+var_args(apply, 0) -> [u8];
+var_args(try_end, 0) -> [{y,0}];
+var_args(l_move_call, 7) -> [{y,5},f];
+var_args(call_bif, 17) -> [{b,{ets,lookup,2}}];
+var_args(l_fast_element, 0) -> [{x,0},{u,2},{x,0}];
+var_args(test_heap_1_put_list, 1) -> [{u,2},t];
+var_args(call_bif, 19) -> [{b,{erlang,integer_to_list,1}}];
+var_args(call_bif, 18) -> [{b,{lists,reverse,2}}];
+var_args(call_bif, 20) -> [{b,{erlang,atom_to_list,1}}];
+var_args(l_bs_test_zero_tail2, 3) -> [f,{x,3}];
+var_args(l_move_call_ext, 10) -> [{x,1},e];
+var_args(is_nil, 8) -> [f,{x,8}];
+var_args(get_tuple_element, 7) -> [x8,u8,{x,0}];
+var_args(call_bif, 21) -> [{b,{erlang,list_to_atom,1}}];
+var_args(l_call_ext, 3) -> [{e,{lists,foreach,2}}];
+var_args(catch_end, 2) -> [{y,2}];
+var_args(l_put_tuple, 5) -> [{x,0},u8];
+var_args(is_list, 1) -> [f,{x,1}];
+var_args(extract_next_element3, 2) -> [{x,2}];
+var_args(get_list, 7) -> [t,{x,0},t];
+var_args(l_bif2, 0) -> [f,{b,{erlang,element,2}},t];
+var_args(call_bif, 22) -> [{b,{ets,info,2}}];
+var_args(init, 7) -> [{y,7}];
+var_args(try_end, 1) -> [{y,1}];
+var_args(l_bs_get_integer_32, 0) -> [x8,f,u8,x8];
+var_args(test_arity, 2) -> [f,{x,0},u32];
+var_args(l_trim, 5) -> [{u,6}];
+var_args(l_increment, 4) -> [t,{u,4294967295},u8,{x,0}];
+var_args(l_move_call, 8) -> [{y,4},f];
+var_args(l_call_ext, 4) -> [{e,{lists,foldl,3}}];
+var_args(extract_next_element, 9) -> [{y,0}];
+var_args(l_move_call_ext, 11) -> [t,{e,{io_lib,format,2}}];
+var_args(l_is_ne_exact, 0) -> [f];
+var_args(l_bs_get_binary2, 0) -> [f,t,u8,x8,u8,{u8,0},x8];
+var_args(extract_next_element, 24) -> [t];
+var_args(is_integer, 1) -> [f,{x,1}];
+var_args(l_band, 0) -> [f,u8,x8];
+var_args(move_jump, 0) -> [f,{x,1}];
+var_args(l_is_eq_exact_immed, 12) -> [f,{x,10},t];
+var_args(l_call_fun, 2) -> [{u8,3}];
+var_args(move_deallocate_return, 5) -> [t,{u,2}];
+var_args(l_times, 1) -> [f,u8,{x,0}];
+var_args(l_move_call_last, 3) -> [f,{u,2},t];
+var_args(put_list, 7) -> [t,t,{x,5}];
+var_args(l_call_last, 7) -> [f,{u,7}];
+var_args(l_move_call_ext_only, 3) -> [{e,{lists,reverse,1}},x8];
+var_args(l_fast_element, 2) -> [t,u8,{x,0}];
+var_args(l_is_eq_exact_literal, 7) -> [f,t,t];
+var_args(extract_next_element, 10) -> [{x,8}];
+var_args(extract_next_element2, 6) -> [{x,7}];
+var_args(is_tuple, 2) -> [f,{x,2}];
+var_args(l_catch, 3) -> [{y,3},t];
+var_args(l_call_ext, 5) -> [{e,{lists,sort,1}}];
+var_args(l_call_ext, 6) -> [{e,{file,open,2}}];
+var_args(l_bif2, 1) -> [f,{b,{erlang,'=:=',2}},t];
+var_args(l_is_eq_exact_immed, 13) -> [f,{x,11},t];
+var_args(is_binary, 0) -> [f,{x,0}];
+var_args(l_call_ext, 7) -> [{e,{lists,map,2}}];
+var_args(extract_next_element2, 7) -> [{x,8}];
+var_args(l_allocate_zero, 6) -> [{u,7}];
+var_args(l_bsr, 0) -> [f,u8,x8];
+var_args(l_fetch, 22) -> [t,t];
+var_args(move, 10) -> [t,{x,7}];
+var_args(extract_next_element3, 3) -> [{x,5}];
+var_args(l_is_eq_exact_immed, 14) -> [f,{y,1},t];
+var_args(get_list, 5) -> [{x,0},t,{x,0}];
+var_args(is_atom, 1) -> [f,{x,1}];
+var_args(extract_next_element3, 4) -> [{x,4}];
+var_args(l_bs_get_binary_all2, 0) -> [f,x8,u8,u8,x8];
+var_args(call_bif, 23) -> [{b,{erlang,tuple_to_list,1}}];
+var_args(l_move_call_only, 5) -> [f,{x,6}];
+var_args(call_bif, 24) -> [{b,{erlang,list_to_tuple,1}}];
+var_args(is_nonempty_list, 12) -> [f,{x,12}];
+var_args(l_is_eq_exact_immed, 15) -> [f,{x,12},t];
+var_args(l_fetch, 8) -> [y8,i8];
+var_args(l_is_eq_exact_literal, 1) -> [f,{x,1},t];
+var_args(l_move_call_ext, 12) -> [t,{e,{asn1ct_gen,emit,1}}];
+var_args(l_bs_get_integer_8, 0) -> [{x,0},f,x8];
+var_args(l_is_ne_exact_immed, 2) -> [f,{x,2},t];
+var_args(put_list, 6) -> [x8,nil,x8];
+var_args(is_nil, 9) -> [f,{x,9}];
+var_args(l_bsl, 0) -> [f,u8,{x,0}];
+var_args(l_select_val2, 9) -> [{x,4},f,t,f,t,f];
+var_args(is_list, 2) -> [f,{x,2}];
+var_args(l_allocate_zero, 9) -> [u32];
+var_args(l_put_tuple, 6) -> [y8,u8];
+var_args(l_call_ext, 8) -> [{e,{filename,join,2}}];
+var_args(l_bs_init_fail, 0) -> [u8,f,u8,x8];
+var_args(get_list, 6) -> [y8,x8,x8];
+var_args(l_bif2, 2) -> [f,{b,{erlang,'=<',2}},t];
+var_args(deallocate_return, 7) -> [{u,7}];
+var_args(l_bs_get_integer_8, 1) -> [x8,f,x8];
+var_args(set_tuple_element, 1) -> [t,{x,0},u32];
+var_args(l_move_call_ext, 13) -> [{y,6},e];
+var_args(l_select_val2, 16) -> [t,f,t,f,t,f];
+var_args(call_bif, 26) -> [{b,{erlang,'--',2}}];
+var_args(call_bif, 25) -> [{b,{lists,keyfind,3}}];
+var_args(l_call_ext, 9) -> [{e,{lists,flatten,1}}];
+var_args(l_move_call, 9) -> [{smallint,1},f];
+var_args(l_is_eq_exact_literal, 2) -> [f,{x,4},t];
+var_args(l_bs_get_integer_32, 1) -> [{x,0},f,u8,x8];
+var_args(extract_next_element, 11) -> [{x,9}];
+var_args(l_is_eq_exact_literal, 3) -> [f,{x,2},t];
+var_args(l_is_eq_exact_immed, 16) -> [f,{y,0},t];
+var_args(l_fetch, 9) -> [{x,1},t];
+var_args(l_bif2, 3) -> [f,{b,{erlang,'and',2}},t];
+var_args(is_nil, 10) -> [f,{x,10}];
+var_args(l_bsl, 1) -> [f,u8,x8];
+var_args(l_bs_test_zero_tail2, 5) -> [f,t];
+var_args(l_trim, 6) -> [{u,7}];
+var_args(l_rem, 0) -> [f,u8,x8];
+var_args(move2, 8) -> [{x,0},x8,x8,x8];
+var_args(l_move_call_ext, 14) -> [t,{e,{erlang,put,2}}];
+var_args(timeout, 0) -> [];
+var_args(is_binary, 1) -> [f,{x,1}];
+var_args(catch_end, 3) -> [{y,3}];
+var_args(l_move_call_ext_last, 1) -> [e,{u,0},t];
+var_args(l_call_last, 8) -> [f,{u,8}];
+var_args(l_allocate_zero, 7) -> [{u,8}];
+var_args(l_select_val2, 10) -> [{x,5},f,t,f,t,f];
+var_args(l_fetch, 10) -> [i8,y8];
+var_args(l_fmul, 0) -> [fr,fr,fr];
+var_args(l_bs_match_string, 2) -> [{x,0},f,u32,str];
+var_args(call_bif, 27) -> [{b,{ets,lookup_element,3}}];
+var_args(extract_next_element3, 10) -> [t];
+var_args(l_gc_bif1, 2) -> [f,{b,{erlang,byte_size,1}},x8,u8,{x,0}];
+var_args(move_deallocate_return, 6) -> [t,{u,3}];
+var_args(l_allocate, 7) -> [{u,7}];
+var_args(l_move_call, 10) -> [{y,6},f];
+var_args(l_catch, 4) -> [{y,4},t];
+var_args(is_nonempty_list, 36) -> [f,t];
+var_args(l_bs_get_integer_small_imm, 0) -> [{x,0},u8,f,u8,x8];
+var_args(extract_next_element, 12) -> [{y,2}];
+var_args(l_is_eq_exact_immed, 36) -> [f,t,t];
+var_args(l_call_ext, 10) -> [{e,{ordsets,union,2}}];
+var_args(move_jump, 1) -> [f,{x,2}];
+var_args(l_fcheckerror, 0) -> [];
+var_args(fclearerror, 0) -> [];
+var_args(move_return, 7) -> [{x,4}];
+var_args(l_bs_append, 0) -> [f,u8,u8,u8,x8];
+var_args(node, 0) -> [{x,0}];
+var_args(l_move_call, 11) -> [{x,4},f];
+var_args(extract_next_element2, 16) -> [t];
+var_args(l_move_call_last, 4) -> [f,{u,0},t];
+var_args(l_is_eq_exact_immed, 17) -> [f,{x,13},t];
+var_args(l_call_ext, 11) -> [{e,{lists,concat,1}}];
+var_args(extract_next_element, 13) -> [{y,3}];
+var_args(l_move_call_ext_only, 2) -> [{e,{erlang,nif_error,1}},{a,undef}];
+var_args(l_is_ne_exact_immed, 11) -> [f,t,t];
+var_args(l_is_eq_exact_immed, 18) -> [f,{y,3},t];
+var_args(l_get, 1) -> [t,{x,0}];
+var_args(l_element, 2) -> [t,t,{x,0}];
+var_args(is_integer, 2) -> [f,{x,2}];
+var_args(is_integer, 7) -> [f,t];
+var_args(l_move_call_ext_last, 4) -> [e,u32,t];
+var_args(l_bif2, 4) -> [f,{b,{erlang,'or',2}},t];
+var_args(l_move_call_ext, 16) -> [{x,3},e];
+var_args(l_call_fun, 3) -> [{u8,0}];
+var_args(l_move_call, 12) -> [{x,5},f];
+var_args(call_bif, 28) -> [{b,{erlang,process_flag,2}}];
+var_args(is_nonempty_list, 13) -> [f,{x,13}];
+var_args(try_end, 2) -> [{y,2}];
+var_args(is_nil, 11) -> [f,{x,12}];
+var_args(l_select_tuple_arity, 1) -> [x8,f,u8];
+var_args(is_tuple, 3) -> [f,{x,3}];
+var_args(l_move_call_ext_last, 2) -> [e,{u,1},t];
+var_args(node, 1) -> [{x,1}];
+var_args(is_nonempty_list, 14) -> [f,{y,2}];
+var_args(l_bs_restore2, 1) -> [{x,0},{u,0}];
+var_args(l_move_call_ext, 17) -> [{y,5},e];
+var_args(l_band, 1) -> [f,u8,{x,0}];
+var_args(l_is_eq_exact_immed, 19) -> [f,{y,2},t];
+var_args(l_get, 4) -> [t,t];
+var_args(call_bif, 29) -> [{b,{re,run,3}}];
+var_args(call_bif, 1) -> [{b,{erlang,raise,3}}];
+var_args(l_fetch, 11) -> [t,{x,1}];
+var_args(l_gc_bif1, 3) -> [f,b,{x,0},{u8,1},{x,0}];
+var_args(is_nil, 12) -> [f,{x,11}];
+var_args(l_move_call_only, 6) -> [f,{x,7}];
+var_args(l_move_call, 13) -> [nil,f];
+var_args(system_limit, 0) -> [f];
+var_args(l_element, 0) -> [x8,{x,0},x8];
+var_args(l_select_tuple_arity, 0) -> [{x,0},f,{u,6}];
+var_args(bif2_body, 1) -> [b,{x,1}];
+var_args(is_float, 1) -> [f,t];
+var_args(extract_next_element2, 8) -> [{x,9}];
+var_args(l_select_val2, 8) -> [t,f,{a,false},f,{a,true},f];
+var_args(is_integer_allocate, 0) -> [f,x8,u8];
+var_args(is_atom, 2) -> [f,{x,2}];
+var_args(l_int_div, 0) -> [f,u8,x8];
+var_args(l_get, 2) -> [t,{x,1}];
+var_args(l_gc_bif1, 5) -> [f,b,t,u8,{x,0}];
+var_args(l_move_call_ext, 18) -> [t,{e,{prettypr,text,1}}];
+var_args(is_nil, 29) -> [f,t];
+var_args(l_is_eq_exact_immed, 20) -> [f,{y,4},t];
+var_args(call_bif, 30) -> [{b,{ets,new,2}}];
+var_args(l_bor, 0) -> [f,u8,{x,0}];
+var_args(l_bif1, 0) -> [f,b,x8,x8];
+var_args(l_catch, 5) -> [{y,5},t];
+var_args(l_get, 0) -> [{a,asn1_module},{y,0}];
+var_args(l_fetch, 12) -> [{x,2},t];
+var_args(l_call_ext, 13) -> [{e,{file,delete,1}}];
+var_args(l_call_ext, 12) -> [{e,{test_server,timetrap,1}}];
+var_args(is_tuple, 9) -> [f,t];
+var_args(try_end, 3) -> [{y,4}];
+var_args(init, 8) -> [{y,8}];
+var_args(call_bif, 32) -> [{b,{erlang,make_ref,0}}];
+var_args(call_bif, 31) -> [{b,{erlang,whereis,1}}];
+var_args(is_nil, 13) -> [f,{y,1}];
+var_args(apply_last, 0) -> [u8,u32];
+var_args(call_bif, 33) -> [{b,{erlang,process_info,2}}];
+var_args(l_int_div, 1) -> [f,u8,{x,0}];
+var_args(call_bif, 34) -> [{b,{erlang,unlink,1}}];
+var_args(extract_next_element, 14) -> [{x,10}];
+var_args(put_list, 9) -> [t,{x,0},t];
+var_args(is_nonempty_list, 15) -> [f,{y,3}];
+var_args(case_end, 11) -> [t];
+var_args(l_bs_skip_bits2, 0) -> [f,t,t,u8];
+var_args(l_call_ext, 14) -> [{e,{test_server,timetrap_cancel,1}}];
+var_args(deallocate_return, 8) -> [{u,8}];
+var_args(l_call_ext_last, 3) -> [e,{u,3}];
+var_args(l_move_call_ext, 19) -> [t,{e,{proplists,get_value,3}}];
+var_args(l_is_ne_exact_immed, 3) -> [f,{x,3},t];
+var_args(extract_next_element3, 5) -> [{x,6}];
+var_args(is_integer, 3) -> [f,{x,3}];
+var_args(l_trim, 7) -> [{u,8}];
+var_args(l_is_eq_exact_immed, 21) -> [f,{x,14},t];
+var_args(l_increment, 8) -> [t,u32,u8,t];
+var_args(call_bif, 4) -> [{b,{erlang,exit,2}}];
+var_args(is_nonempty_list, 16) -> [f,{x,14}];
+var_args(is_list, 7) -> [f,t];
+var_args(l_element, 4) -> [t,t,t];
+var_args(extract_next_element3, 6) -> [{x,7}];
+var_args(l_is_eq_exact_literal, 4) -> [f,{x,3},t];
+var_args(test_arity, 3) -> [f,y8,u8];
+var_args(move_deallocate_return, 7) -> [t,{u,4}];
+var_args(l_move_call_ext_only, 4) -> [e,{x,2}];
+var_args(l_fadd, 0) -> [fr,fr,fr];
+var_args(l_call_ext, 16) -> [{e,{dict,find,2}}];
+var_args(l_call_ext, 15) -> [{e,{mnesia_lib,set,2}}];
+var_args(try_end, 5) -> [{y,3}];
+var_args(try_end, 4) -> [{y,5}];
+var_args(l_move_call_ext, 20) -> [nil,e];
+var_args(l_bs_match_string, 3) -> [x8,f,u8,str];
+var_args(call_bif, 35) -> [{b,{erlang,get_stacktrace,0}}];
+var_args(l_call_ext, 17) -> [{e,{lists,mapfoldl,3}}];
+var_args(fmove_1, 0) -> [t,{fr,1}];
+var_args(l_increment, 6) -> [x8,u32,u8,x8];
+var_args(if_end, 0) -> [];
+var_args(l_increment, 5) -> [{x,0},u8,u8,x8];
+var_args(l_call_ext, 18) -> [{e,{dict,new,0}}];
+var_args(is_integer, 4) -> [f,{x,4}];
+var_args(l_bs_get_utf8, 0) -> [x8,f,x8];
+var_args(is_list, 3) -> [f,{x,3}];
+var_args(is_atom, 3) -> [f,{x,3}];
+var_args(l_fetch, 13) -> [{x,4},t];
+var_args(l_bs_init_bits_fail, 0) -> [u32,f,u8,t];
+var_args(call_bif, 36) -> [{b,{ets,delete,2}}];
+var_args(l_call_ext, 19) -> [{e,{test_server,lookup_config,2}}];
+var_args(l_bs_test_zero_tail2, 4) -> [f,{x,4}];
+var_args(fconv, 0) -> [t,{fr,0}];
+var_args(case_end, 3) -> [{x,3}];
+var_args(catch_end, 4) -> [{y,4}];
+var_args(l_make_export, 0) -> [e];
+var_args(l_rem, 1) -> [f,u8,{x,0}];
+var_args(self, 2) -> [{x,2}];
+var_args(fmove_2, 0) -> [fr,{x,0}];
+var_args(l_bor, 1) -> [f,u8,x8];
+var_args(l_call_ext_last, 4) -> [e,{u,4}];
+var_args(call_bif, 37) -> [{b,{lists,keymember,3}}];
+var_args(l_call_last, 9) -> [f,{u,9}];
+var_args(bif1_body, 2) -> [{b,{erlang,hd,1}},{y,1},{x,2}];
+var_args(is_binary, 2) -> [f,{x,2}];
+var_args(l_fetch, 14) -> [{x,3},t];
+var_args(l_call_ext, 20) -> [{e,{erl_syntax,type,1}}];
+var_args(l_move_call_ext, 21) -> [t,{e,{test_server,seconds,1}}];
+var_args(l_bs_skip_bits_all2, 0) -> [f,{x,2},{u8,8}];
+var_args(l_catch, 7) -> [t,t];
+var_args(l_move_call_ext, 22) -> [t,{e,{asn1ct_name,new,1}}];
+var_args(extract_next_element, 15) -> [{x,11}];
+var_args(badmatch, 4) -> [{y,2}];
+var_args(l_move_call, 14) -> [{y,7},f];
+var_args(self, 5) -> [t];
+var_args(get_tuple_element, 8) -> [{x,0},u32,{x,0}];
+var_args(l_move_call_ext, 23) -> [t,{e,{proplists,get_value,2}}];
+var_args(l_move_call_ext, 24) -> [{y,7},e];
+var_args(l_call_ext, 21) -> [{e,{erlang,binary_to_term,1}}];
+var_args(l_move_call_only, 7) -> [f,nil];
+var_args(put_list, 8) -> [{x,0},t,{y,0}];
+var_args(l_is_eq_exact_immed, 22) -> [f,{y,5},t];
+var_args(is_nonempty_list_test_heap, 0) -> [f,u8,u8];
+var_args(is_tuple, 4) -> [f,{x,4}];
+var_args(extract_next_element2, 9) -> [{x,12}];
+var_args(case_end, 4) -> [{y,2}];
+var_args(l_is_function2, 0) -> [f,{x,0},u8];
+var_args(bif2_body, 3) -> [b,t];
+var_args(fmove_2, 1) -> [fr,x8];
+var_args(l_call_ext, 22) -> [{e,{dict,store,3}}];
+var_args(extract_next_element, 16) -> [{y,5}];
+var_args(extract_next_element2, 10) -> [{x,10}];
+var_args(move_jump, 2) -> [f,nil];
+var_args(move_return, 8) -> [{smallint,1}];
+var_args(is_nonempty_list, 17) -> [f,{y,1}];
+var_args(is_pid, 0) -> [f,{x,0}];
+var_args(l_jump_on_val, 0) -> [x8,f,u8,u8];
+var_args(l_get, 3) -> [t,{x,2}];
+var_args(bif1_body, 3) -> [b,t,{x,0}];
+var_args(l_select_val2, 11) -> [{x,6},f,t,f,t,f];
+var_args(l_allocate_zero, 8) -> [{u,9}];
+var_args(is_list, 4) -> [f,{x,4}];
+var_args(l_is_ne_exact_immed, 4) -> [f,t,{a,true}];
+var_args(fmove_1, 2) -> [t,fr];
+var_args(bif1_body, 4) -> [b,y8,x8];
+var_args(fmove_1, 1) -> [x8,fr];
+var_args(is_nonempty_list, 18) -> [f,{x,15}];
+var_args(l_bs_test_unit_8, 3) -> [f,t];
+var_args(l_fetch, 15) -> [{x,5},t];
+var_args(l_is_eq_exact_immed, 24) -> [f,{x,16},t];
+var_args(put_list, 10) -> [t,t,{x,6}];
+var_args(call_bif, 38) -> [{b,{erlang,now,0}}];
+var_args(l_gc_bif1, 4) -> [f,{b,{erlang,length,1}},t,u8,y8];
+var_args(extract_next_element, 17) -> [{y,4}];
+var_args(is_atom, 6) -> [f,t];
+var_args(l_move_call, 15) -> [{smallint,0},f];
+var_args(l_allocate, 10) -> [u32];
+var_args(l_move_call_ext_last, 3) -> [e,{u,2},t];
+var_args(l_call_ext, 23) -> [{e,{prettypr,floating,1}}];
+var_args(l_element, 1) -> [{x,0},x8,x8];
+var_args(move_deallocate_return, 8) -> [t,{u,5}];
+var_args(l_new_bs_put_integer, 0) -> [f,t,{u8,1},{u8,0},t];
+var_args(l_call_ext, 24) -> [{e,{proplists,get_value,2}}];
+var_args(l_move_call_last, 5) -> [f,{u,3},t];
+var_args(l_move_call_ext, 25) -> [t,{e,{mnesia_lib,verbose,2}}];
+var_args(init, 9) -> [{y,9}];
+var_args(l_allocate, 8) -> [{u,8}];
+var_args(l_call_ext, 25) -> [{e,{erlang,list_to_integer,1}}];
+var_args(l_fdiv, 0) -> [fr,fr,fr];
+var_args(bs_context_to_binary, 4) -> [t];
+var_args(l_bif2, 6) -> [f,b,t];
+var_args(l_call_ext_last, 6) -> [e,u32];
+var_args(get_list, 8) -> [x8,y8,y8];
+var_args(node, 4) -> [t];
+var_args(l_call_ext, 26) -> [{e,{filename,join,1}}];
+var_args(extract_next_element, 18) -> [{x,12}];
+var_args(deallocate_return, 9) -> [{u,9}];
+var_args(l_move_call_ext, 15) -> [{smallint,0},{e,{lists,seq,2}}];
+var_args(is_binary, 3) -> [f,t];
+var_args(move_deallocate_return, 9) -> [t,u32];
+var_args(l_call_ext, 27) -> [{e,{lists,usort,1}}];
+var_args(is_nonempty_list, 19) -> [f,{x,16}];
+var_args(l_select_val_atoms, 2) -> [t,f,u32];
+var_args(badmatch, 17) -> [t];
+var_args(call_bif, 39) -> [{b,{erlang,spawn_link,1}}];
+var_args(l_call_ext, 28) -> [{e,{proplists,get_value,3}}];
+var_args(extract_next_element2, 11) -> [{x,11}];
+var_args(badmatch, 5) -> [{y,3}];
+var_args(case_end, 5) -> [{y,1}];
+var_args(l_bs_restore2, 2) -> [{x,0},{u,1}];
+var_args(l_fetch, 16) -> [t,{x,4}];
+var_args(l_bs_get_integer, 0) -> [f,u8,u8,u8,x8];
+var_args(l_is_eq_exact_immed, 25) -> [f,{x,15},t];
+var_args(l_call_ext, 29) -> [{e,{sofs,to_external,1}}];
+var_args(move_return, 9) -> [{smallint,0}];
+var_args(is_function, 2) -> [f,t];
+var_args(l_bif1, 2) -> [f,b,t,t];
+var_args(l_move_call_ext, 26) -> [{x,4},e];
+var_args(call_bif, 40) -> [{b,{ets,safe_fixtable,2}}];
+var_args(l_call_ext, 30) -> [{e,{lists,filter,2}}];
+var_args(case_end, 6) -> [{x,4}];
+var_args(l_move_call_ext, 27) -> [t,{e,{io,format,1}}];
+var_args(catch_end, 5) -> [{y,5}];
+var_args(l_bs_get_binary_imm2, 0) -> [f,x8,u8,u8,{u8,0},x8];
+var_args(l_move_call_ext, 28) -> [t,{e,{lists,duplicate,2}}];
+var_args(call_bif, 42) -> [{b,{ets,next,2}}];
+var_args(call_bif, 41) -> [{b,{erlang,fun_info,2}}];
+var_args(l_call_ext, 32) -> [{e,{ordsets,from_list,1}}];
+var_args(l_call_ext, 31) -> [{e,{string,tokens,2}}];
+var_args(l_bs_test_unit_8, 1) -> [f,{x,3}];
+var_args(l_move_call, 16) -> [{smallint,2},f];
+var_args(l_bsr, 1) -> [f,u8,t];
+var_args(l_move_call_ext, 29) -> [t,{e,{erlang,system_info,1}}];
+var_args(l_bs_skip_bits_imm2, 0) -> [f,x8,u8];
+var_args(l_move_call_ext, 30) -> [t,{e,{erlang,erase,1}}];
+var_args(l_call_ext, 34) -> [{e,{asn1_db,dbget,2}}];
+var_args(l_call_ext, 33) -> [{e,{prettypr,beside,2}}];
+var_args(is_nil, 15) -> [f,{y,2}];
+var_args(is_nil, 14) -> [f,{x,13}];
+var_args(badmatch, 6) -> [{x,4}];
+var_args(l_call_last, 11) -> [f,u32];
+var_args(fconv, 1) -> [t,fr];
+var_args(is_boolean, 0) -> [f,t];
+var_args(l_is_ne_exact_immed, 5) -> [f,{x,4},t];
+var_args(call_bif, 43) -> [{b,{erlang,monitor,2}}];
+var_args(l_call_ext, 35) -> [{e,{lists,append,1}}];
+var_args(is_nil, 16) -> [f,{x,15}];
+var_args(l_move_call_only, 8) -> [f,{x,8}];
+var_args(l_bs_test_unit_8, 2) -> [f,{x,1}];
+var_args(catch_end, 7) -> [t];
+var_args(l_bs_get_utf16, 1) -> [{x,0},f,u8,x8];
+var_args(get_list, 9) -> [{x,0},y8,y8];
+var_args(l_plus, 2) -> [f,u8,y8];
+var_args(deallocate_return, 12) -> [u32];
+var_args(l_element, 3) -> [x8,x8,x8];
+var_args(move_jump, 3) -> [f,{x,4}];
+var_args(l_bs_put_string, 0) -> [{u,1},str];
+var_args(is_pid, 1) -> [f,t];
+var_args(is_atom, 4) -> [f,{x,4}];
+var_args(l_select_tuple_arity, 2) -> [{x,0},f,{u,8}];
+var_args(l_call_ext, 36) -> [{e,{erlang,term_to_binary,1}}];
+var_args(extract_next_element, 19) -> [{x,13}];
+var_args(case_end, 7) -> [{y,3}];
+var_args(l_catch, 6) -> [{y,6},t];
+var_args(l_call_ext, 38) -> [{e,{lists,last,1}}];
+var_args(l_call_ext, 37) -> [{e,{erlang,put,2}}];
+var_args(move_jump, 4) -> [f,{y,2}];
+var_args(is_nil, 17) -> [f,{x,14}];
+var_args(is_list, 5) -> [f,{x,5}];
+var_args(try_case_end, 0) -> [{x,0}];
+var_args(l_bs_get_binary_all2, 1) -> [f,{x,0},u8,u8,x8];
+var_args(move, 11) -> [t,{x,8}];
+var_args(l_move_call_last, 6) -> [f,{u,5},t];
+var_args(put_list, 14) -> [t,t,t];
+var_args(move_jump, 5) -> [f,{y,1}];
+var_args(move_return, 10) -> [{smallint,2}];
+var_args(l_is_eq_exact_literal, 5) -> [f,{x,5},t];
+var_args(bif2_body, 2) -> [b,{x,2}];
+var_args(get_tuple_element, 9) -> [y8,u8,{x,0}];
+var_args(put_list, 11) -> [x8,t,y8];
+var_args(l_select_val2, 12) -> [{x,7},f,t,f,t,f];
+var_args(call_bif, 44) -> [{b,{ets,match_object,2}}];
+var_args(is_nonempty_list, 20) -> [f,{x,17}];
+var_args(l_fsub, 0) -> [fr,fr,fr];
+var_args(l_move_call_ext, 31) -> [t,{e,{lists,seq,2}}];
+var_args(bif1_body, 5) -> [b,x8,x8];
+var_args(l_call_ext, 39) -> [{e,{lists,delete,2}}];
+var_args(extract_next_element3, 7) -> [{x,8}];
+var_args(l_bs_start_match2, 3) -> [t,f,u8,u8,{x,0}];
+var_args(l_trim, 8) -> [{u,9}];
+var_args(bs_context_to_binary, 1) -> [{x,1}];
+var_args(l_call_ext, 40) -> [{e,{lists,keydelete,3}}];
+var_args(move_return, 11) -> [{a,undefined}];
+var_args(l_call_fun, 4) -> [u8];
+var_args(l_is_eq_exact_literal, 6) -> [f,{x,6},t];
+var_args(l_is_ne_exact_immed, 6) -> [f,{y,0},t];
+var_args(test_heap_1_put_list, 2) -> [u8,y8];
+var_args(test_heap_1_put_list, 3) -> [u8,i8];
+var_args(l_is_eq_exact_immed, 26) -> [f,{x,17},t];
+var_args(self, 3) -> [{x,3}];
+var_args(l_call_ext, 41) -> [{e,{unicode,characters_to_binary,1}}];
+var_args(l_move_call_ext, 33) -> [t,{e,{mnesia_lib,dbg_out,2}}];
+var_args(init, 10) -> [{y,10}];
+var_args(l_bs_skip_bits_imm2, 1) -> [f,t,u32];
+var_args(l_call_ext, 42) -> [{e,{erlang,max,2}}];
+var_args(extract_next_element2, 12) -> [{x,13}];
+var_args(badmatch, 7) -> [{y,4}];
+var_args(l_move_call_ext_only, 5) -> [{e,{io,format,2}},t];
+var_args(l_call_ext, 43) -> [{e,{file,read,2}}];
+var_args(move_jump, 6) -> [f,{x,3}];
+var_args(is_nil, 18) -> [f,{x,16}];
+var_args(l_call_ext_only, 0) -> [{e,{gen_server,call,3}}];
+var_args(l_fetch, 17) -> [t,{x,2}];
+var_args(l_move_call_ext, 34) -> [t,{e,{erlang,binary_to_term,1}}];
+var_args(l_move_call_ext, 35) -> [t,{e,{test_server,lookup_config,2}}];
+var_args(l_is_eq_exact_immed, 27) -> [f,t,{a,asn1_NOVALUE}];
+var_args(l_bs_append, 1) -> [f,u8,u8,u8,{x,0}];
+var_args(l_bif2, 5) -> [f,{b,{erlang,'==',2}},t];
+var_args(l_bs_get_binary2, 1) -> [f,x8,u8,t,u8,{u8,0},x8];
+var_args(l_bs_get_integer_small_imm, 1) -> [x8,u8,f,u8,x8];
+var_args(l_call_ext, 47) -> [{e,{file,write,2}}];
+var_args(l_call_ext, 46) -> [{e,{ordsets,subtract,2}}];
+var_args(l_call_ext, 45) -> [{e,{gb_trees,lookup,2}}];
+var_args(l_call_ext, 44) -> [{e,{lists,duplicate,2}}];
+var_args(move_return, 12) -> [{x,5}];
+var_args(l_bs_save2, 1) -> [{x,0},{u,1}];
+var_args(is_function, 0) -> [f,{x,0}];
+var_args(l_bs_get_integer_imm, 0) -> [t,u8,u8,f,u8,x8];
+var_args(l_move_call_ext_only, 6) -> [e,{x,1}];
+var_args(l_call_ext, 48) -> [{e,{filename,basename,1}}];
+var_args(l_move_call, 17) -> [{a,foo},f];
+var_args(l_is_ne_exact_immed, 7) -> [f,x8,i8];
+var_args(l_call_ext, 50) -> [{e,{file,read_file,1}}];
+var_args(l_call_ext, 49) -> [{e,{gb_trees,empty,0}}];
+var_args(is_integer, 5) -> [f,{x,5}];
+var_args(move_return, 13) -> [{a,error}];
+var_args(l_bs_put_string, 1) -> [{u,4},str];
+var_args(try_end, 7) -> [t];
+var_args(l_yield, 0) -> [];
+var_args(l_move_call, 18) -> [{x,6},f];
+var_args(l_fetch, 18) -> [{y,0},t];
+var_args(l_is_eq_exact_immed, 28) -> [f,{x,18},t];
+var_args(l_new_bs_put_integer, 1) -> [f,t,u8,u8,t];
+var_args(node, 2) -> [{x,2}];
+var_args(l_call_ext, 51) -> [{e,{file,read_file_info,1}}];
+var_args(move_jump, 7) -> [f,{y,0}];
+var_args(case_end, 9) -> [{y,4}];
+var_args(case_end, 8) -> [{y,0}];
+var_args(is_nonempty_list, 22) -> [f,{y,4}];
+var_args(is_nonempty_list, 21) -> [f,{x,18}];
+var_args(l_move_call, 19) -> [{y,12},f];
+var_args(l_move_call_ext, 37) -> [t,{e,{io,fwrite,2}}];
+var_args(get_list, 11) -> [t,t,{x,0}];
+var_args(l_fetch, 19) -> [t,{x,3}];
+var_args(l_new_bs_put_float_imm, 1) -> [f,u32,u8,t];
+var_args(l_move_call, 20) -> [{a,endDocument},f];
+var_args(l_call_ext_only, 1) -> [{e,{ssh_bits,encode,2}}];
+var_args(l_gc_bif1, 6) -> [f,b,t,u8,t];
+var_args(l_bif1, 1) -> [f,{b,{erlang,tuple_size,1}},{x,0},t];
+var_args(l_move_call, 21) -> [{smallint,3},f];
+var_args(l_is_ne_exact_literal, 0) -> [f,t,t];
+var_args(l_bs_put_string, 2) -> [u32,str];
+var_args(l_call_ext, 52) -> [{e,{io,format,3}}];
+var_args(l_is_eq_exact_immed, 23) -> [f,{y,10},{a,ber}];
+var_args(extract_next_element, 20) -> [{x,14}];
+var_args(is_nil, 19) -> [f,{y,3}];
+var_args(badmatch, 8) -> [{x,5}];
+var_args(catch_end, 6) -> [{y,6}];
+var_args(l_is_function2, 1) -> [f,x8,u8];
+var_args(l_call_ext, 53) -> [{e,{filename,dirname,1}}];
+var_args(move_return, 14) -> [{smallint,3}];
+var_args(badmatch, 9) -> [{y,0}];
+var_args(self, 4) -> [{y,0}];
+var_args(l_call_ext, 56) -> [{e,{file,position,2}}];
+var_args(l_call_ext, 55) -> [{e,{os,type,0}}];
+var_args(l_call_ext, 54) -> [{e,{cerl,get_ann,1}}];
+var_args(l_call_ext_last, 5) -> [e,{u,5}];
+var_args(l_move_call, 23) -> [{a,ets},f];
+var_args(l_move_call, 22) -> [{a,schema},f];
+var_args(l_select_tuple_arity, 3) -> [{x,0},f,{u,10}];
+var_args(l_apply, 0) -> [];
+var_args(init, 16) -> [t];
+var_args(init, 11) -> [{y,11}];
+var_args(l_move_call_last, 8) -> [f,u32,t];
+var_args(l_move_call_last, 7) -> [f,{u,4},t];
+var_args(l_call_ext, 59) -> [{e,{file,make_dir,1}}];
+var_args(l_call_ext, 58) -> [{e,{erl_syntax,atom,1}}];
+var_args(l_call_ext, 57) -> [{e,{ssh_channel,cache_lookup,2}}];
+var_args(extract_next_element2, 13) -> [{x,14}];
+var_args(l_new_bs_put_integer_imm, 1) -> [f,u32,{u8,0},{smallint,0}];
+var_args(try_end, 6) -> [{y,6}];
+var_args(deallocate_return, 10) -> [{u,10}];
+var_args(l_move_call, 24) -> [{y,8},f];
+var_args(l_fetch, 20) -> [t,{x,5}];
+var_args(get_list, 10) -> [x8,y8,x8];
+var_args(l_allocate, 9) -> [{u,9}];
+var_args(bs_init_writable, 0) -> [];
+var_args(l_call_ext, 60) -> [{e,{orddict,find,2}}];
+var_args(extract_next_element, 21) -> [{x,16}];
+var_args(extract_next_element3, 8) -> [{x,11}];
+var_args(is_integer, 6) -> [f,{x,6}];
+var_args(move_jump, 8) -> [f,{y,3}];
+var_args(badmatch, 10) -> [{x,7}];
+var_args(is_nonempty_list, 23) -> [f,{x,20}];
+var_args(l_bs_private_append, 0) -> [f,u8,t];
+var_args(deallocate_return, 11) -> [{u,11}];
+var_args(l_move_call, 25) -> [{a,false},f];
+var_args(l_call_ext, 63) -> [{e,{asn1ct_gen,mk_var,1}}];
+var_args(l_call_ext, 62) -> [{e,{sofs,family_union,2}}];
+var_args(l_call_ext, 61) -> [{e,{mnesia_lib,exists,1}}];
+var_args(move_jump, 9) -> [f,{a,true}];
+var_args(move_return, 16) -> [{a,none}];
+var_args(move_return, 15) -> [{a,no}];
+var_args(bs_context_to_binary, 2) -> [{x,2}];
+var_args(l_jump_on_val, 1) -> [{x,0},f,u8,u8];
+var_args(l_increment, 7) -> [{x,0},u32,u8,y8];
+var_args(l_is_ne_exact_immed, 8) -> [f,{y,2},t];
+var_args(l_call_ext, 67) -> [{e,{file,rename,2}}];
+var_args(l_call_ext, 66) -> [{e,{gb_trees,get,2}}];
+var_args(l_call_ext, 65) -> [{e,{asn1ct_gen,get_inner,1}}];
+var_args(l_call_ext, 64) -> [{e,{file,get_cwd,0}}];
+var_args(extract_next_element2, 14) -> [{y,0}];
+var_args(put_list, 13) -> [t,nil,t];
+var_args(is_float, 0) -> [f,{x,0}];
+var_args(l_is_eq_exact_immed, 29) -> [f,{x,19},t];
+var_args(l_select_val2, 14) -> [{x,8},f,t,f,t,f];
+var_args(l_call_ext, 69) -> [{e,{lists,dropwhile,2}}];
+var_args(l_call_ext, 68) -> [{e,{lists,split,2}}];
+var_args(extract_next_element3, 9) -> [{x,10}];
+var_args(move_return, 17) -> [{smallint,4}];
+var_args(is_nonempty_list, 25) -> [f,{y,0}];
+var_args(is_nonempty_list, 24) -> [f,{x,19}];
+var_args(l_select_tuple_arity2, 2) -> [y8,f,u8,f,u8,f];
+var_args(is_atom, 5) -> [f,{x,5}];
+var_args(l_call_ext_only, 2) -> [{e,{io,format,3}}];
+var_args(l_is_ne_exact_immed, 9) -> [f,{y,1},t];
+var_args(node, 3) -> [{x,3}];
+var_args(is_tuple, 5) -> [f,{x,7}];
+var_args(l_call_ext, 73) -> [{e,{mnesia_lib,cs_to_storage_type,2}}];
+var_args(l_call_ext, 72) -> [{e,{lists,splitwith,2}}];
+var_args(l_call_ext, 71) -> [{e,{test_server,fail,1}}];
+var_args(l_call_ext, 70) -> [{e,{unicode,characters_to_list,1}}];
+var_args(extract_next_element, 22) -> [{y,6}];
+var_args(wait_timeout, 0) -> [f,t];
+var_args(extract_next_element2, 15) -> [{x,16}];
+var_args(is_nil, 20) -> [f,{x,17}];
+var_args(is_nonempty_list, 26) -> [f,{y,6}];
+var_args(l_wait_timeout, 2) -> [f,u32];
+var_args(l_minus, 2) -> [f,u8,t];
+var_args(is_tuple, 6) -> [f,{x,5}];
+var_args(l_call_ext, 79) -> [{e,{sofs,relation,1}}];
+var_args(l_call_ext, 78) -> [{e,{mnesia_monitor,use_dir,0}}];
+var_args(l_call_ext, 77) -> [{e,{sets,is_element,2}}];
+var_args(l_call_ext, 76) -> [{e,{lists,sublist,3}}];
+var_args(l_call_ext, 75) -> [{e,{gb_trees,insert,3}}];
+var_args(l_call_ext, 74) -> [{e,{random,uniform,1}}];
+var_args(l_call_last, 10) -> [f,{u,10}];
+var_args(l_bs_test_tail_imm2, 0) -> [f,t,u32];
+var_args(move_jump, 10) -> [f,{a,false}];
+var_args(move_return, 18) -> [{smallint,8}];
+var_args(is_integer_allocate, 1) -> [f,t,u32];
+var_args(is_nonempty_list, 27) -> [f,{y,9}];
+var_args(l_new_bs_put_float_imm, 0) -> [f,{u,64},{u8,0},{x,0}];
+var_args(l_fetch, 21) -> [t,{y,0}];
+var_args(move, 12) -> [t,{x,10}];
+var_args(move2, 9) -> [{x,0},x8,{x,0},x8];
+var_args(l_bs_skip_bits_all2, 1) -> [f,{x,3},{u8,8}];
+var_args(is_tuple, 7) -> [f,{y,4}];
+var_args(l_call_ext, 84) -> [{e,{mnesia_schema,list2cs,1}}];
+var_args(l_call_ext, 83) -> [{e,{gb_trees,from_orddict,1}}];
+var_args(l_call_ext, 82) -> [{e,{gb_trees,to_list,1}}];
+var_args(l_call_ext, 81) -> [{e,{gb_sets,empty,0}}];
+var_args(l_call_ext, 80) -> [{e,{dict,fetch,2}}];
+var_args(l_is_eq_exact_immed, 30) -> [f,{y,6},t];
+var_args(is_nil, 21) -> [f,{y,0}];
+var_args(recv_mark, 0) -> [f];
+var_args(raise, 1) -> [t,t];
+var_args(case_end, 10) -> [{x,5}];
+var_args(is_function, 1) -> [f,{x,1}];
+var_args(l_call_ext_only, 3) -> [{e,{asn1ct_gen,emit,1}}];
+var_args(l_recv_set, 0) -> [];
+var_args(l_bs_skip_bits_all2, 2) -> [f,t,u8];
+var_args(l_fast_element, 3) -> [x8,u8,y8];
+var_args(l_trim, 11) -> [u32];
+var_args(l_times, 2) -> [f,u8,t];
+var_args(bs_context_to_binary, 3) -> [{y,0}];
+var_args(l_move_call_ext, 32) -> [{a,funky},{e,{estone_SUITE,req,2}}];
+var_args(l_is_eq_exact_immed, 31) -> [f,{x,22},t];
+var_args(is_port, 0) -> [f,t];
+var_args(l_bs_get_float2, 0) -> [f,t,u8,t,u8,u8,t];
+var_args(l_bs_get_utf8, 1) -> [t,f,t];
+var_args(l_select_val2, 15) -> [{y,1},f,t,f,t,f];
+var_args(l_select_tuple_arity, 4) -> [t,f,u32];
+var_args(test_heap_1_put_list, 4) -> [u32,t];
+var_args(is_map, 0) -> [f,t];
+var_args(l_trim, 9) -> [{u,11}];
+var_args(badmatch, 11) -> [{y,6}];
+var_args(l_apply_fun, 0) -> [];
+var_args(init, 12) -> [{y,12}];
+var_args(l_is_eq_exact_immed, 32) -> [f,{y,7},t];
+var_args(extract_next_element, 23) -> [{x,18}];
+var_args(l_move_call_only, 10) -> [f,{x,9}];
+var_args(l_move_call_only, 9) -> [f,{smallint,1}];
+var_args(l_is_eq_exact_immed, 33) -> [f,{x,20},t];
+var_args(l_is_ne_exact_immed, 10) -> [f,{x,5},t];
+var_args(move_return, 19) -> [{a,nomatch}];
+var_args(badmatch, 13) -> [{y,9}];
+var_args(badmatch, 12) -> [{y,5}];
+var_args(l_bs_get_integer_16, 0) -> [t,f,t];
+var_args(l_bs_get_binary_all_reuse, 1) -> [{x,0},f,{u8,1}];
+var_args(l_is_eq_exact_immed, 34) -> [f,{y,8},t];
+var_args(move_jump, 11) -> [f,{a,asn1_NOVALUE}];
+var_args(move_return, 21) -> [{smallint,16}];
+var_args(move_return, 20) -> [{a,ignore}];
+var_args(l_move_call_only, 11) -> [f,{x,10}];
+var_args(badmatch, 14) -> [{y,1}];
+var_args(is_list, 6) -> [f,{x,7}];
+var_args(l_bs_init_fail, 1) -> [u32,f,u8,t];
+var_args(l_move_call_ext, 36) -> [{a,auto_repair},{e,{mnesia_monitor,get_env,1}}];
+var_args(is_tuple, 8) -> [f,{x,6}];
+var_args(move_jump, 13) -> [f,{smallint,0}];
+var_args(move_jump, 12) -> [f,{y,4}];
+var_args(move_return, 22) -> [{x,6}];
+var_args(is_nil, 22) -> [f,{x,19}];
+var_args(is_nonempty_list, 29) -> [f,{y,7}];
+var_args(is_nonempty_list, 28) -> [f,{y,5}];
+var_args(l_bs_init, 0) -> [u32,u32,u8,t];
+var_args(l_bs_restore2, 3) -> [t,u32];
+var_args(move, 13) -> [t,{x,9}];
+var_args(l_bs_get_binary_imm2, 1) -> [f,{x,0},u8,u32,u8,x8];
+var_args(is_nonempty_list, 30) -> [f,{x,24}];
+var_args(l_bs_init_bits, 0) -> [u32,u32,u8,t];
+var_args(l_bs_put_utf16, 0) -> [f,u8,t];
+var_args(is_bitstr, 0) -> [f,t];
+var_args(l_bs_validate_unicode, 0) -> [f,t];
+var_args(is_nonempty_list, 32) -> [f,{y,8}];
+var_args(is_nonempty_list, 31) -> [f,{x,21}];
+var_args(l_bs_save2, 2) -> [t,u32];
+var_args(l_bs_utf16_size, 0) -> [t,t];
+var_args(l_bs_get_binary2, 2) -> [f,t,u8,t,u8,u8,t];
+var_args(l_is_eq_exact_immed, 35) -> [f,{x,23},t];
+var_args(get_tuple_element, 10) -> [t,u32,t];
+var_args(l_bs_get_integer_32, 2) -> [t,f,u8,t];
+var_args(move_return, 24) -> [{smallint,5}];
+var_args(move_return, 23) -> [{smallint,64}];
+var_args(is_nil, 23) -> [f,{x,18}];
+var_args(badmatch, 15) -> [{x,6}];
+var_args(is_nonempty_list, 33) -> [f,{x,22}];
+var_args(move, 14) -> [t,t];
+var_args(l_bs_add, 1) -> [f,u8,t];
+var_args(is_reference, 0) -> [f,t];
+var_args(is_nil, 26) -> [f,{x,22}];
+var_args(is_nil, 25) -> [f,{x,21}];
+var_args(is_nil, 24) -> [f,{y,4}];
+var_args(l_new_bs_put_binary, 0) -> [f,t,u8,u8,t];
+var_args(badmatch, 16) -> [{y,8}];
+var_args(is_nonempty_list, 34) -> [f,{x,25}];
+var_args(init, 13) -> [{y,14}];
+var_args(is_nil, 28) -> [f,{x,20}];
+var_args(is_nil, 27) -> [f,{y,5}];
+var_args(put_list, 12) -> [{x,0},{x,3},{x,8}];
+var_args(is_nonempty_list, 35) -> [f,{x,26}];
+var_args(l_bs_validate_unicode_retract, 0) -> [f];
+var_args(l_wait_timeout, 0) -> [f,{u,1000}];
+var_args(l_gc_bif2, 0) -> [f,b,u8,t];
+var_args(init, 14) -> [{y,13}];
+var_args(l_fast_element, 4) -> [t,u32,t];
+var_args(l_trim, 10) -> [{u,10}];
+var_args(l_new_bs_put_binary_all, 1) -> [f,t,u8];
+var_args(l_apply_last, 0) -> [u32];
+var_args(init, 15) -> [{y,16}];
+var_args(is_number, 0) -> [f,t];
+var_args(l_int_bnot, 0) -> [f,t,u8,t];
+var_args(l_bs_put_utf8, 0) -> [f,t];
+var_args(l_new_bs_put_float, 0) -> [f,t,u8,u8,t];
+var_args(l_select_val2, 13) -> [{x,9},f,{a,atom},f,{a,var},f];
+var_args(l_bs_utf8_size, 0) -> [t,t];
+var_args(l_wait_timeout, 1) -> [f,{u,1}];
+var_args(fmove_2, 2) -> [fr,t];
+var_args(l_jump_on_val, 2) -> [t,f,u32,u32];
+var_args(l_bs_get_binary_imm2, 2) -> [f,t,u8,u32,u8,t];
+var_args(l_fnegate, 0) -> [fr,fr];
+var_args(get_list, 12) -> [t,t,t];
+var_args(l_bs_get_integer_imm, 1) -> [t,u32,u8,f,u8,t];
+var_args(bif1_body, 6) -> [b,t,t];
+var_args(l_bs_get_binary_all_reuse, 2) -> [t,f,u8];
+var_args(l_bxor, 0) -> [f,u8,t];
+var_args(l_new_bs_put_integer_imm, 2) -> [f,u32,u8,t];
+var_args(l_int_div, 2) -> [f,u8,t];
+var_args(l_gc_bif3, 0) -> [f,b,t,u8,t];
+var_args(l_apply_only, 0) -> [];
+var_args(l_bor, 2) -> [f,u8,t];
+var_args(l_bs_start_match2, 4) -> [t,f,u8,u32,t];
+var_args(l_rem, 2) -> [f,u8,t];
+var_args(l_bsl, 2) -> [f,u8,t];
+var_args(l_new_bs_put_binary_imm, 0) -> [f,u32,u8,t];
+var_args(l_apply_fun_only, 0) -> [];
+var_args(l_bs_get_integer_8, 2) -> [t,f,t];
+var_args(l_bs_get_integer_small_imm, 2) -> [t,u32,f,u8,t];
+var_args(l_hibernate, 0) -> [];
+var_args(l_apply_fun_last, 0) -> [u32];
+var_args(l_band, 2) -> [f,u8,t];
+var_args(is_bigint, 0) -> [f,t];
+var_args(on_load, 0) -> [];
+var_args(move2, 10) -> [t,t,t,t];
+var_args(l_bs_test_unit, 0) -> [f,t,u8];
+var_args(l_m_div, 0) -> [f,u8,t];
+var_args(l_select_val_smallints, 2) -> [t,f,u32];
+var_args(is_function2, 0) -> [f,t,t];
+var_args(test_heap, 1) -> [u32,u8];
+var_args(func_info, 0) -> [t,t,u8];
+var_args(call_bif, 0) -> [{b,{erlang,purge_module,1}}];
+var_args(l_bs_get_utf16, 2) -> [t,f,u8,t];
+var_args(l_put_tuple, 7) -> [t,u32];
+var_args(allocate_init, 1) -> [u32,t];
+var_args(l_call_fun_last, 1) -> [u8,u32];
+var_args(set_tuple_element, 2) -> [t,t,u32];
+var_args(allocate_heap, 1) -> [u32,u32,u8];
+var_args(is_tuple_of_arity, 4) -> [f,t,u32];
+var_args(test_arity, 4) -> [f,t,u32];
+var_args(l_bs_match_string, 4) -> [t,f,u32,str];
+var_args(is_nonempty_list_allocate, 2) -> [f,t,u32];
+var_args(l_bs_append, 2) -> [f,u32,u8,u8,t];
+var_args(try_case_end, 1) -> [t];
+var_args(init3, 1) -> [t,t,t];
+var_args(l_select_tuple_arity2, 3) -> [t,f,u32,f,u32,f];
+var_args(init2, 1) -> [t,t];
+var_args(l_is_function2, 2) -> [f,t,u8];
+var_args(l_bs_get_binary_all2, 2) -> [f,t,u8,u8,t];
+var_args(is_nonempty_list_test_heap, 1) -> [f,u32,u8];
+var_args(allocate_heap_zero, 1) -> [u32,u32,u8];
+var_args(l_bs_init_heap_bin, 1) -> [u32,u32,u8,t];
+var_args(l_plus, 3) -> [f,u8,t];
+var_args(l_bs_get_integer, 1) -> [f,u8,u8,u8,t];
+
+var_args(Op, No) -> erlang:error({novar,Op,No}).
+
+var_index(move, 0) -> 0;
+var_index(move, 1) -> 1;
+var_index(l_call, 0) -> 2;
+var_index(test_heap, 0) -> 3;
+var_index(move, 2) -> 4;
+var_index(badmatch, 0) -> 5;
+var_index(move, 3) -> 6;
+var_index(l_put_tuple, 0) -> 7;
+var_index(move, 4) -> 8;
+var_index(move2, 1) -> 9;
+var_index(get_tuple_element, 0) -> 10;
+var_index(move2, 0) -> 11;
+var_index(put_list, 0) -> 12;
+var_index(is_tuple_of_arity, 1) -> 13;
+var_index(get_tuple_element, 1) -> 14;
+var_index(l_call_only, 0) -> 15;
+var_index(call_bif, 7) -> 16;
+var_index(l_bs_start_match2, 0) -> 17;
+var_index(l_bs_test_zero_tail2, 0) -> 18;
+var_index(l_bs_match_string, 0) -> 19;
+var_index(l_is_eq_exact_immed, 0) -> 20;
+var_index(put_list, 1) -> 21;
+var_index(is_tuple_of_arity, 0) -> 22;
+var_index(l_is_eq_exact_immed, 1) -> 23;
+var_index(get_list, 0) -> 24;
+var_index(l_put_tuple, 1) -> 25;
+var_index(move, 5) -> 26;
+var_index(l_call_ext, 85) -> 27;
+var_index(l_move_call_ext, 0) -> 28;
+var_index(return, 0) -> 29;
+var_index(move2, 2) -> 30;
+var_index(l_is_ge, 0) -> 31;
+var_index(l_move_call_last, 0) -> 32;
+var_index(l_make_fun, 0) -> 33;
+var_index(is_tuple_of_arity, 2) -> 34;
+var_index(extract_next_element2, 0) -> 35;
+var_index(move_deallocate_return, 0) -> 36;
+var_index(call_bif, 3) -> 37;
+var_index(l_allocate, 0) -> 38;
+var_index(l_fetch, 0) -> 39;
+var_index(l_trim, 0) -> 40;
+var_index(is_nil, 0) -> 41;
+var_index(is_nonempty_list, 0) -> 42;
+var_index(move_return, 25) -> 43;
+var_index(l_move_call_ext, 1) -> 44;
+var_index(deallocate_return, 0) -> 45;
+var_index(case_end, 0) -> 46;
+var_index(get_list, 1) -> 47;
+var_index(l_allocate, 1) -> 48;
+var_index(l_fetch, 1) -> 49;
+var_index(jump, 0) -> 50;
+var_index(extract_next_element, 0) -> 51;
+var_index(put_list, 3) -> 52;
+var_index(l_is_eq_exact_immed, 2) -> 53;
+var_index(move2, 3) -> 54;
+var_index(l_fetch, 2) -> 55;
+var_index(l_is_eq_exact, 0) -> 56;
+var_index(call_bif, 8) -> 57;
+var_index(l_allocate, 2) -> 58;
+var_index(l_is_eq_exact_immed, 3) -> 59;
+var_index(get_tuple_element, 2) -> 60;
+var_index(l_move_call, 26) -> 61;
+var_index(deallocate_return, 1) -> 62;
+var_index(move_return, 0) -> 63;
+var_index(init2, 0) -> 64;
+var_index(get_tuple_element, 3) -> 65;
+var_index(put_list, 2) -> 66;
+var_index(init, 0) -> 67;
+var_index(move2, 4) -> 68;
+var_index(l_is_eq_exact_immed, 4) -> 69;
+var_index(call_bif, 9) -> 70;
+var_index(l_fetch, 3) -> 71;
+var_index(deallocate_return, 2) -> 72;
+var_index(extract_next_element, 1) -> 73;
+var_index(is_nonempty_list, 1) -> 74;
+var_index(put_list, 4) -> 75;
+var_index(l_put_tuple, 2) -> 76;
+var_index(l_allocate, 3) -> 77;
+var_index(is_tuple_of_arity, 3) -> 78;
+var_index(move2, 5) -> 79;
+var_index(init, 1) -> 80;
+var_index(get_tuple_element, 4) -> 81;
+var_index(l_fetch, 4) -> 82;
+var_index(init3, 0) -> 83;
+var_index(get_list, 2) -> 84;
+var_index(l_move_call_ext, 38) -> 85;
+var_index(allocate_init, 0) -> 86;
+var_index(l_is_eq_exact_immed, 5) -> 87;
+var_index(l_trim, 1) -> 88;
+var_index(test_heap_1_put_list, 0) -> 89;
+var_index(l_is_lt, 0) -> 90;
+var_index(l_is_eq_exact_literal, 0) -> 91;
+var_index(call_bif, 6) -> 92;
+var_index(call_bif, 45) -> 93;
+var_index(l_allocate_zero, 0) -> 94;
+var_index(allocate_heap, 0) -> 95;
+var_index(is_tuple, 0) -> 96;
+var_index(move_return, 1) -> 97;
+var_index(is_nonempty_list, 2) -> 98;
+var_index(l_allocate_zero, 1) -> 99;
+var_index(move, 6) -> 100;
+var_index(l_call_last, 0) -> 101;
+var_index(init, 2) -> 102;
+var_index(l_gc_bif1, 0) -> 103;
+var_index(deallocate_return, 3) -> 104;
+var_index(get_tuple_element, 5) -> 105;
+var_index(l_increment, 0) -> 106;
+var_index(call_bif, 2) -> 107;
+var_index(is_nonempty_list_allocate, 0) -> 108;
+var_index(l_select_val_atoms, 0) -> 109;
+var_index(l_move_call, 0) -> 110;
+var_index(l_is_eq_exact_immed, 6) -> 111;
+var_index(call_bif, 5) -> 112;
+var_index(move_deallocate_return, 1) -> 113;
+var_index(is_nonempty_list, 3) -> 114;
+var_index(extract_next_element, 2) -> 115;
+var_index(is_list, 0) -> 116;
+var_index(l_select_val2, 3) -> 117;
+var_index(l_fetch, 5) -> 118;
+var_index(extract_next_element3, 0) -> 119;
+var_index(is_nil, 1) -> 120;
+var_index(move_deallocate_return, 2) -> 121;
+var_index(l_call_last, 1) -> 122;
+var_index(l_trim, 2) -> 123;
+var_index(l_call_last, 2) -> 124;
+var_index(get_list, 3) -> 125;
+var_index(l_select_val2, 0) -> 126;
+var_index(l_move_call_only, 12) -> 127;
+var_index(is_nil, 2) -> 128;
+var_index(move2, 6) -> 129;
+var_index(l_allocate, 4) -> 130;
+var_index(l_move_call_only, 0) -> 131;
+var_index(extract_next_element2, 1) -> 132;
+var_index(move_return, 2) -> 133;
+var_index(test_arity, 0) -> 134;
+var_index(move2, 7) -> 135;
+var_index(l_call_ext, 0) -> 136;
+var_index(l_new_bs_put_integer_imm, 0) -> 137;
+var_index(l_select_val2, 4) -> 138;
+var_index(l_move_call_only, 1) -> 139;
+var_index(l_select_val2, 1) -> 140;
+var_index(remove_message, 0) -> 141;
+var_index(init, 3) -> 142;
+var_index(l_allocate_zero, 2) -> 143;
+var_index(l_plus, 0) -> 144;
+var_index(l_catch, 0) -> 145;
+var_index(deallocate_return, 4) -> 146;
+var_index(is_nonempty_list, 4) -> 147;
+var_index(bif1_body, 0) -> 148;
+var_index(l_put_tuple, 3) -> 149;
+var_index(extract_next_element, 3) -> 150;
+var_index(l_is_eq_exact_immed, 7) -> 151;
+var_index(move_jump, 14) -> 152;
+var_index(move, 7) -> 153;
+var_index(l_allocate_zero, 3) -> 154;
+var_index(l_move_call_only, 2) -> 155;
+var_index(l_select_tuple_arity2, 0) -> 156;
+var_index(l_bs_start_match2, 1) -> 157;
+var_index(catch_end, 0) -> 158;
+var_index(move_return, 3) -> 159;
+var_index(is_nonempty_list, 5) -> 160;
+var_index(l_is_eq_exact_immed, 8) -> 161;
+var_index(l_call_last, 3) -> 162;
+var_index(l_move_call_only, 3) -> 163;
+var_index(l_call_last, 4) -> 164;
+var_index(get_list, 4) -> 165;
+var_index(move_return, 4) -> 166;
+var_index(move, 8) -> 167;
+var_index(test_arity, 1) -> 168;
+var_index(move_return, 5) -> 169;
+var_index(is_nonempty_list, 6) -> 170;
+var_index(l_call_fun, 0) -> 171;
+var_index(l_increment, 1) -> 172;
+var_index(put_list, 5) -> 173;
+var_index(init, 4) -> 174;
+var_index(l_is_eq, 0) -> 175;
+var_index(l_select_val2, 2) -> 176;
+var_index(l_move_call_ext, 2) -> 177;
+var_index(l_call_ext_only, 4) -> 178;
+var_index(l_bs_get_binary_all_reuse, 0) -> 179;
+var_index(send, 0) -> 180;
+var_index(set_tuple_element, 0) -> 181;
+var_index(bif2_body, 0) -> 182;
+var_index(extract_next_element2, 2) -> 183;
+var_index(l_move_call, 1) -> 184;
+var_index(l_catch, 1) -> 185;
+var_index(is_nil, 3) -> 186;
+var_index(move_deallocate_return, 3) -> 187;
+var_index(call_bif, 10) -> 188;
+var_index(extract_next_element2, 3) -> 189;
+var_index(badmatch, 1) -> 190;
+var_index(is_nonempty_list, 7) -> 191;
+var_index(l_increment, 2) -> 192;
+var_index(l_is_eq_exact_immed, 9) -> 193;
+var_index(case_end, 1) -> 194;
+var_index(extract_next_element, 4) -> 195;
+var_index(l_trim, 3) -> 196;
+var_index(l_move_call_ext_last, 0) -> 197;
+var_index(is_nonempty_list, 8) -> 198;
+var_index(l_move_call_last, 1) -> 199;
+var_index(badmatch, 2) -> 200;
+var_index(deallocate_return, 5) -> 201;
+var_index(l_fetch, 6) -> 202;
+var_index(l_select_val_atoms, 1) -> 203;
+var_index(l_bs_add, 0) -> 204;
+var_index(l_allocate, 5) -> 205;
+var_index(l_select_val_smallints, 0) -> 206;
+var_index(l_move_call, 2) -> 207;
+var_index(l_select_tuple_arity2, 1) -> 208;
+var_index(is_nonempty_list, 9) -> 209;
+var_index(l_bs_test_zero_tail2, 1) -> 210;
+var_index(l_loop_rec, 0) -> 211;
+var_index(l_move_call_ext, 3) -> 212;
+var_index(is_nil, 4) -> 213;
+var_index(l_is_ne_exact_immed, 0) -> 214;
+var_index(l_increment, 3) -> 215;
+var_index(l_is_ne, 0) -> 216;
+var_index(l_move_call, 3) -> 217;
+var_index(l_plus, 1) -> 218;
+var_index(catch_end, 1) -> 219;
+var_index(l_move_call, 4) -> 220;
+var_index(init, 5) -> 221;
+var_index(l_call_last, 6) -> 222;
+var_index(l_call_last, 5) -> 223;
+var_index(l_minus, 0) -> 224;
+var_index(l_move_call_ext, 4) -> 225;
+var_index(l_bs_match_string, 1) -> 226;
+var_index(l_allocate_zero, 4) -> 227;
+var_index(extract_next_element, 5) -> 228;
+var_index(l_select_val2, 6) -> 229;
+var_index(l_bs_init_heap_bin, 0) -> 230;
+var_index(l_allocate_zero, 5) -> 231;
+var_index(l_bs_start_match2, 2) -> 232;
+var_index(l_fetch, 7) -> 233;
+var_index(l_call_ext_last, 0) -> 234;
+var_index(is_nonempty_list_allocate, 1) -> 235;
+var_index(l_bs_restore2, 0) -> 236;
+var_index(loop_rec_end, 0) -> 237;
+var_index(call_bif, 11) -> 238;
+var_index(l_bs_get_utf16, 0) -> 239;
+var_index(l_fast_element, 1) -> 240;
+var_index(l_gc_bif1, 1) -> 241;
+var_index(l_trim, 4) -> 242;
+var_index(move, 9) -> 243;
+var_index(wait, 0) -> 244;
+var_index(l_is_eq_exact_immed, 10) -> 245;
+var_index(extract_next_element2, 4) -> 246;
+var_index(is_atom, 0) -> 247;
+var_index(call_bif, 12) -> 248;
+var_index(int_code_end, 0) -> 249;
+var_index(l_call_fun_last, 0) -> 250;
+var_index(l_move_call_ext_only, 0) -> 251;
+var_index(get_tuple_element, 6) -> 252;
+var_index(move_deallocate_return, 4) -> 253;
+var_index(bs_context_to_binary, 0) -> 254;
+var_index(init, 6) -> 255;
+var_index(l_move_call_ext, 5) -> 256;
+var_index(extract_next_element, 6) -> 257;
+var_index(self, 0) -> 258;
+var_index(is_nil, 5) -> 259;
+var_index(l_move_call_ext, 6) -> 260;
+var_index(l_call_ext_last, 1) -> 261;
+var_index(l_call_fun, 1) -> 262;
+var_index(l_is_eq_exact_immed, 11) -> 263;
+var_index(l_move_call, 5) -> 264;
+var_index(l_is_ne_exact_immed, 1) -> 265;
+var_index(is_tuple, 1) -> 266;
+var_index(extract_next_element, 7) -> 267;
+var_index(l_move_call_last, 2) -> 268;
+var_index(l_times, 0) -> 269;
+var_index(l_bs_test_unit_8, 0) -> 270;
+var_index(l_allocate, 6) -> 271;
+var_index(badmatch, 3) -> 272;
+var_index(l_move_call_ext_only, 1) -> 273;
+var_index(l_bs_test_zero_tail2, 2) -> 274;
+var_index(l_move_call_ext, 7) -> 275;
+var_index(l_move_call_ext, 8) -> 276;
+var_index(move_return, 6) -> 277;
+var_index(l_put_tuple, 4) -> 278;
+var_index(call_bif, 13) -> 279;
+var_index(l_catch, 2) -> 280;
+var_index(bif1_body, 1) -> 281;
+var_index(l_select_val_smallints, 1) -> 282;
+var_index(raise, 0) -> 283;
+var_index(call_bif, 14) -> 284;
+var_index(is_nil, 6) -> 285;
+var_index(l_move_call, 6) -> 286;
+var_index(l_move_call_ext, 9) -> 287;
+var_index(l_select_val2, 7) -> 288;
+var_index(is_integer, 0) -> 289;
+var_index(extract_next_element3, 1) -> 290;
+var_index(l_minus, 1) -> 291;
+var_index(is_nonempty_list, 10) -> 292;
+var_index(call_bif, 15) -> 293;
+var_index(l_bs_save2, 0) -> 294;
+var_index(l_call_ext_last, 2) -> 295;
+var_index(extract_next_element, 8) -> 296;
+var_index(l_call_ext, 1) -> 297;
+var_index(l_new_bs_put_binary_all, 0) -> 298;
+var_index(l_move_call_ext_only, 7) -> 299;
+var_index(is_nil, 7) -> 300;
+var_index(deallocate_return, 6) -> 301;
+var_index(l_move_call_only, 4) -> 302;
+var_index(self, 1) -> 303;
+var_index(l_call_ext, 2) -> 304;
+var_index(l_select_val2, 5) -> 305;
+var_index(case_end, 2) -> 306;
+var_index(allocate_heap_zero, 0) -> 307;
+var_index(call_bif, 16) -> 308;
+var_index(is_nonempty_list, 11) -> 309;
+var_index(extract_next_element2, 5) -> 310;
+var_index(apply, 0) -> 311;
+var_index(try_end, 0) -> 312;
+var_index(l_move_call, 7) -> 313;
+var_index(call_bif, 17) -> 314;
+var_index(l_fast_element, 0) -> 315;
+var_index(test_heap_1_put_list, 1) -> 316;
+var_index(call_bif, 19) -> 317;
+var_index(call_bif, 18) -> 318;
+var_index(call_bif, 20) -> 319;
+var_index(l_bs_test_zero_tail2, 3) -> 320;
+var_index(l_move_call_ext, 10) -> 321;
+var_index(is_nil, 8) -> 322;
+var_index(get_tuple_element, 7) -> 323;
+var_index(call_bif, 21) -> 324;
+var_index(l_call_ext, 3) -> 325;
+var_index(catch_end, 2) -> 326;
+var_index(l_put_tuple, 5) -> 327;
+var_index(is_list, 1) -> 328;
+var_index(extract_next_element3, 2) -> 329;
+var_index(get_list, 7) -> 330;
+var_index(l_bif2, 0) -> 331;
+var_index(call_bif, 22) -> 332;
+var_index(init, 7) -> 333;
+var_index(try_end, 1) -> 334;
+var_index(l_bs_get_integer_32, 0) -> 335;
+var_index(test_arity, 2) -> 336;
+var_index(l_trim, 5) -> 337;
+var_index(l_increment, 4) -> 338;
+var_index(l_move_call, 8) -> 339;
+var_index(l_call_ext, 4) -> 340;
+var_index(extract_next_element, 9) -> 341;
+var_index(l_move_call_ext, 11) -> 342;
+var_index(l_is_ne_exact, 0) -> 343;
+var_index(l_bs_get_binary2, 0) -> 344;
+var_index(extract_next_element, 24) -> 345;
+var_index(is_integer, 1) -> 346;
+var_index(l_band, 0) -> 347;
+var_index(move_jump, 0) -> 348;
+var_index(l_is_eq_exact_immed, 12) -> 349;
+var_index(l_call_fun, 2) -> 350;
+var_index(move_deallocate_return, 5) -> 351;
+var_index(l_times, 1) -> 352;
+var_index(l_move_call_last, 3) -> 353;
+var_index(put_list, 7) -> 354;
+var_index(l_call_last, 7) -> 355;
+var_index(l_move_call_ext_only, 3) -> 356;
+var_index(l_fast_element, 2) -> 357;
+var_index(l_is_eq_exact_literal, 7) -> 358;
+var_index(extract_next_element, 10) -> 359;
+var_index(extract_next_element2, 6) -> 360;
+var_index(is_tuple, 2) -> 361;
+var_index(l_catch, 3) -> 362;
+var_index(l_call_ext, 5) -> 363;
+var_index(l_call_ext, 6) -> 364;
+var_index(l_bif2, 1) -> 365;
+var_index(l_is_eq_exact_immed, 13) -> 366;
+var_index(is_binary, 0) -> 367;
+var_index(l_call_ext, 7) -> 368;
+var_index(extract_next_element2, 7) -> 369;
+var_index(l_allocate_zero, 6) -> 370;
+var_index(l_bsr, 0) -> 371;
+var_index(l_fetch, 22) -> 372;
+var_index(move, 10) -> 373;
+var_index(extract_next_element3, 3) -> 374;
+var_index(l_is_eq_exact_immed, 14) -> 375;
+var_index(get_list, 5) -> 376;
+var_index(is_atom, 1) -> 377;
+var_index(extract_next_element3, 4) -> 378;
+var_index(l_bs_get_binary_all2, 0) -> 379;
+var_index(call_bif, 23) -> 380;
+var_index(l_move_call_only, 5) -> 381;
+var_index(call_bif, 24) -> 382;
+var_index(is_nonempty_list, 12) -> 383;
+var_index(l_is_eq_exact_immed, 15) -> 384;
+var_index(l_fetch, 8) -> 385;
+var_index(l_is_eq_exact_literal, 1) -> 386;
+var_index(l_move_call_ext, 12) -> 387;
+var_index(l_bs_get_integer_8, 0) -> 388;
+var_index(l_is_ne_exact_immed, 2) -> 389;
+var_index(put_list, 6) -> 390;
+var_index(is_nil, 9) -> 391;
+var_index(l_bsl, 0) -> 392;
+var_index(l_select_val2, 9) -> 393;
+var_index(is_list, 2) -> 394;
+var_index(l_allocate_zero, 9) -> 395;
+var_index(l_put_tuple, 6) -> 396;
+var_index(l_call_ext, 8) -> 397;
+var_index(l_bs_init_fail, 0) -> 398;
+var_index(get_list, 6) -> 399;
+var_index(l_bif2, 2) -> 400;
+var_index(deallocate_return, 7) -> 401;
+var_index(l_bs_get_integer_8, 1) -> 402;
+var_index(set_tuple_element, 1) -> 403;
+var_index(l_move_call_ext, 13) -> 404;
+var_index(l_select_val2, 16) -> 405;
+var_index(call_bif, 26) -> 406;
+var_index(call_bif, 25) -> 407;
+var_index(l_call_ext, 9) -> 408;
+var_index(l_move_call, 9) -> 409;
+var_index(l_is_eq_exact_literal, 2) -> 410;
+var_index(l_bs_get_integer_32, 1) -> 411;
+var_index(extract_next_element, 11) -> 412;
+var_index(l_is_eq_exact_literal, 3) -> 413;
+var_index(l_is_eq_exact_immed, 16) -> 414;
+var_index(l_fetch, 9) -> 415;
+var_index(l_bif2, 3) -> 416;
+var_index(is_nil, 10) -> 417;
+var_index(l_bsl, 1) -> 418;
+var_index(l_bs_test_zero_tail2, 5) -> 419;
+var_index(l_trim, 6) -> 420;
+var_index(l_rem, 0) -> 421;
+var_index(move2, 8) -> 422;
+var_index(l_move_call_ext, 14) -> 423;
+var_index(timeout, 0) -> 424;
+var_index(is_binary, 1) -> 425;
+var_index(catch_end, 3) -> 426;
+var_index(l_move_call_ext_last, 1) -> 427;
+var_index(l_call_last, 8) -> 428;
+var_index(l_allocate_zero, 7) -> 429;
+var_index(l_select_val2, 10) -> 430;
+var_index(l_fetch, 10) -> 431;
+var_index(l_fmul, 0) -> 432;
+var_index(l_bs_match_string, 2) -> 433;
+var_index(call_bif, 27) -> 434;
+var_index(extract_next_element3, 10) -> 435;
+var_index(l_gc_bif1, 2) -> 436;
+var_index(move_deallocate_return, 6) -> 437;
+var_index(l_allocate, 7) -> 438;
+var_index(l_move_call, 10) -> 439;
+var_index(l_catch, 4) -> 440;
+var_index(is_nonempty_list, 36) -> 441;
+var_index(l_bs_get_integer_small_imm, 0) -> 442;
+var_index(extract_next_element, 12) -> 443;
+var_index(l_is_eq_exact_immed, 36) -> 444;
+var_index(l_call_ext, 10) -> 445;
+var_index(move_jump, 1) -> 446;
+var_index(l_fcheckerror, 0) -> 447;
+var_index(fclearerror, 0) -> 448;
+var_index(move_return, 7) -> 449;
+var_index(l_bs_append, 0) -> 450;
+var_index(node, 0) -> 451;
+var_index(l_move_call, 11) -> 452;
+var_index(extract_next_element2, 16) -> 453;
+var_index(l_move_call_last, 4) -> 454;
+var_index(l_is_eq_exact_immed, 17) -> 455;
+var_index(l_call_ext, 11) -> 456;
+var_index(extract_next_element, 13) -> 457;
+var_index(l_move_call_ext_only, 2) -> 458;
+var_index(l_is_ne_exact_immed, 11) -> 459;
+var_index(l_is_eq_exact_immed, 18) -> 460;
+var_index(l_get, 1) -> 461;
+var_index(l_element, 2) -> 462;
+var_index(is_integer, 2) -> 463;
+var_index(is_integer, 7) -> 464;
+var_index(l_move_call_ext_last, 4) -> 465;
+var_index(l_bif2, 4) -> 466;
+var_index(l_move_call_ext, 16) -> 467;
+var_index(l_call_fun, 3) -> 468;
+var_index(l_move_call, 12) -> 469;
+var_index(call_bif, 28) -> 470;
+var_index(is_nonempty_list, 13) -> 471;
+var_index(try_end, 2) -> 472;
+var_index(is_nil, 11) -> 473;
+var_index(l_select_tuple_arity, 1) -> 474;
+var_index(is_tuple, 3) -> 475;
+var_index(l_move_call_ext_last, 2) -> 476;
+var_index(node, 1) -> 477;
+var_index(is_nonempty_list, 14) -> 478;
+var_index(l_bs_restore2, 1) -> 479;
+var_index(l_move_call_ext, 17) -> 480;
+var_index(l_band, 1) -> 481;
+var_index(l_is_eq_exact_immed, 19) -> 482;
+var_index(l_get, 4) -> 483;
+var_index(call_bif, 29) -> 484;
+var_index(call_bif, 1) -> 485;
+var_index(l_fetch, 11) -> 486;
+var_index(l_gc_bif1, 3) -> 487;
+var_index(is_nil, 12) -> 488;
+var_index(l_move_call_only, 6) -> 489;
+var_index(l_move_call, 13) -> 490;
+var_index(system_limit, 0) -> 491;
+var_index(l_element, 0) -> 492;
+var_index(l_select_tuple_arity, 0) -> 493;
+var_index(bif2_body, 1) -> 494;
+var_index(is_float, 1) -> 495;
+var_index(extract_next_element2, 8) -> 496;
+var_index(l_select_val2, 8) -> 497;
+var_index(is_integer_allocate, 0) -> 498;
+var_index(is_atom, 2) -> 499;
+var_index(l_int_div, 0) -> 500;
+var_index(l_get, 2) -> 501;
+var_index(l_gc_bif1, 5) -> 502;
+var_index(l_move_call_ext, 18) -> 503;
+var_index(is_nil, 29) -> 504;
+var_index(l_is_eq_exact_immed, 20) -> 505;
+var_index(call_bif, 30) -> 506;
+var_index(l_bor, 0) -> 507;
+var_index(l_bif1, 0) -> 508;
+var_index(l_catch, 5) -> 509;
+var_index(l_get, 0) -> 510;
+var_index(l_fetch, 12) -> 511;
+var_index(l_call_ext, 13) -> 512;
+var_index(l_call_ext, 12) -> 513;
+var_index(is_tuple, 9) -> 514;
+var_index(try_end, 3) -> 515;
+var_index(init, 8) -> 516;
+var_index(call_bif, 32) -> 517;
+var_index(call_bif, 31) -> 518;
+var_index(is_nil, 13) -> 519;
+var_index(apply_last, 0) -> 520;
+var_index(call_bif, 33) -> 521;
+var_index(l_int_div, 1) -> 522;
+var_index(call_bif, 34) -> 523;
+var_index(extract_next_element, 14) -> 524;
+var_index(put_list, 9) -> 525;
+var_index(is_nonempty_list, 15) -> 526;
+var_index(case_end, 11) -> 527;
+var_index(l_bs_skip_bits2, 0) -> 528;
+var_index(l_call_ext, 14) -> 529;
+var_index(deallocate_return, 8) -> 530;
+var_index(l_call_ext_last, 3) -> 531;
+var_index(l_move_call_ext, 19) -> 532;
+var_index(l_is_ne_exact_immed, 3) -> 533;
+var_index(extract_next_element3, 5) -> 534;
+var_index(is_integer, 3) -> 535;
+var_index(l_trim, 7) -> 536;
+var_index(l_is_eq_exact_immed, 21) -> 537;
+var_index(l_increment, 8) -> 538;
+var_index(call_bif, 4) -> 539;
+var_index(is_nonempty_list, 16) -> 540;
+var_index(is_list, 7) -> 541;
+var_index(l_element, 4) -> 542;
+var_index(extract_next_element3, 6) -> 543;
+var_index(l_is_eq_exact_literal, 4) -> 544;
+var_index(test_arity, 3) -> 545;
+var_index(move_deallocate_return, 7) -> 546;
+var_index(l_move_call_ext_only, 4) -> 547;
+var_index(l_fadd, 0) -> 548;
+var_index(l_call_ext, 16) -> 549;
+var_index(l_call_ext, 15) -> 550;
+var_index(try_end, 5) -> 551;
+var_index(try_end, 4) -> 552;
+var_index(l_move_call_ext, 20) -> 553;
+var_index(l_bs_match_string, 3) -> 554;
+var_index(call_bif, 35) -> 555;
+var_index(l_call_ext, 17) -> 556;
+var_index(fmove_1, 0) -> 557;
+var_index(l_increment, 6) -> 558;
+var_index(if_end, 0) -> 559;
+var_index(l_increment, 5) -> 560;
+var_index(l_call_ext, 18) -> 561;
+var_index(is_integer, 4) -> 562;
+var_index(l_bs_get_utf8, 0) -> 563;
+var_index(is_list, 3) -> 564;
+var_index(is_atom, 3) -> 565;
+var_index(l_fetch, 13) -> 566;
+var_index(l_bs_init_bits_fail, 0) -> 567;
+var_index(call_bif, 36) -> 568;
+var_index(l_call_ext, 19) -> 569;
+var_index(l_bs_test_zero_tail2, 4) -> 570;
+var_index(fconv, 0) -> 571;
+var_index(case_end, 3) -> 572;
+var_index(catch_end, 4) -> 573;
+var_index(l_make_export, 0) -> 574;
+var_index(l_rem, 1) -> 575;
+var_index(self, 2) -> 576;
+var_index(fmove_2, 0) -> 577;
+var_index(l_bor, 1) -> 578;
+var_index(l_call_ext_last, 4) -> 579;
+var_index(call_bif, 37) -> 580;
+var_index(l_call_last, 9) -> 581;
+var_index(bif1_body, 2) -> 582;
+var_index(is_binary, 2) -> 583;
+var_index(l_fetch, 14) -> 584;
+var_index(l_call_ext, 20) -> 585;
+var_index(l_move_call_ext, 21) -> 586;
+var_index(l_bs_skip_bits_all2, 0) -> 587;
+var_index(l_catch, 7) -> 588;
+var_index(l_move_call_ext, 22) -> 589;
+var_index(extract_next_element, 15) -> 590;
+var_index(badmatch, 4) -> 591;
+var_index(l_move_call, 14) -> 592;
+var_index(self, 5) -> 593;
+var_index(get_tuple_element, 8) -> 594;
+var_index(l_move_call_ext, 23) -> 595;
+var_index(l_move_call_ext, 24) -> 596;
+var_index(l_call_ext, 21) -> 597;
+var_index(l_move_call_only, 7) -> 598;
+var_index(put_list, 8) -> 599;
+var_index(l_is_eq_exact_immed, 22) -> 600;
+var_index(is_nonempty_list_test_heap, 0) -> 601;
+var_index(is_tuple, 4) -> 602;
+var_index(extract_next_element2, 9) -> 603;
+var_index(case_end, 4) -> 604;
+var_index(l_is_function2, 0) -> 605;
+var_index(bif2_body, 3) -> 606;
+var_index(fmove_2, 1) -> 607;
+var_index(l_call_ext, 22) -> 608;
+var_index(extract_next_element, 16) -> 609;
+var_index(extract_next_element2, 10) -> 610;
+var_index(move_jump, 2) -> 611;
+var_index(move_return, 8) -> 612;
+var_index(is_nonempty_list, 17) -> 613;
+var_index(is_pid, 0) -> 614;
+var_index(l_jump_on_val, 0) -> 615;
+var_index(l_get, 3) -> 616;
+var_index(bif1_body, 3) -> 617;
+var_index(l_select_val2, 11) -> 618;
+var_index(l_allocate_zero, 8) -> 619;
+var_index(is_list, 4) -> 620;
+var_index(l_is_ne_exact_immed, 4) -> 621;
+var_index(fmove_1, 2) -> 622;
+var_index(bif1_body, 4) -> 623;
+var_index(fmove_1, 1) -> 624;
+var_index(is_nonempty_list, 18) -> 625;
+var_index(l_bs_test_unit_8, 3) -> 626;
+var_index(l_fetch, 15) -> 627;
+var_index(l_is_eq_exact_immed, 24) -> 628;
+var_index(put_list, 10) -> 629;
+var_index(call_bif, 38) -> 630;
+var_index(l_gc_bif1, 4) -> 631;
+var_index(extract_next_element, 17) -> 632;
+var_index(is_atom, 6) -> 633;
+var_index(l_move_call, 15) -> 634;
+var_index(l_allocate, 10) -> 635;
+var_index(l_move_call_ext_last, 3) -> 636;
+var_index(l_call_ext, 23) -> 637;
+var_index(l_element, 1) -> 638;
+var_index(move_deallocate_return, 8) -> 639;
+var_index(l_new_bs_put_integer, 0) -> 640;
+var_index(l_call_ext, 24) -> 641;
+var_index(l_move_call_last, 5) -> 642;
+var_index(l_move_call_ext, 25) -> 643;
+var_index(init, 9) -> 644;
+var_index(l_allocate, 8) -> 645;
+var_index(l_call_ext, 25) -> 646;
+var_index(l_fdiv, 0) -> 647;
+var_index(bs_context_to_binary, 4) -> 648;
+var_index(l_bif2, 6) -> 649;
+var_index(l_call_ext_last, 6) -> 650;
+var_index(get_list, 8) -> 651;
+var_index(node, 4) -> 652;
+var_index(l_call_ext, 26) -> 653;
+var_index(extract_next_element, 18) -> 654;
+var_index(deallocate_return, 9) -> 655;
+var_index(l_move_call_ext, 15) -> 656;
+var_index(is_binary, 3) -> 657;
+var_index(move_deallocate_return, 9) -> 658;
+var_index(l_call_ext, 27) -> 659;
+var_index(is_nonempty_list, 19) -> 660;
+var_index(l_select_val_atoms, 2) -> 661;
+var_index(badmatch, 17) -> 662;
+var_index(call_bif, 39) -> 663;
+var_index(l_call_ext, 28) -> 664;
+var_index(extract_next_element2, 11) -> 665;
+var_index(badmatch, 5) -> 666;
+var_index(case_end, 5) -> 667;
+var_index(l_bs_restore2, 2) -> 668;
+var_index(l_fetch, 16) -> 669;
+var_index(l_bs_get_integer, 0) -> 670;
+var_index(l_is_eq_exact_immed, 25) -> 671;
+var_index(l_call_ext, 29) -> 672;
+var_index(move_return, 9) -> 673;
+var_index(is_function, 2) -> 674;
+var_index(l_bif1, 2) -> 675;
+var_index(l_move_call_ext, 26) -> 676;
+var_index(call_bif, 40) -> 677;
+var_index(l_call_ext, 30) -> 678;
+var_index(case_end, 6) -> 679;
+var_index(l_move_call_ext, 27) -> 680;
+var_index(catch_end, 5) -> 681;
+var_index(l_bs_get_binary_imm2, 0) -> 682;
+var_index(l_move_call_ext, 28) -> 683;
+var_index(call_bif, 42) -> 684;
+var_index(call_bif, 41) -> 685;
+var_index(l_call_ext, 32) -> 686;
+var_index(l_call_ext, 31) -> 687;
+var_index(l_bs_test_unit_8, 1) -> 688;
+var_index(l_move_call, 16) -> 689;
+var_index(l_bsr, 1) -> 690;
+var_index(l_move_call_ext, 29) -> 691;
+var_index(l_bs_skip_bits_imm2, 0) -> 692;
+var_index(l_move_call_ext, 30) -> 693;
+var_index(l_call_ext, 34) -> 694;
+var_index(l_call_ext, 33) -> 695;
+var_index(is_nil, 15) -> 696;
+var_index(is_nil, 14) -> 697;
+var_index(badmatch, 6) -> 698;
+var_index(l_call_last, 11) -> 699;
+var_index(fconv, 1) -> 700;
+var_index(is_boolean, 0) -> 701;
+var_index(l_is_ne_exact_immed, 5) -> 702;
+var_index(call_bif, 43) -> 703;
+var_index(l_call_ext, 35) -> 704;
+var_index(is_nil, 16) -> 705;
+var_index(l_move_call_only, 8) -> 706;
+var_index(l_bs_test_unit_8, 2) -> 707;
+var_index(catch_end, 7) -> 708;
+var_index(l_bs_get_utf16, 1) -> 709;
+var_index(get_list, 9) -> 710;
+var_index(l_plus, 2) -> 711;
+var_index(deallocate_return, 12) -> 712;
+var_index(l_element, 3) -> 713;
+var_index(move_jump, 3) -> 714;
+var_index(l_bs_put_string, 0) -> 715;
+var_index(is_pid, 1) -> 716;
+var_index(is_atom, 4) -> 717;
+var_index(l_select_tuple_arity, 2) -> 718;
+var_index(l_call_ext, 36) -> 719;
+var_index(extract_next_element, 19) -> 720;
+var_index(case_end, 7) -> 721;
+var_index(l_catch, 6) -> 722;
+var_index(l_call_ext, 38) -> 723;
+var_index(l_call_ext, 37) -> 724;
+var_index(move_jump, 4) -> 725;
+var_index(is_nil, 17) -> 726;
+var_index(is_list, 5) -> 727;
+var_index(try_case_end, 0) -> 728;
+var_index(l_bs_get_binary_all2, 1) -> 729;
+var_index(move, 11) -> 730;
+var_index(l_move_call_last, 6) -> 731;
+var_index(put_list, 14) -> 732;
+var_index(move_jump, 5) -> 733;
+var_index(move_return, 10) -> 734;
+var_index(l_is_eq_exact_literal, 5) -> 735;
+var_index(bif2_body, 2) -> 736;
+var_index(get_tuple_element, 9) -> 737;
+var_index(put_list, 11) -> 738;
+var_index(l_select_val2, 12) -> 739;
+var_index(call_bif, 44) -> 740;
+var_index(is_nonempty_list, 20) -> 741;
+var_index(l_fsub, 0) -> 742;
+var_index(l_move_call_ext, 31) -> 743;
+var_index(bif1_body, 5) -> 744;
+var_index(l_call_ext, 39) -> 745;
+var_index(extract_next_element3, 7) -> 746;
+var_index(l_bs_start_match2, 3) -> 747;
+var_index(l_trim, 8) -> 748;
+var_index(bs_context_to_binary, 1) -> 749;
+var_index(l_call_ext, 40) -> 750;
+var_index(move_return, 11) -> 751;
+var_index(l_call_fun, 4) -> 752;
+var_index(l_is_eq_exact_literal, 6) -> 753;
+var_index(l_is_ne_exact_immed, 6) -> 754;
+var_index(test_heap_1_put_list, 2) -> 755;
+var_index(test_heap_1_put_list, 3) -> 756;
+var_index(l_is_eq_exact_immed, 26) -> 757;
+var_index(self, 3) -> 758;
+var_index(l_call_ext, 41) -> 759;
+var_index(l_move_call_ext, 33) -> 760;
+var_index(init, 10) -> 761;
+var_index(l_bs_skip_bits_imm2, 1) -> 762;
+var_index(l_call_ext, 42) -> 763;
+var_index(extract_next_element2, 12) -> 764;
+var_index(badmatch, 7) -> 765;
+var_index(l_move_call_ext_only, 5) -> 766;
+var_index(l_call_ext, 43) -> 767;
+var_index(move_jump, 6) -> 768;
+var_index(is_nil, 18) -> 769;
+var_index(l_call_ext_only, 0) -> 770;
+var_index(l_fetch, 17) -> 771;
+var_index(l_move_call_ext, 34) -> 772;
+var_index(l_move_call_ext, 35) -> 773;
+var_index(l_is_eq_exact_immed, 27) -> 774;
+var_index(l_bs_append, 1) -> 775;
+var_index(l_bif2, 5) -> 776;
+var_index(l_bs_get_binary2, 1) -> 777;
+var_index(l_bs_get_integer_small_imm, 1) -> 778;
+var_index(l_call_ext, 47) -> 779;
+var_index(l_call_ext, 46) -> 780;
+var_index(l_call_ext, 45) -> 781;
+var_index(l_call_ext, 44) -> 782;
+var_index(move_return, 12) -> 783;
+var_index(l_bs_save2, 1) -> 784;
+var_index(is_function, 0) -> 785;
+var_index(l_bs_get_integer_imm, 0) -> 786;
+var_index(l_move_call_ext_only, 6) -> 787;
+var_index(l_call_ext, 48) -> 788;
+var_index(l_move_call, 17) -> 789;
+var_index(l_is_ne_exact_immed, 7) -> 790;
+var_index(l_call_ext, 50) -> 791;
+var_index(l_call_ext, 49) -> 792;
+var_index(is_integer, 5) -> 793;
+var_index(move_return, 13) -> 794;
+var_index(l_bs_put_string, 1) -> 795;
+var_index(try_end, 7) -> 796;
+var_index(l_yield, 0) -> 797;
+var_index(l_move_call, 18) -> 798;
+var_index(l_fetch, 18) -> 799;
+var_index(l_is_eq_exact_immed, 28) -> 800;
+var_index(l_new_bs_put_integer, 1) -> 801;
+var_index(node, 2) -> 802;
+var_index(l_call_ext, 51) -> 803;
+var_index(move_jump, 7) -> 804;
+var_index(case_end, 9) -> 805;
+var_index(case_end, 8) -> 806;
+var_index(is_nonempty_list, 22) -> 807;
+var_index(is_nonempty_list, 21) -> 808;
+var_index(l_move_call, 19) -> 809;
+var_index(l_move_call_ext, 37) -> 810;
+var_index(get_list, 11) -> 811;
+var_index(l_fetch, 19) -> 812;
+var_index(l_new_bs_put_float_imm, 1) -> 813;
+var_index(l_move_call, 20) -> 814;
+var_index(l_call_ext_only, 1) -> 815;
+var_index(l_gc_bif1, 6) -> 816;
+var_index(l_bif1, 1) -> 817;
+var_index(l_move_call, 21) -> 818;
+var_index(l_is_ne_exact_literal, 0) -> 819;
+var_index(l_bs_put_string, 2) -> 820;
+var_index(l_call_ext, 52) -> 821;
+var_index(l_is_eq_exact_immed, 23) -> 822;
+var_index(extract_next_element, 20) -> 823;
+var_index(is_nil, 19) -> 824;
+var_index(badmatch, 8) -> 825;
+var_index(catch_end, 6) -> 826;
+var_index(l_is_function2, 1) -> 827;
+var_index(l_call_ext, 53) -> 828;
+var_index(move_return, 14) -> 829;
+var_index(badmatch, 9) -> 830;
+var_index(self, 4) -> 831;
+var_index(l_call_ext, 56) -> 832;
+var_index(l_call_ext, 55) -> 833;
+var_index(l_call_ext, 54) -> 834;
+var_index(l_call_ext_last, 5) -> 835;
+var_index(l_move_call, 23) -> 836;
+var_index(l_move_call, 22) -> 837;
+var_index(l_select_tuple_arity, 3) -> 838;
+var_index(l_apply, 0) -> 839;
+var_index(init, 16) -> 840;
+var_index(init, 11) -> 841;
+var_index(l_move_call_last, 8) -> 842;
+var_index(l_move_call_last, 7) -> 843;
+var_index(l_call_ext, 59) -> 844;
+var_index(l_call_ext, 58) -> 845;
+var_index(l_call_ext, 57) -> 846;
+var_index(extract_next_element2, 13) -> 847;
+var_index(l_new_bs_put_integer_imm, 1) -> 848;
+var_index(try_end, 6) -> 849;
+var_index(deallocate_return, 10) -> 850;
+var_index(l_move_call, 24) -> 851;
+var_index(l_fetch, 20) -> 852;
+var_index(get_list, 10) -> 853;
+var_index(l_allocate, 9) -> 854;
+var_index(bs_init_writable, 0) -> 855;
+var_index(l_call_ext, 60) -> 856;
+var_index(extract_next_element, 21) -> 857;
+var_index(extract_next_element3, 8) -> 858;
+var_index(is_integer, 6) -> 859;
+var_index(move_jump, 8) -> 860;
+var_index(badmatch, 10) -> 861;
+var_index(is_nonempty_list, 23) -> 862;
+var_index(l_bs_private_append, 0) -> 863;
+var_index(deallocate_return, 11) -> 864;
+var_index(l_move_call, 25) -> 865;
+var_index(l_call_ext, 63) -> 866;
+var_index(l_call_ext, 62) -> 867;
+var_index(l_call_ext, 61) -> 868;
+var_index(move_jump, 9) -> 869;
+var_index(move_return, 16) -> 870;
+var_index(move_return, 15) -> 871;
+var_index(bs_context_to_binary, 2) -> 872;
+var_index(l_jump_on_val, 1) -> 873;
+var_index(l_increment, 7) -> 874;
+var_index(l_is_ne_exact_immed, 8) -> 875;
+var_index(l_call_ext, 67) -> 876;
+var_index(l_call_ext, 66) -> 877;
+var_index(l_call_ext, 65) -> 878;
+var_index(l_call_ext, 64) -> 879;
+var_index(extract_next_element2, 14) -> 880;
+var_index(put_list, 13) -> 881;
+var_index(is_float, 0) -> 882;
+var_index(l_is_eq_exact_immed, 29) -> 883;
+var_index(l_select_val2, 14) -> 884;
+var_index(l_call_ext, 69) -> 885;
+var_index(l_call_ext, 68) -> 886;
+var_index(extract_next_element3, 9) -> 887;
+var_index(move_return, 17) -> 888;
+var_index(is_nonempty_list, 25) -> 889;
+var_index(is_nonempty_list, 24) -> 890;
+var_index(l_select_tuple_arity2, 2) -> 891;
+var_index(is_atom, 5) -> 892;
+var_index(l_call_ext_only, 2) -> 893;
+var_index(l_is_ne_exact_immed, 9) -> 894;
+var_index(node, 3) -> 895;
+var_index(is_tuple, 5) -> 896;
+var_index(l_call_ext, 73) -> 897;
+var_index(l_call_ext, 72) -> 898;
+var_index(l_call_ext, 71) -> 899;
+var_index(l_call_ext, 70) -> 900;
+var_index(extract_next_element, 22) -> 901;
+var_index(wait_timeout, 0) -> 902;
+var_index(extract_next_element2, 15) -> 903;
+var_index(is_nil, 20) -> 904;
+var_index(is_nonempty_list, 26) -> 905;
+var_index(l_wait_timeout, 2) -> 906;
+var_index(l_minus, 2) -> 907;
+var_index(is_tuple, 6) -> 908;
+var_index(l_call_ext, 79) -> 909;
+var_index(l_call_ext, 78) -> 910;
+var_index(l_call_ext, 77) -> 911;
+var_index(l_call_ext, 76) -> 912;
+var_index(l_call_ext, 75) -> 913;
+var_index(l_call_ext, 74) -> 914;
+var_index(l_call_last, 10) -> 915;
+var_index(l_bs_test_tail_imm2, 0) -> 916;
+var_index(move_jump, 10) -> 917;
+var_index(move_return, 18) -> 918;
+var_index(is_integer_allocate, 1) -> 919;
+var_index(is_nonempty_list, 27) -> 920;
+var_index(l_new_bs_put_float_imm, 0) -> 921;
+var_index(l_fetch, 21) -> 922;
+var_index(move, 12) -> 923;
+var_index(move2, 9) -> 924;
+var_index(l_bs_skip_bits_all2, 1) -> 925;
+var_index(is_tuple, 7) -> 926;
+var_index(l_call_ext, 84) -> 927;
+var_index(l_call_ext, 83) -> 928;
+var_index(l_call_ext, 82) -> 929;
+var_index(l_call_ext, 81) -> 930;
+var_index(l_call_ext, 80) -> 931;
+var_index(l_is_eq_exact_immed, 30) -> 932;
+var_index(is_nil, 21) -> 933;
+var_index(recv_mark, 0) -> 934;
+var_index(raise, 1) -> 935;
+var_index(case_end, 10) -> 936;
+var_index(is_function, 1) -> 937;
+var_index(l_call_ext_only, 3) -> 938;
+var_index(l_recv_set, 0) -> 939;
+var_index(l_bs_skip_bits_all2, 2) -> 940;
+var_index(l_fast_element, 3) -> 941;
+var_index(l_trim, 11) -> 942;
+var_index(l_times, 2) -> 943;
+var_index(bs_context_to_binary, 3) -> 944;
+var_index(l_move_call_ext, 32) -> 945;
+var_index(l_is_eq_exact_immed, 31) -> 946;
+var_index(is_port, 0) -> 947;
+var_index(l_bs_get_float2, 0) -> 948;
+var_index(l_bs_get_utf8, 1) -> 949;
+var_index(l_select_val2, 15) -> 950;
+var_index(l_select_tuple_arity, 4) -> 951;
+var_index(test_heap_1_put_list, 4) -> 952;
+var_index(is_map, 0) -> 953;
+var_index(l_trim, 9) -> 954;
+var_index(badmatch, 11) -> 955;
+var_index(l_apply_fun, 0) -> 956;
+var_index(init, 12) -> 957;
+var_index(l_is_eq_exact_immed, 32) -> 958;
+var_index(extract_next_element, 23) -> 959;
+var_index(l_move_call_only, 10) -> 960;
+var_index(l_move_call_only, 9) -> 961;
+var_index(l_is_eq_exact_immed, 33) -> 962;
+var_index(l_is_ne_exact_immed, 10) -> 963;
+var_index(move_return, 19) -> 964;
+var_index(badmatch, 13) -> 965;
+var_index(badmatch, 12) -> 966;
+var_index(l_bs_get_integer_16, 0) -> 967;
+var_index(l_bs_get_binary_all_reuse, 1) -> 968;
+var_index(l_is_eq_exact_immed, 34) -> 969;
+var_index(move_jump, 11) -> 970;
+var_index(move_return, 21) -> 971;
+var_index(move_return, 20) -> 972;
+var_index(l_move_call_only, 11) -> 973;
+var_index(badmatch, 14) -> 974;
+var_index(is_list, 6) -> 975;
+var_index(l_bs_init_fail, 1) -> 976;
+var_index(l_move_call_ext, 36) -> 977;
+var_index(is_tuple, 8) -> 978;
+var_index(move_jump, 13) -> 979;
+var_index(move_jump, 12) -> 980;
+var_index(move_return, 22) -> 981;
+var_index(is_nil, 22) -> 982;
+var_index(is_nonempty_list, 29) -> 983;
+var_index(is_nonempty_list, 28) -> 984;
+var_index(l_bs_init, 0) -> 985;
+var_index(l_bs_restore2, 3) -> 986;
+var_index(move, 13) -> 987;
+var_index(l_bs_get_binary_imm2, 1) -> 988;
+var_index(is_nonempty_list, 30) -> 989;
+var_index(l_bs_init_bits, 0) -> 990;
+var_index(l_bs_put_utf16, 0) -> 991;
+var_index(is_bitstr, 0) -> 992;
+var_index(l_bs_validate_unicode, 0) -> 993;
+var_index(is_nonempty_list, 32) -> 994;
+var_index(is_nonempty_list, 31) -> 995;
+var_index(l_bs_save2, 2) -> 996;
+var_index(l_bs_utf16_size, 0) -> 997;
+var_index(l_bs_get_binary2, 2) -> 998;
+var_index(l_is_eq_exact_immed, 35) -> 999;
+var_index(get_tuple_element, 10) -> 1000;
+var_index(l_bs_get_integer_32, 2) -> 1001;
+var_index(move_return, 24) -> 1002;
+var_index(move_return, 23) -> 1003;
+var_index(is_nil, 23) -> 1004;
+var_index(badmatch, 15) -> 1005;
+var_index(is_nonempty_list, 33) -> 1006;
+var_index(move, 14) -> 1007;
+var_index(l_bs_add, 1) -> 1008;
+var_index(is_reference, 0) -> 1009;
+var_index(is_nil, 26) -> 1010;
+var_index(is_nil, 25) -> 1011;
+var_index(is_nil, 24) -> 1012;
+var_index(l_new_bs_put_binary, 0) -> 1013;
+var_index(badmatch, 16) -> 1014;
+var_index(is_nonempty_list, 34) -> 1015;
+var_index(init, 13) -> 1016;
+var_index(is_nil, 28) -> 1017;
+var_index(is_nil, 27) -> 1018;
+var_index(put_list, 12) -> 1019;
+var_index(is_nonempty_list, 35) -> 1020;
+var_index(l_bs_validate_unicode_retract, 0) -> 1021;
+var_index(l_wait_timeout, 0) -> 1022;
+var_index(l_gc_bif2, 0) -> 1023;
+var_index(init, 14) -> 1024;
+var_index(l_fast_element, 4) -> 1025;
+var_index(l_trim, 10) -> 1026;
+var_index(l_new_bs_put_binary_all, 1) -> 1027;
+var_index(l_apply_last, 0) -> 1028;
+var_index(init, 15) -> 1029;
+var_index(is_number, 0) -> 1030;
+var_index(l_int_bnot, 0) -> 1031;
+var_index(l_bs_put_utf8, 0) -> 1032;
+var_index(l_new_bs_put_float, 0) -> 1033;
+var_index(l_select_val2, 13) -> 1034;
+var_index(l_bs_utf8_size, 0) -> 1035;
+var_index(l_wait_timeout, 1) -> 1036;
+var_index(fmove_2, 2) -> 1037;
+var_index(l_jump_on_val, 2) -> 1038;
+var_index(l_bs_get_binary_imm2, 2) -> 1039;
+var_index(l_fnegate, 0) -> 1040;
+var_index(get_list, 12) -> 1041;
+var_index(l_bs_get_integer_imm, 1) -> 1042;
+var_index(bif1_body, 6) -> 1043;
+var_index(l_bs_get_binary_all_reuse, 2) -> 1044;
+var_index(l_bxor, 0) -> 1045;
+var_index(l_new_bs_put_integer_imm, 2) -> 1046;
+var_index(l_int_div, 2) -> 1047;
+var_index(l_gc_bif3, 0) -> 1048;
+var_index(l_apply_only, 0) -> 1049;
+var_index(l_bor, 2) -> 1050;
+var_index(l_bs_start_match2, 4) -> 1051;
+var_index(l_rem, 2) -> 1052;
+var_index(l_bsl, 2) -> 1053;
+var_index(l_new_bs_put_binary_imm, 0) -> 1054;
+var_index(l_apply_fun_only, 0) -> 1055;
+var_index(l_bs_get_integer_8, 2) -> 1056;
+var_index(l_bs_get_integer_small_imm, 2) -> 1057;
+var_index(l_hibernate, 0) -> 1058;
+var_index(l_apply_fun_last, 0) -> 1059;
+var_index(l_band, 2) -> 1060;
+var_index(is_bigint, 0) -> 1061;
+var_index(on_load, 0) -> 1062;
+var_index(move2, 10) -> 1063;
+var_index(l_bs_test_unit, 0) -> 1064;
+var_index(l_m_div, 0) -> 1065;
+var_index(l_select_val_smallints, 2) -> 1066;
+var_index(is_function2, 0) -> 1067;
+var_index(test_heap, 1) -> 1068;
+var_index(func_info, 0) -> 1069;
+var_index(call_bif, 0) -> 1070;
+var_index(l_bs_get_utf16, 2) -> 1071;
+var_index(l_put_tuple, 7) -> 1072;
+var_index(allocate_init, 1) -> 1073;
+var_index(l_call_fun_last, 1) -> 1074;
+var_index(set_tuple_element, 2) -> 1075;
+var_index(allocate_heap, 1) -> 1076;
+var_index(is_tuple_of_arity, 4) -> 1077;
+var_index(test_arity, 4) -> 1078;
+var_index(l_bs_match_string, 4) -> 1079;
+var_index(is_nonempty_list_allocate, 2) -> 1080;
+var_index(l_bs_append, 2) -> 1081;
+var_index(try_case_end, 1) -> 1082;
+var_index(init3, 1) -> 1083;
+var_index(l_select_tuple_arity2, 3) -> 1084;
+var_index(init2, 1) -> 1085;
+var_index(l_is_function2, 2) -> 1086;
+var_index(l_bs_get_binary_all2, 2) -> 1087;
+var_index(is_nonempty_list_test_heap, 1) -> 1088;
+var_index(allocate_heap_zero, 1) -> 1089;
+var_index(l_bs_init_heap_bin, 1) -> 1090;
+var_index(l_plus, 3) -> 1091;
+var_index(l_bs_get_integer, 1) -> 1092;
+
+var_index(Op, No) -> erlang:error({noindex,Op,No}).
+
+var_by_index(0) -> {move, 0};
+var_by_index(1) -> {move, 1};
+var_by_index(2) -> {l_call, 0};
+var_by_index(3) -> {test_heap, 0};
+var_by_index(4) -> {move, 2};
+var_by_index(5) -> {badmatch, 0};
+var_by_index(6) -> {move, 3};
+var_by_index(7) -> {l_put_tuple, 0};
+var_by_index(8) -> {move, 4};
+var_by_index(9) -> {move2, 1};
+var_by_index(10) -> {get_tuple_element, 0};
+var_by_index(11) -> {move2, 0};
+var_by_index(12) -> {put_list, 0};
+var_by_index(13) -> {is_tuple_of_arity, 1};
+var_by_index(14) -> {get_tuple_element, 1};
+var_by_index(15) -> {l_call_only, 0};
+var_by_index(16) -> {call_bif, 7};
+var_by_index(17) -> {l_bs_start_match2, 0};
+var_by_index(18) -> {l_bs_test_zero_tail2, 0};
+var_by_index(19) -> {l_bs_match_string, 0};
+var_by_index(20) -> {l_is_eq_exact_immed, 0};
+var_by_index(21) -> {put_list, 1};
+var_by_index(22) -> {is_tuple_of_arity, 0};
+var_by_index(23) -> {l_is_eq_exact_immed, 1};
+var_by_index(24) -> {get_list, 0};
+var_by_index(25) -> {l_put_tuple, 1};
+var_by_index(26) -> {move, 5};
+var_by_index(27) -> {l_call_ext, 85};
+var_by_index(28) -> {l_move_call_ext, 0};
+var_by_index(29) -> {return, 0};
+var_by_index(30) -> {move2, 2};
+var_by_index(31) -> {l_is_ge, 0};
+var_by_index(32) -> {l_move_call_last, 0};
+var_by_index(33) -> {l_make_fun, 0};
+var_by_index(34) -> {is_tuple_of_arity, 2};
+var_by_index(35) -> {extract_next_element2, 0};
+var_by_index(36) -> {move_deallocate_return, 0};
+var_by_index(37) -> {call_bif, 3};
+var_by_index(38) -> {l_allocate, 0};
+var_by_index(39) -> {l_fetch, 0};
+var_by_index(40) -> {l_trim, 0};
+var_by_index(41) -> {is_nil, 0};
+var_by_index(42) -> {is_nonempty_list, 0};
+var_by_index(43) -> {move_return, 25};
+var_by_index(44) -> {l_move_call_ext, 1};
+var_by_index(45) -> {deallocate_return, 0};
+var_by_index(46) -> {case_end, 0};
+var_by_index(47) -> {get_list, 1};
+var_by_index(48) -> {l_allocate, 1};
+var_by_index(49) -> {l_fetch, 1};
+var_by_index(50) -> {jump, 0};
+var_by_index(51) -> {extract_next_element, 0};
+var_by_index(52) -> {put_list, 3};
+var_by_index(53) -> {l_is_eq_exact_immed, 2};
+var_by_index(54) -> {move2, 3};
+var_by_index(55) -> {l_fetch, 2};
+var_by_index(56) -> {l_is_eq_exact, 0};
+var_by_index(57) -> {call_bif, 8};
+var_by_index(58) -> {l_allocate, 2};
+var_by_index(59) -> {l_is_eq_exact_immed, 3};
+var_by_index(60) -> {get_tuple_element, 2};
+var_by_index(61) -> {l_move_call, 26};
+var_by_index(62) -> {deallocate_return, 1};
+var_by_index(63) -> {move_return, 0};
+var_by_index(64) -> {init2, 0};
+var_by_index(65) -> {get_tuple_element, 3};
+var_by_index(66) -> {put_list, 2};
+var_by_index(67) -> {init, 0};
+var_by_index(68) -> {move2, 4};
+var_by_index(69) -> {l_is_eq_exact_immed, 4};
+var_by_index(70) -> {call_bif, 9};
+var_by_index(71) -> {l_fetch, 3};
+var_by_index(72) -> {deallocate_return, 2};
+var_by_index(73) -> {extract_next_element, 1};
+var_by_index(74) -> {is_nonempty_list, 1};
+var_by_index(75) -> {put_list, 4};
+var_by_index(76) -> {l_put_tuple, 2};
+var_by_index(77) -> {l_allocate, 3};
+var_by_index(78) -> {is_tuple_of_arity, 3};
+var_by_index(79) -> {move2, 5};
+var_by_index(80) -> {init, 1};
+var_by_index(81) -> {get_tuple_element, 4};
+var_by_index(82) -> {l_fetch, 4};
+var_by_index(83) -> {init3, 0};
+var_by_index(84) -> {get_list, 2};
+var_by_index(85) -> {l_move_call_ext, 38};
+var_by_index(86) -> {allocate_init, 0};
+var_by_index(87) -> {l_is_eq_exact_immed, 5};
+var_by_index(88) -> {l_trim, 1};
+var_by_index(89) -> {test_heap_1_put_list, 0};
+var_by_index(90) -> {l_is_lt, 0};
+var_by_index(91) -> {l_is_eq_exact_literal, 0};
+var_by_index(92) -> {call_bif, 6};
+var_by_index(93) -> {call_bif, 45};
+var_by_index(94) -> {l_allocate_zero, 0};
+var_by_index(95) -> {allocate_heap, 0};
+var_by_index(96) -> {is_tuple, 0};
+var_by_index(97) -> {move_return, 1};
+var_by_index(98) -> {is_nonempty_list, 2};
+var_by_index(99) -> {l_allocate_zero, 1};
+var_by_index(100) -> {move, 6};
+var_by_index(101) -> {l_call_last, 0};
+var_by_index(102) -> {init, 2};
+var_by_index(103) -> {l_gc_bif1, 0};
+var_by_index(104) -> {deallocate_return, 3};
+var_by_index(105) -> {get_tuple_element, 5};
+var_by_index(106) -> {l_increment, 0};
+var_by_index(107) -> {call_bif, 2};
+var_by_index(108) -> {is_nonempty_list_allocate, 0};
+var_by_index(109) -> {l_select_val_atoms, 0};
+var_by_index(110) -> {l_move_call, 0};
+var_by_index(111) -> {l_is_eq_exact_immed, 6};
+var_by_index(112) -> {call_bif, 5};
+var_by_index(113) -> {move_deallocate_return, 1};
+var_by_index(114) -> {is_nonempty_list, 3};
+var_by_index(115) -> {extract_next_element, 2};
+var_by_index(116) -> {is_list, 0};
+var_by_index(117) -> {l_select_val2, 3};
+var_by_index(118) -> {l_fetch, 5};
+var_by_index(119) -> {extract_next_element3, 0};
+var_by_index(120) -> {is_nil, 1};
+var_by_index(121) -> {move_deallocate_return, 2};
+var_by_index(122) -> {l_call_last, 1};
+var_by_index(123) -> {l_trim, 2};
+var_by_index(124) -> {l_call_last, 2};
+var_by_index(125) -> {get_list, 3};
+var_by_index(126) -> {l_select_val2, 0};
+var_by_index(127) -> {l_move_call_only, 12};
+var_by_index(128) -> {is_nil, 2};
+var_by_index(129) -> {move2, 6};
+var_by_index(130) -> {l_allocate, 4};
+var_by_index(131) -> {l_move_call_only, 0};
+var_by_index(132) -> {extract_next_element2, 1};
+var_by_index(133) -> {move_return, 2};
+var_by_index(134) -> {test_arity, 0};
+var_by_index(135) -> {move2, 7};
+var_by_index(136) -> {l_call_ext, 0};
+var_by_index(137) -> {l_new_bs_put_integer_imm, 0};
+var_by_index(138) -> {l_select_val2, 4};
+var_by_index(139) -> {l_move_call_only, 1};
+var_by_index(140) -> {l_select_val2, 1};
+var_by_index(141) -> {remove_message, 0};
+var_by_index(142) -> {init, 3};
+var_by_index(143) -> {l_allocate_zero, 2};
+var_by_index(144) -> {l_plus, 0};
+var_by_index(145) -> {l_catch, 0};
+var_by_index(146) -> {deallocate_return, 4};
+var_by_index(147) -> {is_nonempty_list, 4};
+var_by_index(148) -> {bif1_body, 0};
+var_by_index(149) -> {l_put_tuple, 3};
+var_by_index(150) -> {extract_next_element, 3};
+var_by_index(151) -> {l_is_eq_exact_immed, 7};
+var_by_index(152) -> {move_jump, 14};
+var_by_index(153) -> {move, 7};
+var_by_index(154) -> {l_allocate_zero, 3};
+var_by_index(155) -> {l_move_call_only, 2};
+var_by_index(156) -> {l_select_tuple_arity2, 0};
+var_by_index(157) -> {l_bs_start_match2, 1};
+var_by_index(158) -> {catch_end, 0};
+var_by_index(159) -> {move_return, 3};
+var_by_index(160) -> {is_nonempty_list, 5};
+var_by_index(161) -> {l_is_eq_exact_immed, 8};
+var_by_index(162) -> {l_call_last, 3};
+var_by_index(163) -> {l_move_call_only, 3};
+var_by_index(164) -> {l_call_last, 4};
+var_by_index(165) -> {get_list, 4};
+var_by_index(166) -> {move_return, 4};
+var_by_index(167) -> {move, 8};
+var_by_index(168) -> {test_arity, 1};
+var_by_index(169) -> {move_return, 5};
+var_by_index(170) -> {is_nonempty_list, 6};
+var_by_index(171) -> {l_call_fun, 0};
+var_by_index(172) -> {l_increment, 1};
+var_by_index(173) -> {put_list, 5};
+var_by_index(174) -> {init, 4};
+var_by_index(175) -> {l_is_eq, 0};
+var_by_index(176) -> {l_select_val2, 2};
+var_by_index(177) -> {l_move_call_ext, 2};
+var_by_index(178) -> {l_call_ext_only, 4};
+var_by_index(179) -> {l_bs_get_binary_all_reuse, 0};
+var_by_index(180) -> {send, 0};
+var_by_index(181) -> {set_tuple_element, 0};
+var_by_index(182) -> {bif2_body, 0};
+var_by_index(183) -> {extract_next_element2, 2};
+var_by_index(184) -> {l_move_call, 1};
+var_by_index(185) -> {l_catch, 1};
+var_by_index(186) -> {is_nil, 3};
+var_by_index(187) -> {move_deallocate_return, 3};
+var_by_index(188) -> {call_bif, 10};
+var_by_index(189) -> {extract_next_element2, 3};
+var_by_index(190) -> {badmatch, 1};
+var_by_index(191) -> {is_nonempty_list, 7};
+var_by_index(192) -> {l_increment, 2};
+var_by_index(193) -> {l_is_eq_exact_immed, 9};
+var_by_index(194) -> {case_end, 1};
+var_by_index(195) -> {extract_next_element, 4};
+var_by_index(196) -> {l_trim, 3};
+var_by_index(197) -> {l_move_call_ext_last, 0};
+var_by_index(198) -> {is_nonempty_list, 8};
+var_by_index(199) -> {l_move_call_last, 1};
+var_by_index(200) -> {badmatch, 2};
+var_by_index(201) -> {deallocate_return, 5};
+var_by_index(202) -> {l_fetch, 6};
+var_by_index(203) -> {l_select_val_atoms, 1};
+var_by_index(204) -> {l_bs_add, 0};
+var_by_index(205) -> {l_allocate, 5};
+var_by_index(206) -> {l_select_val_smallints, 0};
+var_by_index(207) -> {l_move_call, 2};
+var_by_index(208) -> {l_select_tuple_arity2, 1};
+var_by_index(209) -> {is_nonempty_list, 9};
+var_by_index(210) -> {l_bs_test_zero_tail2, 1};
+var_by_index(211) -> {l_loop_rec, 0};
+var_by_index(212) -> {l_move_call_ext, 3};
+var_by_index(213) -> {is_nil, 4};
+var_by_index(214) -> {l_is_ne_exact_immed, 0};
+var_by_index(215) -> {l_increment, 3};
+var_by_index(216) -> {l_is_ne, 0};
+var_by_index(217) -> {l_move_call, 3};
+var_by_index(218) -> {l_plus, 1};
+var_by_index(219) -> {catch_end, 1};
+var_by_index(220) -> {l_move_call, 4};
+var_by_index(221) -> {init, 5};
+var_by_index(222) -> {l_call_last, 6};
+var_by_index(223) -> {l_call_last, 5};
+var_by_index(224) -> {l_minus, 0};
+var_by_index(225) -> {l_move_call_ext, 4};
+var_by_index(226) -> {l_bs_match_string, 1};
+var_by_index(227) -> {l_allocate_zero, 4};
+var_by_index(228) -> {extract_next_element, 5};
+var_by_index(229) -> {l_select_val2, 6};
+var_by_index(230) -> {l_bs_init_heap_bin, 0};
+var_by_index(231) -> {l_allocate_zero, 5};
+var_by_index(232) -> {l_bs_start_match2, 2};
+var_by_index(233) -> {l_fetch, 7};
+var_by_index(234) -> {l_call_ext_last, 0};
+var_by_index(235) -> {is_nonempty_list_allocate, 1};
+var_by_index(236) -> {l_bs_restore2, 0};
+var_by_index(237) -> {loop_rec_end, 0};
+var_by_index(238) -> {call_bif, 11};
+var_by_index(239) -> {l_bs_get_utf16, 0};
+var_by_index(240) -> {l_fast_element, 1};
+var_by_index(241) -> {l_gc_bif1, 1};
+var_by_index(242) -> {l_trim, 4};
+var_by_index(243) -> {move, 9};
+var_by_index(244) -> {wait, 0};
+var_by_index(245) -> {l_is_eq_exact_immed, 10};
+var_by_index(246) -> {extract_next_element2, 4};
+var_by_index(247) -> {is_atom, 0};
+var_by_index(248) -> {call_bif, 12};
+var_by_index(249) -> {int_code_end, 0};
+var_by_index(250) -> {l_call_fun_last, 0};
+var_by_index(251) -> {l_move_call_ext_only, 0};
+var_by_index(252) -> {get_tuple_element, 6};
+var_by_index(253) -> {move_deallocate_return, 4};
+var_by_index(254) -> {bs_context_to_binary, 0};
+var_by_index(255) -> {init, 6};
+var_by_index(256) -> {l_move_call_ext, 5};
+var_by_index(257) -> {extract_next_element, 6};
+var_by_index(258) -> {self, 0};
+var_by_index(259) -> {is_nil, 5};
+var_by_index(260) -> {l_move_call_ext, 6};
+var_by_index(261) -> {l_call_ext_last, 1};
+var_by_index(262) -> {l_call_fun, 1};
+var_by_index(263) -> {l_is_eq_exact_immed, 11};
+var_by_index(264) -> {l_move_call, 5};
+var_by_index(265) -> {l_is_ne_exact_immed, 1};
+var_by_index(266) -> {is_tuple, 1};
+var_by_index(267) -> {extract_next_element, 7};
+var_by_index(268) -> {l_move_call_last, 2};
+var_by_index(269) -> {l_times, 0};
+var_by_index(270) -> {l_bs_test_unit_8, 0};
+var_by_index(271) -> {l_allocate, 6};
+var_by_index(272) -> {badmatch, 3};
+var_by_index(273) -> {l_move_call_ext_only, 1};
+var_by_index(274) -> {l_bs_test_zero_tail2, 2};
+var_by_index(275) -> {l_move_call_ext, 7};
+var_by_index(276) -> {l_move_call_ext, 8};
+var_by_index(277) -> {move_return, 6};
+var_by_index(278) -> {l_put_tuple, 4};
+var_by_index(279) -> {call_bif, 13};
+var_by_index(280) -> {l_catch, 2};
+var_by_index(281) -> {bif1_body, 1};
+var_by_index(282) -> {l_select_val_smallints, 1};
+var_by_index(283) -> {raise, 0};
+var_by_index(284) -> {call_bif, 14};
+var_by_index(285) -> {is_nil, 6};
+var_by_index(286) -> {l_move_call, 6};
+var_by_index(287) -> {l_move_call_ext, 9};
+var_by_index(288) -> {l_select_val2, 7};
+var_by_index(289) -> {is_integer, 0};
+var_by_index(290) -> {extract_next_element3, 1};
+var_by_index(291) -> {l_minus, 1};
+var_by_index(292) -> {is_nonempty_list, 10};
+var_by_index(293) -> {call_bif, 15};
+var_by_index(294) -> {l_bs_save2, 0};
+var_by_index(295) -> {l_call_ext_last, 2};
+var_by_index(296) -> {extract_next_element, 8};
+var_by_index(297) -> {l_call_ext, 1};
+var_by_index(298) -> {l_new_bs_put_binary_all, 0};
+var_by_index(299) -> {l_move_call_ext_only, 7};
+var_by_index(300) -> {is_nil, 7};
+var_by_index(301) -> {deallocate_return, 6};
+var_by_index(302) -> {l_move_call_only, 4};
+var_by_index(303) -> {self, 1};
+var_by_index(304) -> {l_call_ext, 2};
+var_by_index(305) -> {l_select_val2, 5};
+var_by_index(306) -> {case_end, 2};
+var_by_index(307) -> {allocate_heap_zero, 0};
+var_by_index(308) -> {call_bif, 16};
+var_by_index(309) -> {is_nonempty_list, 11};
+var_by_index(310) -> {extract_next_element2, 5};
+var_by_index(311) -> {apply, 0};
+var_by_index(312) -> {try_end, 0};
+var_by_index(313) -> {l_move_call, 7};
+var_by_index(314) -> {call_bif, 17};
+var_by_index(315) -> {l_fast_element, 0};
+var_by_index(316) -> {test_heap_1_put_list, 1};
+var_by_index(317) -> {call_bif, 19};
+var_by_index(318) -> {call_bif, 18};
+var_by_index(319) -> {call_bif, 20};
+var_by_index(320) -> {l_bs_test_zero_tail2, 3};
+var_by_index(321) -> {l_move_call_ext, 10};
+var_by_index(322) -> {is_nil, 8};
+var_by_index(323) -> {get_tuple_element, 7};
+var_by_index(324) -> {call_bif, 21};
+var_by_index(325) -> {l_call_ext, 3};
+var_by_index(326) -> {catch_end, 2};
+var_by_index(327) -> {l_put_tuple, 5};
+var_by_index(328) -> {is_list, 1};
+var_by_index(329) -> {extract_next_element3, 2};
+var_by_index(330) -> {get_list, 7};
+var_by_index(331) -> {l_bif2, 0};
+var_by_index(332) -> {call_bif, 22};
+var_by_index(333) -> {init, 7};
+var_by_index(334) -> {try_end, 1};
+var_by_index(335) -> {l_bs_get_integer_32, 0};
+var_by_index(336) -> {test_arity, 2};
+var_by_index(337) -> {l_trim, 5};
+var_by_index(338) -> {l_increment, 4};
+var_by_index(339) -> {l_move_call, 8};
+var_by_index(340) -> {l_call_ext, 4};
+var_by_index(341) -> {extract_next_element, 9};
+var_by_index(342) -> {l_move_call_ext, 11};
+var_by_index(343) -> {l_is_ne_exact, 0};
+var_by_index(344) -> {l_bs_get_binary2, 0};
+var_by_index(345) -> {extract_next_element, 24};
+var_by_index(346) -> {is_integer, 1};
+var_by_index(347) -> {l_band, 0};
+var_by_index(348) -> {move_jump, 0};
+var_by_index(349) -> {l_is_eq_exact_immed, 12};
+var_by_index(350) -> {l_call_fun, 2};
+var_by_index(351) -> {move_deallocate_return, 5};
+var_by_index(352) -> {l_times, 1};
+var_by_index(353) -> {l_move_call_last, 3};
+var_by_index(354) -> {put_list, 7};
+var_by_index(355) -> {l_call_last, 7};
+var_by_index(356) -> {l_move_call_ext_only, 3};
+var_by_index(357) -> {l_fast_element, 2};
+var_by_index(358) -> {l_is_eq_exact_literal, 7};
+var_by_index(359) -> {extract_next_element, 10};
+var_by_index(360) -> {extract_next_element2, 6};
+var_by_index(361) -> {is_tuple, 2};
+var_by_index(362) -> {l_catch, 3};
+var_by_index(363) -> {l_call_ext, 5};
+var_by_index(364) -> {l_call_ext, 6};
+var_by_index(365) -> {l_bif2, 1};
+var_by_index(366) -> {l_is_eq_exact_immed, 13};
+var_by_index(367) -> {is_binary, 0};
+var_by_index(368) -> {l_call_ext, 7};
+var_by_index(369) -> {extract_next_element2, 7};
+var_by_index(370) -> {l_allocate_zero, 6};
+var_by_index(371) -> {l_bsr, 0};
+var_by_index(372) -> {l_fetch, 22};
+var_by_index(373) -> {move, 10};
+var_by_index(374) -> {extract_next_element3, 3};
+var_by_index(375) -> {l_is_eq_exact_immed, 14};
+var_by_index(376) -> {get_list, 5};
+var_by_index(377) -> {is_atom, 1};
+var_by_index(378) -> {extract_next_element3, 4};
+var_by_index(379) -> {l_bs_get_binary_all2, 0};
+var_by_index(380) -> {call_bif, 23};
+var_by_index(381) -> {l_move_call_only, 5};
+var_by_index(382) -> {call_bif, 24};
+var_by_index(383) -> {is_nonempty_list, 12};
+var_by_index(384) -> {l_is_eq_exact_immed, 15};
+var_by_index(385) -> {l_fetch, 8};
+var_by_index(386) -> {l_is_eq_exact_literal, 1};
+var_by_index(387) -> {l_move_call_ext, 12};
+var_by_index(388) -> {l_bs_get_integer_8, 0};
+var_by_index(389) -> {l_is_ne_exact_immed, 2};
+var_by_index(390) -> {put_list, 6};
+var_by_index(391) -> {is_nil, 9};
+var_by_index(392) -> {l_bsl, 0};
+var_by_index(393) -> {l_select_val2, 9};
+var_by_index(394) -> {is_list, 2};
+var_by_index(395) -> {l_allocate_zero, 9};
+var_by_index(396) -> {l_put_tuple, 6};
+var_by_index(397) -> {l_call_ext, 8};
+var_by_index(398) -> {l_bs_init_fail, 0};
+var_by_index(399) -> {get_list, 6};
+var_by_index(400) -> {l_bif2, 2};
+var_by_index(401) -> {deallocate_return, 7};
+var_by_index(402) -> {l_bs_get_integer_8, 1};
+var_by_index(403) -> {set_tuple_element, 1};
+var_by_index(404) -> {l_move_call_ext, 13};
+var_by_index(405) -> {l_select_val2, 16};
+var_by_index(406) -> {call_bif, 26};
+var_by_index(407) -> {call_bif, 25};
+var_by_index(408) -> {l_call_ext, 9};
+var_by_index(409) -> {l_move_call, 9};
+var_by_index(410) -> {l_is_eq_exact_literal, 2};
+var_by_index(411) -> {l_bs_get_integer_32, 1};
+var_by_index(412) -> {extract_next_element, 11};
+var_by_index(413) -> {l_is_eq_exact_literal, 3};
+var_by_index(414) -> {l_is_eq_exact_immed, 16};
+var_by_index(415) -> {l_fetch, 9};
+var_by_index(416) -> {l_bif2, 3};
+var_by_index(417) -> {is_nil, 10};
+var_by_index(418) -> {l_bsl, 1};
+var_by_index(419) -> {l_bs_test_zero_tail2, 5};
+var_by_index(420) -> {l_trim, 6};
+var_by_index(421) -> {l_rem, 0};
+var_by_index(422) -> {move2, 8};
+var_by_index(423) -> {l_move_call_ext, 14};
+var_by_index(424) -> {timeout, 0};
+var_by_index(425) -> {is_binary, 1};
+var_by_index(426) -> {catch_end, 3};
+var_by_index(427) -> {l_move_call_ext_last, 1};
+var_by_index(428) -> {l_call_last, 8};
+var_by_index(429) -> {l_allocate_zero, 7};
+var_by_index(430) -> {l_select_val2, 10};
+var_by_index(431) -> {l_fetch, 10};
+var_by_index(432) -> {l_fmul, 0};
+var_by_index(433) -> {l_bs_match_string, 2};
+var_by_index(434) -> {call_bif, 27};
+var_by_index(435) -> {extract_next_element3, 10};
+var_by_index(436) -> {l_gc_bif1, 2};
+var_by_index(437) -> {move_deallocate_return, 6};
+var_by_index(438) -> {l_allocate, 7};
+var_by_index(439) -> {l_move_call, 10};
+var_by_index(440) -> {l_catch, 4};
+var_by_index(441) -> {is_nonempty_list, 36};
+var_by_index(442) -> {l_bs_get_integer_small_imm, 0};
+var_by_index(443) -> {extract_next_element, 12};
+var_by_index(444) -> {l_is_eq_exact_immed, 36};
+var_by_index(445) -> {l_call_ext, 10};
+var_by_index(446) -> {move_jump, 1};
+var_by_index(447) -> {l_fcheckerror, 0};
+var_by_index(448) -> {fclearerror, 0};
+var_by_index(449) -> {move_return, 7};
+var_by_index(450) -> {l_bs_append, 0};
+var_by_index(451) -> {node, 0};
+var_by_index(452) -> {l_move_call, 11};
+var_by_index(453) -> {extract_next_element2, 16};
+var_by_index(454) -> {l_move_call_last, 4};
+var_by_index(455) -> {l_is_eq_exact_immed, 17};
+var_by_index(456) -> {l_call_ext, 11};
+var_by_index(457) -> {extract_next_element, 13};
+var_by_index(458) -> {l_move_call_ext_only, 2};
+var_by_index(459) -> {l_is_ne_exact_immed, 11};
+var_by_index(460) -> {l_is_eq_exact_immed, 18};
+var_by_index(461) -> {l_get, 1};
+var_by_index(462) -> {l_element, 2};
+var_by_index(463) -> {is_integer, 2};
+var_by_index(464) -> {is_integer, 7};
+var_by_index(465) -> {l_move_call_ext_last, 4};
+var_by_index(466) -> {l_bif2, 4};
+var_by_index(467) -> {l_move_call_ext, 16};
+var_by_index(468) -> {l_call_fun, 3};
+var_by_index(469) -> {l_move_call, 12};
+var_by_index(470) -> {call_bif, 28};
+var_by_index(471) -> {is_nonempty_list, 13};
+var_by_index(472) -> {try_end, 2};
+var_by_index(473) -> {is_nil, 11};
+var_by_index(474) -> {l_select_tuple_arity, 1};
+var_by_index(475) -> {is_tuple, 3};
+var_by_index(476) -> {l_move_call_ext_last, 2};
+var_by_index(477) -> {node, 1};
+var_by_index(478) -> {is_nonempty_list, 14};
+var_by_index(479) -> {l_bs_restore2, 1};
+var_by_index(480) -> {l_move_call_ext, 17};
+var_by_index(481) -> {l_band, 1};
+var_by_index(482) -> {l_is_eq_exact_immed, 19};
+var_by_index(483) -> {l_get, 4};
+var_by_index(484) -> {call_bif, 29};
+var_by_index(485) -> {call_bif, 1};
+var_by_index(486) -> {l_fetch, 11};
+var_by_index(487) -> {l_gc_bif1, 3};
+var_by_index(488) -> {is_nil, 12};
+var_by_index(489) -> {l_move_call_only, 6};
+var_by_index(490) -> {l_move_call, 13};
+var_by_index(491) -> {system_limit, 0};
+var_by_index(492) -> {l_element, 0};
+var_by_index(493) -> {l_select_tuple_arity, 0};
+var_by_index(494) -> {bif2_body, 1};
+var_by_index(495) -> {is_float, 1};
+var_by_index(496) -> {extract_next_element2, 8};
+var_by_index(497) -> {l_select_val2, 8};
+var_by_index(498) -> {is_integer_allocate, 0};
+var_by_index(499) -> {is_atom, 2};
+var_by_index(500) -> {l_int_div, 0};
+var_by_index(501) -> {l_get, 2};
+var_by_index(502) -> {l_gc_bif1, 5};
+var_by_index(503) -> {l_move_call_ext, 18};
+var_by_index(504) -> {is_nil, 29};
+var_by_index(505) -> {l_is_eq_exact_immed, 20};
+var_by_index(506) -> {call_bif, 30};
+var_by_index(507) -> {l_bor, 0};
+var_by_index(508) -> {l_bif1, 0};
+var_by_index(509) -> {l_catch, 5};
+var_by_index(510) -> {l_get, 0};
+var_by_index(511) -> {l_fetch, 12};
+var_by_index(512) -> {l_call_ext, 13};
+var_by_index(513) -> {l_call_ext, 12};
+var_by_index(514) -> {is_tuple, 9};
+var_by_index(515) -> {try_end, 3};
+var_by_index(516) -> {init, 8};
+var_by_index(517) -> {call_bif, 32};
+var_by_index(518) -> {call_bif, 31};
+var_by_index(519) -> {is_nil, 13};
+var_by_index(520) -> {apply_last, 0};
+var_by_index(521) -> {call_bif, 33};
+var_by_index(522) -> {l_int_div, 1};
+var_by_index(523) -> {call_bif, 34};
+var_by_index(524) -> {extract_next_element, 14};
+var_by_index(525) -> {put_list, 9};
+var_by_index(526) -> {is_nonempty_list, 15};
+var_by_index(527) -> {case_end, 11};
+var_by_index(528) -> {l_bs_skip_bits2, 0};
+var_by_index(529) -> {l_call_ext, 14};
+var_by_index(530) -> {deallocate_return, 8};
+var_by_index(531) -> {l_call_ext_last, 3};
+var_by_index(532) -> {l_move_call_ext, 19};
+var_by_index(533) -> {l_is_ne_exact_immed, 3};
+var_by_index(534) -> {extract_next_element3, 5};
+var_by_index(535) -> {is_integer, 3};
+var_by_index(536) -> {l_trim, 7};
+var_by_index(537) -> {l_is_eq_exact_immed, 21};
+var_by_index(538) -> {l_increment, 8};
+var_by_index(539) -> {call_bif, 4};
+var_by_index(540) -> {is_nonempty_list, 16};
+var_by_index(541) -> {is_list, 7};
+var_by_index(542) -> {l_element, 4};
+var_by_index(543) -> {extract_next_element3, 6};
+var_by_index(544) -> {l_is_eq_exact_literal, 4};
+var_by_index(545) -> {test_arity, 3};
+var_by_index(546) -> {move_deallocate_return, 7};
+var_by_index(547) -> {l_move_call_ext_only, 4};
+var_by_index(548) -> {l_fadd, 0};
+var_by_index(549) -> {l_call_ext, 16};
+var_by_index(550) -> {l_call_ext, 15};
+var_by_index(551) -> {try_end, 5};
+var_by_index(552) -> {try_end, 4};
+var_by_index(553) -> {l_move_call_ext, 20};
+var_by_index(554) -> {l_bs_match_string, 3};
+var_by_index(555) -> {call_bif, 35};
+var_by_index(556) -> {l_call_ext, 17};
+var_by_index(557) -> {fmove_1, 0};
+var_by_index(558) -> {l_increment, 6};
+var_by_index(559) -> {if_end, 0};
+var_by_index(560) -> {l_increment, 5};
+var_by_index(561) -> {l_call_ext, 18};
+var_by_index(562) -> {is_integer, 4};
+var_by_index(563) -> {l_bs_get_utf8, 0};
+var_by_index(564) -> {is_list, 3};
+var_by_index(565) -> {is_atom, 3};
+var_by_index(566) -> {l_fetch, 13};
+var_by_index(567) -> {l_bs_init_bits_fail, 0};
+var_by_index(568) -> {call_bif, 36};
+var_by_index(569) -> {l_call_ext, 19};
+var_by_index(570) -> {l_bs_test_zero_tail2, 4};
+var_by_index(571) -> {fconv, 0};
+var_by_index(572) -> {case_end, 3};
+var_by_index(573) -> {catch_end, 4};
+var_by_index(574) -> {l_make_export, 0};
+var_by_index(575) -> {l_rem, 1};
+var_by_index(576) -> {self, 2};
+var_by_index(577) -> {fmove_2, 0};
+var_by_index(578) -> {l_bor, 1};
+var_by_index(579) -> {l_call_ext_last, 4};
+var_by_index(580) -> {call_bif, 37};
+var_by_index(581) -> {l_call_last, 9};
+var_by_index(582) -> {bif1_body, 2};
+var_by_index(583) -> {is_binary, 2};
+var_by_index(584) -> {l_fetch, 14};
+var_by_index(585) -> {l_call_ext, 20};
+var_by_index(586) -> {l_move_call_ext, 21};
+var_by_index(587) -> {l_bs_skip_bits_all2, 0};
+var_by_index(588) -> {l_catch, 7};
+var_by_index(589) -> {l_move_call_ext, 22};
+var_by_index(590) -> {extract_next_element, 15};
+var_by_index(591) -> {badmatch, 4};
+var_by_index(592) -> {l_move_call, 14};
+var_by_index(593) -> {self, 5};
+var_by_index(594) -> {get_tuple_element, 8};
+var_by_index(595) -> {l_move_call_ext, 23};
+var_by_index(596) -> {l_move_call_ext, 24};
+var_by_index(597) -> {l_call_ext, 21};
+var_by_index(598) -> {l_move_call_only, 7};
+var_by_index(599) -> {put_list, 8};
+var_by_index(600) -> {l_is_eq_exact_immed, 22};
+var_by_index(601) -> {is_nonempty_list_test_heap, 0};
+var_by_index(602) -> {is_tuple, 4};
+var_by_index(603) -> {extract_next_element2, 9};
+var_by_index(604) -> {case_end, 4};
+var_by_index(605) -> {l_is_function2, 0};
+var_by_index(606) -> {bif2_body, 3};
+var_by_index(607) -> {fmove_2, 1};
+var_by_index(608) -> {l_call_ext, 22};
+var_by_index(609) -> {extract_next_element, 16};
+var_by_index(610) -> {extract_next_element2, 10};
+var_by_index(611) -> {move_jump, 2};
+var_by_index(612) -> {move_return, 8};
+var_by_index(613) -> {is_nonempty_list, 17};
+var_by_index(614) -> {is_pid, 0};
+var_by_index(615) -> {l_jump_on_val, 0};
+var_by_index(616) -> {l_get, 3};
+var_by_index(617) -> {bif1_body, 3};
+var_by_index(618) -> {l_select_val2, 11};
+var_by_index(619) -> {l_allocate_zero, 8};
+var_by_index(620) -> {is_list, 4};
+var_by_index(621) -> {l_is_ne_exact_immed, 4};
+var_by_index(622) -> {fmove_1, 2};
+var_by_index(623) -> {bif1_body, 4};
+var_by_index(624) -> {fmove_1, 1};
+var_by_index(625) -> {is_nonempty_list, 18};
+var_by_index(626) -> {l_bs_test_unit_8, 3};
+var_by_index(627) -> {l_fetch, 15};
+var_by_index(628) -> {l_is_eq_exact_immed, 24};
+var_by_index(629) -> {put_list, 10};
+var_by_index(630) -> {call_bif, 38};
+var_by_index(631) -> {l_gc_bif1, 4};
+var_by_index(632) -> {extract_next_element, 17};
+var_by_index(633) -> {is_atom, 6};
+var_by_index(634) -> {l_move_call, 15};
+var_by_index(635) -> {l_allocate, 10};
+var_by_index(636) -> {l_move_call_ext_last, 3};
+var_by_index(637) -> {l_call_ext, 23};
+var_by_index(638) -> {l_element, 1};
+var_by_index(639) -> {move_deallocate_return, 8};
+var_by_index(640) -> {l_new_bs_put_integer, 0};
+var_by_index(641) -> {l_call_ext, 24};
+var_by_index(642) -> {l_move_call_last, 5};
+var_by_index(643) -> {l_move_call_ext, 25};
+var_by_index(644) -> {init, 9};
+var_by_index(645) -> {l_allocate, 8};
+var_by_index(646) -> {l_call_ext, 25};
+var_by_index(647) -> {l_fdiv, 0};
+var_by_index(648) -> {bs_context_to_binary, 4};
+var_by_index(649) -> {l_bif2, 6};
+var_by_index(650) -> {l_call_ext_last, 6};
+var_by_index(651) -> {get_list, 8};
+var_by_index(652) -> {node, 4};
+var_by_index(653) -> {l_call_ext, 26};
+var_by_index(654) -> {extract_next_element, 18};
+var_by_index(655) -> {deallocate_return, 9};
+var_by_index(656) -> {l_move_call_ext, 15};
+var_by_index(657) -> {is_binary, 3};
+var_by_index(658) -> {move_deallocate_return, 9};
+var_by_index(659) -> {l_call_ext, 27};
+var_by_index(660) -> {is_nonempty_list, 19};
+var_by_index(661) -> {l_select_val_atoms, 2};
+var_by_index(662) -> {badmatch, 17};
+var_by_index(663) -> {call_bif, 39};
+var_by_index(664) -> {l_call_ext, 28};
+var_by_index(665) -> {extract_next_element2, 11};
+var_by_index(666) -> {badmatch, 5};
+var_by_index(667) -> {case_end, 5};
+var_by_index(668) -> {l_bs_restore2, 2};
+var_by_index(669) -> {l_fetch, 16};
+var_by_index(670) -> {l_bs_get_integer, 0};
+var_by_index(671) -> {l_is_eq_exact_immed, 25};
+var_by_index(672) -> {l_call_ext, 29};
+var_by_index(673) -> {move_return, 9};
+var_by_index(674) -> {is_function, 2};
+var_by_index(675) -> {l_bif1, 2};
+var_by_index(676) -> {l_move_call_ext, 26};
+var_by_index(677) -> {call_bif, 40};
+var_by_index(678) -> {l_call_ext, 30};
+var_by_index(679) -> {case_end, 6};
+var_by_index(680) -> {l_move_call_ext, 27};
+var_by_index(681) -> {catch_end, 5};
+var_by_index(682) -> {l_bs_get_binary_imm2, 0};
+var_by_index(683) -> {l_move_call_ext, 28};
+var_by_index(684) -> {call_bif, 42};
+var_by_index(685) -> {call_bif, 41};
+var_by_index(686) -> {l_call_ext, 32};
+var_by_index(687) -> {l_call_ext, 31};
+var_by_index(688) -> {l_bs_test_unit_8, 1};
+var_by_index(689) -> {l_move_call, 16};
+var_by_index(690) -> {l_bsr, 1};
+var_by_index(691) -> {l_move_call_ext, 29};
+var_by_index(692) -> {l_bs_skip_bits_imm2, 0};
+var_by_index(693) -> {l_move_call_ext, 30};
+var_by_index(694) -> {l_call_ext, 34};
+var_by_index(695) -> {l_call_ext, 33};
+var_by_index(696) -> {is_nil, 15};
+var_by_index(697) -> {is_nil, 14};
+var_by_index(698) -> {badmatch, 6};
+var_by_index(699) -> {l_call_last, 11};
+var_by_index(700) -> {fconv, 1};
+var_by_index(701) -> {is_boolean, 0};
+var_by_index(702) -> {l_is_ne_exact_immed, 5};
+var_by_index(703) -> {call_bif, 43};
+var_by_index(704) -> {l_call_ext, 35};
+var_by_index(705) -> {is_nil, 16};
+var_by_index(706) -> {l_move_call_only, 8};
+var_by_index(707) -> {l_bs_test_unit_8, 2};
+var_by_index(708) -> {catch_end, 7};
+var_by_index(709) -> {l_bs_get_utf16, 1};
+var_by_index(710) -> {get_list, 9};
+var_by_index(711) -> {l_plus, 2};
+var_by_index(712) -> {deallocate_return, 12};
+var_by_index(713) -> {l_element, 3};
+var_by_index(714) -> {move_jump, 3};
+var_by_index(715) -> {l_bs_put_string, 0};
+var_by_index(716) -> {is_pid, 1};
+var_by_index(717) -> {is_atom, 4};
+var_by_index(718) -> {l_select_tuple_arity, 2};
+var_by_index(719) -> {l_call_ext, 36};
+var_by_index(720) -> {extract_next_element, 19};
+var_by_index(721) -> {case_end, 7};
+var_by_index(722) -> {l_catch, 6};
+var_by_index(723) -> {l_call_ext, 38};
+var_by_index(724) -> {l_call_ext, 37};
+var_by_index(725) -> {move_jump, 4};
+var_by_index(726) -> {is_nil, 17};
+var_by_index(727) -> {is_list, 5};
+var_by_index(728) -> {try_case_end, 0};
+var_by_index(729) -> {l_bs_get_binary_all2, 1};
+var_by_index(730) -> {move, 11};
+var_by_index(731) -> {l_move_call_last, 6};
+var_by_index(732) -> {put_list, 14};
+var_by_index(733) -> {move_jump, 5};
+var_by_index(734) -> {move_return, 10};
+var_by_index(735) -> {l_is_eq_exact_literal, 5};
+var_by_index(736) -> {bif2_body, 2};
+var_by_index(737) -> {get_tuple_element, 9};
+var_by_index(738) -> {put_list, 11};
+var_by_index(739) -> {l_select_val2, 12};
+var_by_index(740) -> {call_bif, 44};
+var_by_index(741) -> {is_nonempty_list, 20};
+var_by_index(742) -> {l_fsub, 0};
+var_by_index(743) -> {l_move_call_ext, 31};
+var_by_index(744) -> {bif1_body, 5};
+var_by_index(745) -> {l_call_ext, 39};
+var_by_index(746) -> {extract_next_element3, 7};
+var_by_index(747) -> {l_bs_start_match2, 3};
+var_by_index(748) -> {l_trim, 8};
+var_by_index(749) -> {bs_context_to_binary, 1};
+var_by_index(750) -> {l_call_ext, 40};
+var_by_index(751) -> {move_return, 11};
+var_by_index(752) -> {l_call_fun, 4};
+var_by_index(753) -> {l_is_eq_exact_literal, 6};
+var_by_index(754) -> {l_is_ne_exact_immed, 6};
+var_by_index(755) -> {test_heap_1_put_list, 2};
+var_by_index(756) -> {test_heap_1_put_list, 3};
+var_by_index(757) -> {l_is_eq_exact_immed, 26};
+var_by_index(758) -> {self, 3};
+var_by_index(759) -> {l_call_ext, 41};
+var_by_index(760) -> {l_move_call_ext, 33};
+var_by_index(761) -> {init, 10};
+var_by_index(762) -> {l_bs_skip_bits_imm2, 1};
+var_by_index(763) -> {l_call_ext, 42};
+var_by_index(764) -> {extract_next_element2, 12};
+var_by_index(765) -> {badmatch, 7};
+var_by_index(766) -> {l_move_call_ext_only, 5};
+var_by_index(767) -> {l_call_ext, 43};
+var_by_index(768) -> {move_jump, 6};
+var_by_index(769) -> {is_nil, 18};
+var_by_index(770) -> {l_call_ext_only, 0};
+var_by_index(771) -> {l_fetch, 17};
+var_by_index(772) -> {l_move_call_ext, 34};
+var_by_index(773) -> {l_move_call_ext, 35};
+var_by_index(774) -> {l_is_eq_exact_immed, 27};
+var_by_index(775) -> {l_bs_append, 1};
+var_by_index(776) -> {l_bif2, 5};
+var_by_index(777) -> {l_bs_get_binary2, 1};
+var_by_index(778) -> {l_bs_get_integer_small_imm, 1};
+var_by_index(779) -> {l_call_ext, 47};
+var_by_index(780) -> {l_call_ext, 46};
+var_by_index(781) -> {l_call_ext, 45};
+var_by_index(782) -> {l_call_ext, 44};
+var_by_index(783) -> {move_return, 12};
+var_by_index(784) -> {l_bs_save2, 1};
+var_by_index(785) -> {is_function, 0};
+var_by_index(786) -> {l_bs_get_integer_imm, 0};
+var_by_index(787) -> {l_move_call_ext_only, 6};
+var_by_index(788) -> {l_call_ext, 48};
+var_by_index(789) -> {l_move_call, 17};
+var_by_index(790) -> {l_is_ne_exact_immed, 7};
+var_by_index(791) -> {l_call_ext, 50};
+var_by_index(792) -> {l_call_ext, 49};
+var_by_index(793) -> {is_integer, 5};
+var_by_index(794) -> {move_return, 13};
+var_by_index(795) -> {l_bs_put_string, 1};
+var_by_index(796) -> {try_end, 7};
+var_by_index(797) -> {l_yield, 0};
+var_by_index(798) -> {l_move_call, 18};
+var_by_index(799) -> {l_fetch, 18};
+var_by_index(800) -> {l_is_eq_exact_immed, 28};
+var_by_index(801) -> {l_new_bs_put_integer, 1};
+var_by_index(802) -> {node, 2};
+var_by_index(803) -> {l_call_ext, 51};
+var_by_index(804) -> {move_jump, 7};
+var_by_index(805) -> {case_end, 9};
+var_by_index(806) -> {case_end, 8};
+var_by_index(807) -> {is_nonempty_list, 22};
+var_by_index(808) -> {is_nonempty_list, 21};
+var_by_index(809) -> {l_move_call, 19};
+var_by_index(810) -> {l_move_call_ext, 37};
+var_by_index(811) -> {get_list, 11};
+var_by_index(812) -> {l_fetch, 19};
+var_by_index(813) -> {l_new_bs_put_float_imm, 1};
+var_by_index(814) -> {l_move_call, 20};
+var_by_index(815) -> {l_call_ext_only, 1};
+var_by_index(816) -> {l_gc_bif1, 6};
+var_by_index(817) -> {l_bif1, 1};
+var_by_index(818) -> {l_move_call, 21};
+var_by_index(819) -> {l_is_ne_exact_literal, 0};
+var_by_index(820) -> {l_bs_put_string, 2};
+var_by_index(821) -> {l_call_ext, 52};
+var_by_index(822) -> {l_is_eq_exact_immed, 23};
+var_by_index(823) -> {extract_next_element, 20};
+var_by_index(824) -> {is_nil, 19};
+var_by_index(825) -> {badmatch, 8};
+var_by_index(826) -> {catch_end, 6};
+var_by_index(827) -> {l_is_function2, 1};
+var_by_index(828) -> {l_call_ext, 53};
+var_by_index(829) -> {move_return, 14};
+var_by_index(830) -> {badmatch, 9};
+var_by_index(831) -> {self, 4};
+var_by_index(832) -> {l_call_ext, 56};
+var_by_index(833) -> {l_call_ext, 55};
+var_by_index(834) -> {l_call_ext, 54};
+var_by_index(835) -> {l_call_ext_last, 5};
+var_by_index(836) -> {l_move_call, 23};
+var_by_index(837) -> {l_move_call, 22};
+var_by_index(838) -> {l_select_tuple_arity, 3};
+var_by_index(839) -> {l_apply, 0};
+var_by_index(840) -> {init, 16};
+var_by_index(841) -> {init, 11};
+var_by_index(842) -> {l_move_call_last, 8};
+var_by_index(843) -> {l_move_call_last, 7};
+var_by_index(844) -> {l_call_ext, 59};
+var_by_index(845) -> {l_call_ext, 58};
+var_by_index(846) -> {l_call_ext, 57};
+var_by_index(847) -> {extract_next_element2, 13};
+var_by_index(848) -> {l_new_bs_put_integer_imm, 1};
+var_by_index(849) -> {try_end, 6};
+var_by_index(850) -> {deallocate_return, 10};
+var_by_index(851) -> {l_move_call, 24};
+var_by_index(852) -> {l_fetch, 20};
+var_by_index(853) -> {get_list, 10};
+var_by_index(854) -> {l_allocate, 9};
+var_by_index(855) -> {bs_init_writable, 0};
+var_by_index(856) -> {l_call_ext, 60};
+var_by_index(857) -> {extract_next_element, 21};
+var_by_index(858) -> {extract_next_element3, 8};
+var_by_index(859) -> {is_integer, 6};
+var_by_index(860) -> {move_jump, 8};
+var_by_index(861) -> {badmatch, 10};
+var_by_index(862) -> {is_nonempty_list, 23};
+var_by_index(863) -> {l_bs_private_append, 0};
+var_by_index(864) -> {deallocate_return, 11};
+var_by_index(865) -> {l_move_call, 25};
+var_by_index(866) -> {l_call_ext, 63};
+var_by_index(867) -> {l_call_ext, 62};
+var_by_index(868) -> {l_call_ext, 61};
+var_by_index(869) -> {move_jump, 9};
+var_by_index(870) -> {move_return, 16};
+var_by_index(871) -> {move_return, 15};
+var_by_index(872) -> {bs_context_to_binary, 2};
+var_by_index(873) -> {l_jump_on_val, 1};
+var_by_index(874) -> {l_increment, 7};
+var_by_index(875) -> {l_is_ne_exact_immed, 8};
+var_by_index(876) -> {l_call_ext, 67};
+var_by_index(877) -> {l_call_ext, 66};
+var_by_index(878) -> {l_call_ext, 65};
+var_by_index(879) -> {l_call_ext, 64};
+var_by_index(880) -> {extract_next_element2, 14};
+var_by_index(881) -> {put_list, 13};
+var_by_index(882) -> {is_float, 0};
+var_by_index(883) -> {l_is_eq_exact_immed, 29};
+var_by_index(884) -> {l_select_val2, 14};
+var_by_index(885) -> {l_call_ext, 69};
+var_by_index(886) -> {l_call_ext, 68};
+var_by_index(887) -> {extract_next_element3, 9};
+var_by_index(888) -> {move_return, 17};
+var_by_index(889) -> {is_nonempty_list, 25};
+var_by_index(890) -> {is_nonempty_list, 24};
+var_by_index(891) -> {l_select_tuple_arity2, 2};
+var_by_index(892) -> {is_atom, 5};
+var_by_index(893) -> {l_call_ext_only, 2};
+var_by_index(894) -> {l_is_ne_exact_immed, 9};
+var_by_index(895) -> {node, 3};
+var_by_index(896) -> {is_tuple, 5};
+var_by_index(897) -> {l_call_ext, 73};
+var_by_index(898) -> {l_call_ext, 72};
+var_by_index(899) -> {l_call_ext, 71};
+var_by_index(900) -> {l_call_ext, 70};
+var_by_index(901) -> {extract_next_element, 22};
+var_by_index(902) -> {wait_timeout, 0};
+var_by_index(903) -> {extract_next_element2, 15};
+var_by_index(904) -> {is_nil, 20};
+var_by_index(905) -> {is_nonempty_list, 26};
+var_by_index(906) -> {l_wait_timeout, 2};
+var_by_index(907) -> {l_minus, 2};
+var_by_index(908) -> {is_tuple, 6};
+var_by_index(909) -> {l_call_ext, 79};
+var_by_index(910) -> {l_call_ext, 78};
+var_by_index(911) -> {l_call_ext, 77};
+var_by_index(912) -> {l_call_ext, 76};
+var_by_index(913) -> {l_call_ext, 75};
+var_by_index(914) -> {l_call_ext, 74};
+var_by_index(915) -> {l_call_last, 10};
+var_by_index(916) -> {l_bs_test_tail_imm2, 0};
+var_by_index(917) -> {move_jump, 10};
+var_by_index(918) -> {move_return, 18};
+var_by_index(919) -> {is_integer_allocate, 1};
+var_by_index(920) -> {is_nonempty_list, 27};
+var_by_index(921) -> {l_new_bs_put_float_imm, 0};
+var_by_index(922) -> {l_fetch, 21};
+var_by_index(923) -> {move, 12};
+var_by_index(924) -> {move2, 9};
+var_by_index(925) -> {l_bs_skip_bits_all2, 1};
+var_by_index(926) -> {is_tuple, 7};
+var_by_index(927) -> {l_call_ext, 84};
+var_by_index(928) -> {l_call_ext, 83};
+var_by_index(929) -> {l_call_ext, 82};
+var_by_index(930) -> {l_call_ext, 81};
+var_by_index(931) -> {l_call_ext, 80};
+var_by_index(932) -> {l_is_eq_exact_immed, 30};
+var_by_index(933) -> {is_nil, 21};
+var_by_index(934) -> {recv_mark, 0};
+var_by_index(935) -> {raise, 1};
+var_by_index(936) -> {case_end, 10};
+var_by_index(937) -> {is_function, 1};
+var_by_index(938) -> {l_call_ext_only, 3};
+var_by_index(939) -> {l_recv_set, 0};
+var_by_index(940) -> {l_bs_skip_bits_all2, 2};
+var_by_index(941) -> {l_fast_element, 3};
+var_by_index(942) -> {l_trim, 11};
+var_by_index(943) -> {l_times, 2};
+var_by_index(944) -> {bs_context_to_binary, 3};
+var_by_index(945) -> {l_move_call_ext, 32};
+var_by_index(946) -> {l_is_eq_exact_immed, 31};
+var_by_index(947) -> {is_port, 0};
+var_by_index(948) -> {l_bs_get_float2, 0};
+var_by_index(949) -> {l_bs_get_utf8, 1};
+var_by_index(950) -> {l_select_val2, 15};
+var_by_index(951) -> {l_select_tuple_arity, 4};
+var_by_index(952) -> {test_heap_1_put_list, 4};
+var_by_index(953) -> {is_map, 0};
+var_by_index(954) -> {l_trim, 9};
+var_by_index(955) -> {badmatch, 11};
+var_by_index(956) -> {l_apply_fun, 0};
+var_by_index(957) -> {init, 12};
+var_by_index(958) -> {l_is_eq_exact_immed, 32};
+var_by_index(959) -> {extract_next_element, 23};
+var_by_index(960) -> {l_move_call_only, 10};
+var_by_index(961) -> {l_move_call_only, 9};
+var_by_index(962) -> {l_is_eq_exact_immed, 33};
+var_by_index(963) -> {l_is_ne_exact_immed, 10};
+var_by_index(964) -> {move_return, 19};
+var_by_index(965) -> {badmatch, 13};
+var_by_index(966) -> {badmatch, 12};
+var_by_index(967) -> {l_bs_get_integer_16, 0};
+var_by_index(968) -> {l_bs_get_binary_all_reuse, 1};
+var_by_index(969) -> {l_is_eq_exact_immed, 34};
+var_by_index(970) -> {move_jump, 11};
+var_by_index(971) -> {move_return, 21};
+var_by_index(972) -> {move_return, 20};
+var_by_index(973) -> {l_move_call_only, 11};
+var_by_index(974) -> {badmatch, 14};
+var_by_index(975) -> {is_list, 6};
+var_by_index(976) -> {l_bs_init_fail, 1};
+var_by_index(977) -> {l_move_call_ext, 36};
+var_by_index(978) -> {is_tuple, 8};
+var_by_index(979) -> {move_jump, 13};
+var_by_index(980) -> {move_jump, 12};
+var_by_index(981) -> {move_return, 22};
+var_by_index(982) -> {is_nil, 22};
+var_by_index(983) -> {is_nonempty_list, 29};
+var_by_index(984) -> {is_nonempty_list, 28};
+var_by_index(985) -> {l_bs_init, 0};
+var_by_index(986) -> {l_bs_restore2, 3};
+var_by_index(987) -> {move, 13};
+var_by_index(988) -> {l_bs_get_binary_imm2, 1};
+var_by_index(989) -> {is_nonempty_list, 30};
+var_by_index(990) -> {l_bs_init_bits, 0};
+var_by_index(991) -> {l_bs_put_utf16, 0};
+var_by_index(992) -> {is_bitstr, 0};
+var_by_index(993) -> {l_bs_validate_unicode, 0};
+var_by_index(994) -> {is_nonempty_list, 32};
+var_by_index(995) -> {is_nonempty_list, 31};
+var_by_index(996) -> {l_bs_save2, 2};
+var_by_index(997) -> {l_bs_utf16_size, 0};
+var_by_index(998) -> {l_bs_get_binary2, 2};
+var_by_index(999) -> {l_is_eq_exact_immed, 35};
+var_by_index(1000) -> {get_tuple_element, 10};
+var_by_index(1001) -> {l_bs_get_integer_32, 2};
+var_by_index(1002) -> {move_return, 24};
+var_by_index(1003) -> {move_return, 23};
+var_by_index(1004) -> {is_nil, 23};
+var_by_index(1005) -> {badmatch, 15};
+var_by_index(1006) -> {is_nonempty_list, 33};
+var_by_index(1007) -> {move, 14};
+var_by_index(1008) -> {l_bs_add, 1};
+var_by_index(1009) -> {is_reference, 0};
+var_by_index(1010) -> {is_nil, 26};
+var_by_index(1011) -> {is_nil, 25};
+var_by_index(1012) -> {is_nil, 24};
+var_by_index(1013) -> {l_new_bs_put_binary, 0};
+var_by_index(1014) -> {badmatch, 16};
+var_by_index(1015) -> {is_nonempty_list, 34};
+var_by_index(1016) -> {init, 13};
+var_by_index(1017) -> {is_nil, 28};
+var_by_index(1018) -> {is_nil, 27};
+var_by_index(1019) -> {put_list, 12};
+var_by_index(1020) -> {is_nonempty_list, 35};
+var_by_index(1021) -> {l_bs_validate_unicode_retract, 0};
+var_by_index(1022) -> {l_wait_timeout, 0};
+var_by_index(1023) -> {l_gc_bif2, 0};
+var_by_index(1024) -> {init, 14};
+var_by_index(1025) -> {l_fast_element, 4};
+var_by_index(1026) -> {l_trim, 10};
+var_by_index(1027) -> {l_new_bs_put_binary_all, 1};
+var_by_index(1028) -> {l_apply_last, 0};
+var_by_index(1029) -> {init, 15};
+var_by_index(1030) -> {is_number, 0};
+var_by_index(1031) -> {l_int_bnot, 0};
+var_by_index(1032) -> {l_bs_put_utf8, 0};
+var_by_index(1033) -> {l_new_bs_put_float, 0};
+var_by_index(1034) -> {l_select_val2, 13};
+var_by_index(1035) -> {l_bs_utf8_size, 0};
+var_by_index(1036) -> {l_wait_timeout, 1};
+var_by_index(1037) -> {fmove_2, 2};
+var_by_index(1038) -> {l_jump_on_val, 2};
+var_by_index(1039) -> {l_bs_get_binary_imm2, 2};
+var_by_index(1040) -> {l_fnegate, 0};
+var_by_index(1041) -> {get_list, 12};
+var_by_index(1042) -> {l_bs_get_integer_imm, 1};
+var_by_index(1043) -> {bif1_body, 6};
+var_by_index(1044) -> {l_bs_get_binary_all_reuse, 2};
+var_by_index(1045) -> {l_bxor, 0};
+var_by_index(1046) -> {l_new_bs_put_integer_imm, 2};
+var_by_index(1047) -> {l_int_div, 2};
+var_by_index(1048) -> {l_gc_bif3, 0};
+var_by_index(1049) -> {l_apply_only, 0};
+var_by_index(1050) -> {l_bor, 2};
+var_by_index(1051) -> {l_bs_start_match2, 4};
+var_by_index(1052) -> {l_rem, 2};
+var_by_index(1053) -> {l_bsl, 2};
+var_by_index(1054) -> {l_new_bs_put_binary_imm, 0};
+var_by_index(1055) -> {l_apply_fun_only, 0};
+var_by_index(1056) -> {l_bs_get_integer_8, 2};
+var_by_index(1057) -> {l_bs_get_integer_small_imm, 2};
+var_by_index(1058) -> {l_hibernate, 0};
+var_by_index(1059) -> {l_apply_fun_last, 0};
+var_by_index(1060) -> {l_band, 2};
+var_by_index(1061) -> {is_bigint, 0};
+var_by_index(1062) -> {on_load, 0};
+var_by_index(1063) -> {move2, 10};
+var_by_index(1064) -> {l_bs_test_unit, 0};
+var_by_index(1065) -> {l_m_div, 0};
+var_by_index(1066) -> {l_select_val_smallints, 2};
+var_by_index(1067) -> {is_function2, 0};
+var_by_index(1068) -> {test_heap, 1};
+var_by_index(1069) -> {func_info, 0};
+var_by_index(1070) -> {call_bif, 0};
+var_by_index(1071) -> {l_bs_get_utf16, 2};
+var_by_index(1072) -> {l_put_tuple, 7};
+var_by_index(1073) -> {allocate_init, 1};
+var_by_index(1074) -> {l_call_fun_last, 1};
+var_by_index(1075) -> {set_tuple_element, 2};
+var_by_index(1076) -> {allocate_heap, 1};
+var_by_index(1077) -> {is_tuple_of_arity, 4};
+var_by_index(1078) -> {test_arity, 4};
+var_by_index(1079) -> {l_bs_match_string, 4};
+var_by_index(1080) -> {is_nonempty_list_allocate, 2};
+var_by_index(1081) -> {l_bs_append, 2};
+var_by_index(1082) -> {try_case_end, 1};
+var_by_index(1083) -> {init3, 1};
+var_by_index(1084) -> {l_select_tuple_arity2, 3};
+var_by_index(1085) -> {init2, 1};
+var_by_index(1086) -> {l_is_function2, 2};
+var_by_index(1087) -> {l_bs_get_binary_all2, 2};
+var_by_index(1088) -> {is_nonempty_list_test_heap, 1};
+var_by_index(1089) -> {allocate_heap_zero, 1};
+var_by_index(1090) -> {l_bs_init_heap_bin, 1};
+var_by_index(1091) -> {l_plus, 3};
+var_by_index(1092) -> {l_bs_get_integer, 1};
+
+var_by_index(Index) -> erlang:error({novarat,Index}).
+
+%%EOF
+
+

src/ling/ling_lib.erl

@@ -0,0 +1,299 @@
+%% Copyright (c) 2013-2014 Cloudozer LLP. All rights reserved.
+%% 
+%% Redistribution and use in source and binary forms, with or without
+%% modification, are permitted provided that the following conditions are met:
+%% 
+%% * Redistributions of source code must retain the above copyright notice, this
+%% list of conditions and the following disclaimer.
+%% 
+%% * Redistributions in binary form must reproduce the above copyright notice,
+%% this list of conditions and the following disclaimer in the documentation
+%% and/or other materials provided with the distribution.
+%% 
+%% * Redistributions in any form must be accompanied by information on how to
+%% obtain complete source code for the LING software and any accompanying
+%% software that uses the LING software. The source code must either be included
+%% in the distribution or be available for no more than the cost of distribution
+%% plus a nominal fee, and must be freely redistributable under reasonable
+%% conditions.  For an executable file, complete source code means the source
+%% code for all modules it contains. It does not include source code for modules
+%% or files that typically accompany the major components of the operating
+%% system on which the executable file runs.
+%% 
+%% THIS SOFTWARE IS PROVIDED BY CLOUDOZER LLP ``AS IS'' AND ANY EXPRESS OR
+%% IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+%% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE
+%% DISCLAIMED. IN NO EVENT SHALL CLOUDOZER LLP BE LIABLE FOR ANY DIRECT,
+%% INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+%% (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+%% LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+%% ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+%% (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+%% SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-module(ling_lib).
+-export([abstract_code/1]).
+-export([specs_to_binary/1]).
+
+-include("ling_code.hrl").
+
+abstract_code(Ling) when is_list(Ling) -> %% {ok,Forms} | {error,Error}
+	case file:read_file(Ling) of
+	{ok,Bin} ->
+		abstract_code(Bin);
+	Err ->
+		Err
+	end;
+abstract_code(<<"FOR1",_Size:32,"LING",Chunks/binary>>) ->
+	scan_chunks(Chunks);
+abstract_code(_) ->
+	{error,badarg}.
+
+scan_chunks(<<"Abst",Sz:32,Data:(Sz)/binary,_/binary>>) ->
+	{ok,binary_to_term(Data)};
+scan_chunks(<<_Tag:4/binary,Sz:32,_Data:(Sz)/binary,PadChunks/binary>>) ->
+	PadSize = case Sz rem 4 of
+	0 -> 0;
+	N -> 4 -N
+	end,
+	<<_Pad:(PadSize)/binary,Chunks/binary>> = PadChunks,
+	scan_chunks(Chunks);
+scan_chunks(<<>>) ->
+	no_abstract_code.
+	
+%% (unsigned)
+%% opcode
+%% atom
+%% bif
+%% catch
+%% export
+%% reg_as_term
+%% slot_as_term
+%% tag_int
+%% literal
+%% label
+%% nolabel
+%% nil
+%% fu
+%% str
+
+%% 0xxxxxxx		{opcode,7}
+%% 1000xxxx		{reg_as_term,4}
+%% 1001xxxx		{slot_as_term,4}
+%% 1010xxxx		{unsigned,12} [1]
+%% 1011xxxx		{unsigned,20} [2]
+%% 1100xxxx		{atom,12} [1]
+%% 1101xxxx		{export,12} [1]
+%% 111000xx		{literal,10} [1]
+%% 111001xx		{bif,10} [1]	
+%% 111010xx		{opcode,10} [1]
+%% 111011xx		{tag_int,10} [1]
+%% 111100xx		{fu,10} [1]
+%% 11110100		{catch,8} [1]		
+%% 11110101		{str,8} [1]
+%% 11110110		(unused)
+%% 11110111		(unused)
+%% 11111000		{tag_int,32} [4]
+%% 11111001		{unsigned,32} [4]
+%% 11111010		{reg_as_term,8} [1]
+%% 11111011		{slot_as_term,8} [1]
+%% 11111100		nil
+%% 11111101		{f,none}
+%% 11111110		{f,16} [2]
+%% 11111111		(extended)
+
+%% extended tag (follows 255):
+%%
+%% 00000000		{f,32} [4]
+%% 00000001		{atom,32} [4]
+%% 00000010		{export,32} [4]
+%% 00000011		{literal,32} [4]
+%% 00000100		{bif,32} [4]
+%% 00000101		{fu,32} [4]
+%% 00000110		{catch,32} [4]
+%% 00000111		{str,32} [4]
+%% 00001000		{slot_as_term,32} [4]
+%% 00001001		{opcode,32} [4]
+%% ...			(unused)
+%%
+
+specs_to_binary(Specs) ->	%% {ok,Bin}
+
+	L = [wrap("Atom", atoms_chunk(Specs)),
+		 wrap("ExpT", exports_chunk(Specs)),
+		 wrap("ImpT", imports_chunk(Specs)),
+		 wrap("Code", code_chunk(Specs)),
+		 wrap("CatT", catches_chunk(Specs)),
+		 wrap("FunT", lambdas_chunk(Specs)),
+		 wrap("StrT", strings_chunk(Specs)),
+		 wrap("LitT", literals_chunk(Specs)),
+		 wrap("Attr", attrs_chunk(Specs)),
+		 wrap("CInf", cinfo_chunk(Specs)),
+	 	 wrap("Line", line_chunk(Specs))]
+	%% 
+	%% This increases the size of the image; make an option?
+	%%
+		++ if Specs#m.abst_code =/= no_abstract_code ->
+			[wrap("Abst", term_to_binary(Specs#m.abst_code))];
+				true -> [] end,
+
+	Chunks = list_to_binary(L),
+
+	FormSize = byte_size(Chunks) + 4,
+
+	<<"FOR1",FormSize:32,"LING",Chunks/binary>>.
+
+wrap(_, undefined) ->
+	<<>>;
+wrap([A,B,C,D], Body) ->
+	ChunkSize = byte_size(Body),
+	AlignedSize = (ChunkSize + 3) band (bnot 3),
+	PadSize = AlignedSize - ChunkSize,
+	<<A,B,C,D,ChunkSize:32,Body/binary,0:PadSize/unit:8>>.
+
+atoms_chunk(#m{atoms=Atoms}) ->
+	%io:format("Atoms=~p~n", [Atoms]),
+	L = [<<(length(Atoms)):32>>] ++
+		[[length(atom_to_list(A))] ++ atom_to_list(A) || A <- Atoms],
+	list_to_binary(L).
+
+exports_chunk(#m{atoms=Atoms,exports=Exports}) ->
+	L = [<<(length(Exports)):32>>] ++
+		[<<(ai(F, Atoms)):32,N:32,Off:32>> || {F,N,Off} <- Exports],
+	list_to_binary(L).
+
+imports_chunk(#m{atoms=Atoms,imports=Imports}) ->
+	L = [<<(length(Imports)):32>>] ++
+		[<<(ai(M, Atoms)):32,(ai(F, Atoms)):32,N:32>> || {M,F,N} <- Imports],
+	list_to_binary(L).
+
+code_chunk(#m{code=Code}) ->
+
+	CodeSize = length(lists:concat(Code)),
+
+	<<CodeSize:32,(encode(Code))/binary>>.
+
+catches_chunk(#m{catches=Catches}) ->
+	L = [<<(length(Catches)):32>>] ++
+		[<<Off:32>> || Off <- Catches],
+	list_to_binary(L).
+
+lambdas_chunk(#m{atoms=Atoms,lambdas=Lambdas}) ->
+	L = [<<(length(Lambdas)):32>>] ++
+		[<<(ai(F, Atoms)):32,A:32,Off:32,Idx:32,NFree:32,Ou:32>>
+					|| {F,A,Off,Idx,NFree,Ou} <- Lambdas],
+	list_to_binary(L).
+
+strings_chunk(#m{strings=StrTabBin}) ->
+	StrTabBin.
+
+literals_chunk(#m{literals=Literals}) ->
+	%io:format("Literals=~p~n", [Literals]),
+	EncLits = [term_to_binary(Lit) || Lit <- Literals],
+	L = [<<(length(Literals)):32>>] ++
+		[<<(byte_size(EncLit)):32,EncLit/binary>> || EncLit <- EncLits],
+	list_to_binary(L).
+
+attrs_chunk(#m{attrs=undefined}) ->
+	undefined;
+attrs_chunk(#m{attrs=Attrs}) ->
+	term_to_binary(Attrs).
+
+cinfo_chunk(#m{compile_info=undefined}) ->
+	undefined;
+cinfo_chunk(#m{compile_info=CInfo}) ->
+	term_to_binary(CInfo).
+
+line_chunk(#m{line_info=undefined}) ->
+	undefined;
+line_chunk(#m{atoms=Atoms,line_info={LineRefs,FileNames}}) ->
+	PackedLineRefs = lists:map(fun({Offset,undefined}) ->
+		{Offset,0};
+	({Offset,{nofile,Line}}) ->
+		{Offset,Line};	%% does absense of file ref mean default file?
+	({Offset,{File,Line}}) ->
+		{Offset,(File bsl 24) bor Line}
+	end, LineRefs),
+
+	L = [<<(length(LineRefs)):32,(length(FileNames)):32>>] ++
+		[<<Offset:32,Location:32>> || {Offset,Location} <- PackedLineRefs] ++
+		[<<(ai(Name, Atoms)):32>> || Name <- FileNames],
+	list_to_binary(L).
+
+ai(A, As) ->
+	ai(A, As, 0).
+
+ai(A, [A|_], I) -> I;
+ai(A, [_|As], I) ->
+	ai(A, As, I+1).
+
+encode(Specs) ->
+	list_to_binary([enc(S) || S <- lists:concat(Specs)]).
+
+enc({opcode,N}) when N < 128 ->
+	<<0:1,N:7>>;
+enc({opcode,N}) when N < 1024 ->
+	<<58:6,N:10>>;
+enc({opcode,N}) ->
+	<<255,9,N:32>>;
+enc({reg_as_term,X}) when X < 16 ->
+	<<8:4,X:4>>;
+enc({reg_as_term,X}) when X < 256 ->
+	<<250,X>>;
+enc({slot_as_term,Y}) when Y < 16 ->
+	<<9:4,Y:4>>;
+enc({slot_as_term,Y}) when Y < 256 ->
+	<<251,Y>>;
+enc({slot_as_term,Y}) ->
+	<<255,8,Y:32>>;
+enc(N) when is_integer(N), N >= 0, N < 4096 ->
+	<<10:4,N:12>>;
+enc(N) when is_integer(N), N >= 0, N < 1048576 ->
+	<<11:4,N:20>>;
+enc(N) when is_integer(N), N >= 0 ->
+	<<249,N:32>>;
+enc({atom,N}) when N < 4096 ->
+	<<12:4,N:12>>;
+enc({atom,N}) ->
+	<<255,1,N:32>>;
+enc({export,none}) ->
+	<<246>>;	%% very rare - yet a single byte encoding
+enc({export,N}) when N < 4096 ->
+	<<13:4,N:12>>;
+enc({export,N}) ->
+	<<255,2,N:32>>;
+enc({literal,N}) when N < 1024 ->
+	<<56:6,N:10>>;
+enc({literal,N}) ->
+	<<255,3,N:32>>;
+enc({bif,N}) when N < 1024 ->
+	<<57:6,N:10>>;
+enc({bif,N}) ->
+	<<255,4,N:32>>;
+enc({tag_int,I}) when I >= -512, I < 512 ->
+	<<59:6,I:10/signed>>;
+enc({tag_int,I}) ->
+	<<248,I:32/signed>>;
+enc({fu,N}) when N < 1024 ->
+	<<60:6,N:10>>;
+enc({fu,N}) ->
+	<<255,5,N:32>>;
+enc({'catch',N}) when N < 256 ->
+	<<244,N>>;
+enc({'catch',N}) ->
+	<<255,6,N:32>>;
+enc({str,N}) when N < 256 ->
+	<<245,N>>;
+enc({str,N}) ->
+	<<255,7,N:32>>;
+enc(nil) ->
+	<<252>>;
+enc({f,none}) ->
+	<<253>>;
+enc({f,O}) when O < 65536 ->
+	<<254,O:16>>;
+enc({f,O}) ->
+	<<255,0,O:32>>.
+
+%%EOF
+

src/mad_bundle.erl

@@ -2,30 +2,38 @@
 -copyright('Maxim Sokhatsky').
 -compile(export_all).
 
-id(X) -> X.
-
 main(App) ->
     EmuArgs = "-noshell -noinput",
-    Files = static() ++ beams(fun filename:basename/1),
+    Files = static() ++ beams(fun filename:basename/1, fun read_file/1) ++ overlay(),
     escript:create(App,[shebang,{comment,""},{emu_args,EmuArgs},{archive,Files,[memory]}]),
     file:change_mode(App, 8#764),
     false.
 
+id(X) -> X.
 read_file(File) -> {ok, Bin} = file:read_file(filename:absname(File)), Bin.
-
-static() -> Name = "static.gz",
+static() ->
+    Name = "static.gz",
     {ok,{_,Bin}} = zip:create(Name,
         [ F || F <- mad_repl:wildcards(["{apps,deps}/*/priv/**","priv/**"]), not filelib:is_dir(F) ],
-        [{compress,all},memory]), [ { Name, Bin } ].
+        [{compress,all},memory]),
+    [ { Name, Bin } ].
+
+beams() -> beams(fun id/1,  fun read_file/1).
+beams(Fun,Read) ->
+    [ { Fun(F), Read(F) } ||
+        F <- mad_repl:wildcards(["ebin/*","{apps,deps}/*/ebin/*","sys.config",".applist"]) ].
+
+privs() -> privs(fun id/1,  fun read_file/1).
+privs(Fun,Read) ->
+    [ { Fun(F), Read(F) } ||
+        F <- mad_repl:wildcards(["{apps,deps}/*/priv/**","priv/**"]), not filelib:is_dir(F) ].
 
-beams() -> beams(fun id/1).
-beams(Fun) ->
-    [ { Fun(F), read_file(F) } || F <-
-        lists:concat([filelib:wildcard(X)||X <-
-        [ "ebin/*","{apps,deps}/*/ebin/*","sys.config",".applist"]])].
+system_files() -> lists:flatten([system_files(A) || A<- mad_repl:applist(), lists:member(A,mad_repl:system()) ]).
+system_files(App) ->
+    [ { F, mad_bundle:read_file(F) } ||
+        F <- mad_repl:wildcards([lists:concat([code:lib_dir(App),"/ebin/*.{app,beam}"])]) ].
 
-privs() -> privs(fun id/1).
-privs(Fun) ->
-    [ { Fun(F), read_file(F) } || F <-
-        lists:concat([filelib:wildcard(X)||X <-
-        [ F || F <- mad_repl:wildcards(["{apps,deps}/*/priv/**","priv/**"]), not filelib:is_dir(F) ]])].
+overlay() -> overlay(fun id/1,  fun read_file/1).
+overlay(Fun,Read) ->
+    [ { Fun(F), Read(F) } ||
+        F <- mad_repl:wildcards(["deps/ling/apps/*/ebin/*.beam"]) ].

src/mad_ling.erl

@@ -2,36 +2,70 @@
 -description("LING Erlang Virtual Machine Bundle Packaging").
 -copyright('Cloudozer, LLP').
 -compile(export_all).
+-define(ARCH, list_to_atom( case os:getenv("ARCH") of false -> "posix_x86"; A -> A end)).
 
 main(App) ->
     io:format("Bundle Name: ~p~n",[mad_repl:local_app()]),
     io:format("System: ~p~n",     [mad_repl:system()]),
     io:format("Apps: ~p~n",       [mad_repl:applist()]),
-    io:format("Overlay: ~p~n",    [overlay()]),
+    io:format("Overlay: ~p~n",    [[{filename:basename(N),size(B)}||{N,B}<-mad_bundle:overlay()]]),
     io:format("Files: ~p~n",      [[B||{B,_} <- bundle()]]),
     add_apps(),
     false.
 
-bundle()         -> mad_bundle:beams(fun filename:basename/1) ++ mad_bundle:privs().
-cache_dir()      -> ".railing".
-overlay()        -> filelib:wildcard("deps/ling/apps/*/ebin/*.beam").
-local_map(Bucks) -> list_to_binary(lists:map(fun({B,M,_}) ->
-                    io_lib:format("~s /~s\n",[M,B]) end, Bucks)).
+cache_dir()       -> ".railing".
+local_map(Bucks)  -> list_to_binary(lists:map(fun({B,M,_}) -> io_lib:format("~s /~s\n",[M,B]) end,Bucks)).
+bundle()          -> lists:flatten([ mad_bundle:X() || X <- [beams,privs,system_files,overlay] ]).
+library(Filename) -> case filename:split(Filename) of
+    ["deps","ling","apps",Lib|_] -> list_to_atom(Lib);
+                      ["ebin"|_] -> mad_repl:local_app();
+                      ["priv"|_] -> mad_repl:local_app();
+           A when length(A) >= 3 -> list_to_atom(hd(string:tokens(lists:nth(3,lists:reverse(A)),"-")));
+                  ["apps",Lib|_] -> list_to_atom(Lib);
+                  ["deps",Lib|_] -> list_to_atom(Lib);
+                               _ -> mad_repl:local_app() end.
 
-bundle_name() ->
-    case file:get_cwd() of
-         {ok,"/"} -> "himmel";
-         {ok,Cwd} -> filename:basename(Cwd) end.
+apps(Ordered) ->
+    Overlay = [{filename:basename(N),B}||{N,B}<-mad_bundle:overlay()],
+    lists:foldl(fun({N,B},Acc) ->
+        A = library(N),
+        Base = filename:basename(N),
+        Body = case lists:keyfind(Base,1,Overlay) of
+                    false -> B;
+                    {Base,Bin} -> io:format("Overlay: ~p~n",[{A,Base}]), Bin end,
+         case lists:keyfind(A,1,Acc) of
+              false -> [{A,[{A,Base,Body}]}|Acc];
+              {A,Files} -> lists:keyreplace(A,1,Acc,{A,[{A,Base,Body}|Files]}) end
+    end,lists:zip(Ordered,lists:duplicate(length(Ordered),[])),bundle()).
 
-add_apps() ->
-    StartBoot = lists:concat([code:root_dir(),"/bin/start.boot"]),
-    Bucks     = [ {boot, "/boot", [local_map, StartBoot]} ]
-             ++ [ lib(A) || A <- mad_repl:applist() ].
+boot(Ordered) ->
+    {script,Erlang,List} = binary_to_term(element(2,file:read_file(lists:concat([code:root_dir(),"/bin/start.boot"])))),
+    Boot = [ L || L<-List, element(1,L) /= 'apply', L/={'progress',started} ]
+        ++ [{'apply',{application,start_boot,[A,permanent]}} || A <- Ordered ]
+        ++ [{'progress',synrc}],
+    io:format("Boot File: ~p~n",[Boot]),
+    {[],"start.boot",term_to_binary({script,Erlang,List})}.
 
-lib(A) -> A.
+erlang_lib({App,Files}) -> {App,lists:concat(["/erlang/lib/",App,"/ebin"]),Files}.
 
-embed_fs(Bucks)  ->
+add_apps() ->
+    {ok,Ordered} = mad_plan:orderapps(),
+    Bucks     = [ {boot, "/boot", [local_map, boot(Ordered)]} ] ++
+                [ erlang_lib(E) || E <- apps(Ordered) ],
+    io:format("Bucks: ~p~n",[[{App,Mount,[{filename:basename(F),size(Bin)}||{_,F,Bin}<-Files]}||{App,Mount,Files}<-Bucks]]),
     EmbedFsPath   = lists:concat([cache_dir(),"/embed.fs"]),
+    io:format("Initializing GooFS: ..."),
+    Res = embed_fs(EmbedFsPath,Bucks),
+    io:format("~p~n",[Res]),
+	{ok, EmbedFsObject} = embedfs_object(EmbedFsPath),
+	Res = case sh:oneliner(ld() ++
+	           ["vmling.o", EmbedFsObject, "-o", "../" ++ atom_to_list(mad_repl:local_app()) ++ ".img"],
+	           cache_dir()) of
+	           {_,0,_} -> ok;
+	           {_,_,M} -> binary_to_list(M) end,
+    io:format("Linking Image: ~p~n",[Res]).
+
+embed_fs(EmbedFsPath,Bucks)  ->
     {ok, EmbedFs} = file:open(EmbedFsPath, [write]),
     BuckCount = length(Bucks),
     BinCount = lists:foldl(fun({_,_,Bins},Count) -> Count + length(Bins) end,0,Bucks),
@@ -42,14 +76,49 @@ embed_fs(Bucks)  ->
           BuckBinCount = length(Bins),
           file:write(EmbedFs, <<BuckNameSize, BuckName/binary, BuckBinCount:32>>),
           lists:foreach(fun
-                (local_map) -> write_bin(EmbedFs, "local.map", local_map(Bucks));
-                (Bin) -> write_bin(EmbedFs, filename:basename(Bin), element(2,file:read_file(Bin)))
+                    (local_map) -> write_bin(EmbedFs, [], "local.map", local_map(Bucks));
+                  ({App,F,Bin}) -> write_bin(EmbedFs, App, filename:basename(F), Bin)
           end,Bins)
     end,Bucks),
     file:close(EmbedFs).
 
-write_bin(Dev, Bin, Data) ->
-    Name = binary:list_to_bin(Bin),
+embedfs_object(EmbedFsPath) ->
+	EmbedCPath = filename:join(filename:absname(cache_dir()), "embedfs.c"),
+	OutPath = filename:join(filename:absname(cache_dir()), "embedfs.o"),
+	{ok, Embed} = file:read_file(EmbedFsPath),
+	io:format("Creating GooFS C file: ..."),
+	Res = bfd_objcopy:blob_to_src(EmbedCPath, "_binary_embed_fs", Embed),
+    io:format("~p~n",[Res]),
+	io:format("Compilation of Filesystem object: ..."),
+	Res = case sh:oneliner(cc() ++ ["-o", OutPath, "-c", EmbedCPath]) of
+	           {_,0,_} -> ok;
+	           {_,_,M} -> binary_to_list(M) end,
+	io:format("~p~n",[Res]),
+	{ok, OutPath}.
+
+write_bin(Dev, App, F, Bin) ->
+    Name = binary:list_to_bin(F),
+    Data = case filename:extension(F) of ".beam" -> beam_to_ling(Bin); _ -> Bin end,
     NameSize = size(Name),
     DataSize = size(Data),
     file:write(Dev, <<NameSize, Name/binary, DataSize:32, Data/binary>>).
+
+beam_to_ling(B) ->
+    ling_lib:specs_to_binary(element(2,ling_code:ling_to_specs(element(2,ling_code:beam_to_ling(B))))).
+
+gold() -> gold("ld").
+gold(Prog) -> [Prog, "-T", "ling.lds", "-nostdlib"].
+
+ld() -> ld(?ARCH).
+ld(arm) -> gold("arm-none-eabi-ld");
+ld(xen_x86) -> case os:type() of {unix, darwin} -> ["x86_64-pc-linux-ld"]; _ -> gold() end;
+ld(posix_x86) -> case os:type() of {unix, darwin} ->
+    ["ld","-image_base","0x8000","-pagezero_size","0x8000","-arch","x86_64","-framework","System"];
+	_ -> gold() end;
+ld(_) -> gold().
+
+cc() -> cc(?ARCH).
+cc(arm) -> ["arm-none-eabi-gcc", "-mfpu=vfp", "-mfloat-abi=hard"];
+cc(xen_x86) -> case os:type() of {unix, darwin} -> ["x86_64-pc-linux-gcc"]; _ -> ["cc"] end;
+cc(_) -> ["cc"].
+

src/mad_plan.erl

@@ -2,18 +2,20 @@
 -author('Maxim Sokhatsky').
 -compile(export_all).
 
+% dependency graph solver
+
 sort(Pairs) -> iterate(Pairs, [], lhs(Pairs) ++ rhs(Pairs)).
 lhs(L) -> [X || {X, _} <- L].
 rhs(L) -> [Y || {_, Y} <- L].
 rm_pairs(L1, L2) -> [All || All={X, _Y} <- L2, not lists:member(X, L1)].
 subtract(L1, L2) -> [X || X <- L1, not lists:member(X, L2)].
 iterate([], L, All) -> {ok,rm_dups(L ++ subtract(All, L))};
-iterate(Pairs, L, All) -> case subtract(lhs(Pairs), rhs(Pairs)) of [] -> Pairs; Lhs -> iterate(rm_pairs(Lhs, Pairs), L ++ Lhs, All) end.
+iterate(P, L, All) -> case subtract(lhs(P), rhs(P)) of [] -> P; Lhs -> iterate(rm_pairs(Lhs, P), L ++ Lhs, All) end.
 rm_dups([]) -> [];
 rm_dups([H|T]) -> case lists:member(H, T) of true -> rm_dups(T); false -> [H|rm_dups(T)] end.
 
 orderapps() ->
-    Pairs = lists:flatten([ case 
+    Pairs = lists:flatten([ case
        file:consult(F) of
          {ok,[{application,Name,Opt}]} ->
               Apps = proplists:get_value(applications,Opt,[]),
@@ -22,8 +24,7 @@ orderapps() ->
                      true -> [{A,Name}]++ system_deps(A) end || A <- Apps ];
          {error,_} ->
             io:format("AppName: ~p~n",[F]), skip
-    end || F <- filelib:wildcard("{apps,deps}/*/ebin/*.app")  ++ 
-                filelib:wildcard("ebin/*.app"), not filelib:is_dir(F) ]),
+    end || F <- mad_repl:wildcards(["{apps,deps}/*/ebin/*.app","ebin/*.app"]), not filelib:is_dir(F) ]),
     case sort(lists:flatten(Pairs)) of
          {ok,Sorted} -> {ok,Sorted};
          Return -> {error,{cycling_apps,Return}} end.