%% 
%% Search data file for erts 14.1
%% generated September 19, 2023
%% 
{"atomics.html", {function, {"erts", "atomics"}},
[
  {"new", "new(Arity, Opts)", "new-2"},
  {"put", "put(Ref, Ix, Value)", "put-3"},
  {"get", "get(Ref, Ix)", "get-2"},
  {"add", "add(Ref, Ix, Incr)", "add-3"},
  {"add_get", "add_get(Ref, Ix, Incr)", "add_get-3"},
  {"sub", "sub(Ref, Ix, Decr)", "sub-3"},
  {"sub_get", "sub_get(Ref, Ix, Decr)", "sub_get-3"},
  {"exchange", "exchange(Ref, Ix, Desired)", "exchange-3"},
  {"compare_exchange", "compare_exchange(Ref, Ix, Expected, Desired)", "compare_exchange-4"},
  {"info", "info(Ref)", "info-1"}
]}.
{"atomics.html", {module, "erts"}, ["atomics"]}.
{"counters.html", {function, {"erts", "counters"}},
[
  {"new", "new(Size, Opts)", "new-2"},
  {"get", "get(Ref, Ix)", "get-2"},
  {"add", "add(Ref, Ix, Incr)", "add-3"},
  {"sub", "sub(Ref, Ix, Decr)", "sub-3"},
  {"put", "put(Ref, Ix, Value)", "put-3"},
  {"info", "info(Ref)", "info-1"}
]}.
{"counters.html", {module, "erts"}, ["counters"]}.
{"driver_entry.html", {function, {"erts", "driver_entry"}}, [
]}.
{"driver_entry.html", {clib, "erts"}, ["driver_entry"]}.
{"epmd.html", {command, "erts"}, ["epmd"]}.
{"erl.html", {command, "erts"}, ["erl"]}.
{"erlang.html", {function, {"erts", "erlang"}},
[
  {"abs", "abs(Float)", "abs-1"},
  {"abs", "abs(Int)", "abs-1"},
  {"adler32", "erlang:adler32(Data)", "adler32-1"},
  {"adler32", "erlang:adler32(OldAdler, Data)", "adler32-2"},
  {"adler32_combine", "erlang:adler32_combine(FirstAdler, SecondAdler, SecondSize)", "adler32_combine-3"},
  {"alias", "alias()", "alias-0"},
  {"alias", "alias(Opts)", "alias-1"},
  {"append_element", "erlang:append_element(Tuple1, Term)", "append_element-2"},
  {"apply", "apply(Fun, Args)", "apply-2"},
  {"apply", "apply(Module, Function, Args)", "apply-3"},
  {"atom_to_binary", "atom_to_binary(Atom)", "atom_to_binary-1"},
  {"atom_to_binary", "atom_to_binary(Atom, Encoding)", "atom_to_binary-2"},
  {"atom_to_list", "atom_to_list(Atom)", "atom_to_list-1"},
  {"binary_part", "binary_part(Subject, PosLen)", "binary_part-2"},
  {"binary_part", "binary_part(Subject, Start, Length)", "binary_part-3"},
  {"binary_to_atom", "binary_to_atom(Binary)", "binary_to_atom-1"},
  {"binary_to_atom", "binary_to_atom(Binary, Encoding)", "binary_to_atom-2"},
  {"binary_to_existing_atom", "binary_to_existing_atom(Binary)", "binary_to_existing_atom-1"},
  {"binary_to_existing_atom", "binary_to_existing_atom(Binary, Encoding)", "binary_to_existing_atom-2"},
  {"binary_to_float", "binary_to_float(Binary)", "binary_to_float-1"},
  {"binary_to_integer", "binary_to_integer(Binary)", "binary_to_integer-1"},
  {"binary_to_integer", "binary_to_integer(Binary, Base)", "binary_to_integer-2"},
  {"binary_to_list", "binary_to_list(Binary)", "binary_to_list-1"},
  {"binary_to_list", "binary_to_list(Binary, Start, Stop)", "binary_to_list-3"},
  {"binary_to_term", "binary_to_term(Binary)", "binary_to_term-1"},
  {"binary_to_term", "binary_to_term(Binary, Opts)", "binary_to_term-2"},
  {"bit_size", "bit_size(Bitstring)", "bit_size-1"},
  {"bitstring_to_list", "bitstring_to_list(Bitstring)", "bitstring_to_list-1"},
  {"bump_reductions", "erlang:bump_reductions(Reductions)", "bump_reductions-1"},
  {"byte_size", "byte_size(Bitstring)", "byte_size-1"},
  {"cancel_timer", "erlang:cancel_timer(TimerRef)", "cancel_timer-1"},
  {"cancel_timer", "erlang:cancel_timer(TimerRef, Options)", "cancel_timer-2"},
  {"ceil", "ceil(Number)", "ceil-1"},
  {"check_old_code", "check_old_code(Module)", "check_old_code-1"},
  {"check_process_code", "check_process_code(Pid, Module)", "check_process_code-2"},
  {"check_process_code", "check_process_code(Pid, Module, OptionList)", "check_process_code-3"},
  {"convert_time_unit", "erlang:convert_time_unit(Time, FromUnit, ToUnit)", "convert_time_unit-3"},
  {"crc32", "erlang:crc32(Data)", "crc32-1"},
  {"crc32", "erlang:crc32(OldCrc, Data)", "crc32-2"},
  {"crc32_combine", "erlang:crc32_combine(FirstCrc, SecondCrc, SecondSize)", "crc32_combine-3"},
  {"date", "date()", "date-0"},
  {"decode_packet", "erlang:decode_packet(Type, Bin, Options)", "decode_packet-3"},
  {"delete_element", "erlang:delete_element(Index, Tuple1)", "delete_element-2"},
  {"delete_module", "delete_module(Module)", "delete_module-1"},
  {"demonitor", "demonitor(MonitorRef)", "demonitor-1"},
  {"demonitor", "demonitor(MonitorRef, OptionList)", "demonitor-2"},
  {"disconnect_node", "disconnect_node(Node)", "disconnect_node-1"},
  {"display", "erlang:display(Term)", "display-1"},
  {"dist_ctrl_get_data", "erlang:dist_ctrl_get_data(DHandle)", "dist_ctrl_get_data-1"},
  {"dist_ctrl_get_opt", "erlang:dist_ctrl_get_opt(DHandle, Opt :: get_size)", "dist_ctrl_get_opt-2"},
  {"dist_ctrl_get_data_notification", "erlang:dist_ctrl_get_data_notification(DHandle)", "dist_ctrl_get_data_notification-1"},
  {"dist_ctrl_input_handler", "erlang:dist_ctrl_input_handler(DHandle, InputHandler)", "dist_ctrl_input_handler-2"},
  {"dist_ctrl_put_data", "erlang:dist_ctrl_put_data(DHandle, Data)", "dist_ctrl_put_data-2"},
  {"dist_ctrl_set_opt", "erlang:dist_ctrl_set_opt(DHandle, Opt :: get_size, Value)", "dist_ctrl_set_opt-3"},
  {"element", "element(N, Tuple)", "element-2"},
  {"erase", "erase()", "erase-0"},
  {"erase", "erase(Key)", "erase-1"},
  {"error", "error(Reason)", "error-1"},
  {"error", "error(Reason, Args)", "error-2"},
  {"error", "error(Reason, Args, Options)", "error-3"},
  {"exit", "exit(Reason)", "exit-1"},
  {"exit", "exit(Pid, Reason)", "exit-2"},
  {"external_size", "erlang:external_size(Term)", "external_size-1"},
  {"external_size", "erlang:external_size(Term, Options)", "external_size-2"},
  {"float", "float(Number)", "float-1"},
  {"float_to_binary", "float_to_binary(Float)", "float_to_binary-1"},
  {"float_to_binary", "float_to_binary(Float, Options)", "float_to_binary-2"},
  {"float_to_list", "float_to_list(Float)", "float_to_list-1"},
  {"float_to_list", "float_to_list(Float, Options)", "float_to_list-2"},
  {"floor", "floor(Number)", "floor-1"},
  {"fun_info", "erlang:fun_info(Fun)", "fun_info-1"},
  {"fun_info", "erlang:fun_info(Fun, Item)", "fun_info-2"},
  {"fun_to_list", "erlang:fun_to_list(Fun)", "fun_to_list-1"},
  {"function_exported", "erlang:function_exported(Module, Function, Arity)", "function_exported-3"},
  {"garbage_collect", "garbage_collect()", "garbage_collect-0"},
  {"garbage_collect", "garbage_collect(Pid)", "garbage_collect-1"},
  {"garbage_collect", "garbage_collect(Pid, OptionList)", "garbage_collect-2"},
  {"get", "get()", "get-0"},
  {"get", "get(Key)", "get-1"},
  {"get_cookie", "erlang:get_cookie()", "get_cookie-0"},
  {"get_cookie", "erlang:get_cookie(Node)", "get_cookie-1"},
  {"get_keys", "get_keys()", "get_keys-0"},
  {"get_keys", "get_keys(Val)", "get_keys-1"},
  {"group_leader", "group_leader()", "group_leader-0"},
  {"group_leader", "group_leader(GroupLeader, Pid)", "group_leader-2"},
  {"halt", "halt()", "halt-0"},
  {"halt", "halt(Status :: integer() >= 0)", "halt-1"},
  {"halt", "halt(Abort :: abort)", "halt-1"},
  {"halt", "halt(CrashDumpSlogan :: string())", "halt-1"},
  {"halt", "halt(Status :: integer() >= 0, Options :: halt_options())", "halt-2"},
  {"halt", "halt(Abort :: abort, Options :: halt_options())", "halt-2"},
  {"halt", "halt(CrashDumpSlogan :: string(), Options :: halt_options())", "halt-2"},
  {"hd", "hd(List)", "hd-1"},
  {"hibernate", "erlang:hibernate(Module, Function, Args)", "hibernate-3"},
  {"insert_element", "erlang:insert_element(Index, Tuple1, Term)", "insert_element-3"},
  {"integer_to_binary", "integer_to_binary(Integer)", "integer_to_binary-1"},
  {"integer_to_binary", "integer_to_binary(Integer, Base)", "integer_to_binary-2"},
  {"integer_to_list", "integer_to_list(Integer)", "integer_to_list-1"},
  {"integer_to_list", "integer_to_list(Integer, Base)", "integer_to_list-2"},
  {"iolist_size", "iolist_size(Item)", "iolist_size-1"},
  {"iolist_to_binary", "iolist_to_binary(IoListOrBinary)", "iolist_to_binary-1"},
  {"iolist_to_iovec", "erlang:iolist_to_iovec(IoListOrBinary)", "iolist_to_iovec-1"},
  {"is_alive", "is_alive()", "is_alive-0"},
  {"is_atom", "is_atom(Term)", "is_atom-1"},
  {"is_binary", "is_binary(Term)", "is_binary-1"},
  {"is_bitstring", "is_bitstring(Term)", "is_bitstring-1"},
  {"is_boolean", "is_boolean(Term)", "is_boolean-1"},
  {"is_builtin", "erlang:is_builtin(Module, Function, Arity)", "is_builtin-3"},
  {"is_float", "is_float(Term)", "is_float-1"},
  {"is_function", "is_function(Term)", "is_function-1"},
  {"is_function", "is_function(Term, Arity)", "is_function-2"},
  {"is_integer", "is_integer(Term)", "is_integer-1"},
  {"is_list", "is_list(Term)", "is_list-1"},
  {"is_map", "is_map(Term)", "is_map-1"},
  {"is_map_key", "is_map_key(Key, Map)", "is_map_key-2"},
  {"is_number", "is_number(Term)", "is_number-1"},
  {"is_pid", "is_pid(Term)", "is_pid-1"},
  {"is_port", "is_port(Term)", "is_port-1"},
  {"is_process_alive", "is_process_alive(Pid)", "is_process_alive-1"},
  {"is_record", "is_record(Term, RecordTag)", "is_record-2"},
  {"is_record", "is_record(Term, RecordTag, Size)", "is_record-3"},
  {"is_reference", "is_reference(Term)", "is_reference-1"},
  {"is_tuple", "is_tuple(Term)", "is_tuple-1"},
  {"length", "length(List)", "length-1"},
  {"link", "link(PidOrPort)", "link-1"},
  {"list_to_atom", "list_to_atom(String)", "list_to_atom-1"},
  {"list_to_binary", "list_to_binary(IoList)", "list_to_binary-1"},
  {"list_to_bitstring", "list_to_bitstring(BitstringList)", "list_to_bitstring-1"},
  {"list_to_existing_atom", "list_to_existing_atom(String)", "list_to_existing_atom-1"},
  {"list_to_float", "list_to_float(String)", "list_to_float-1"},
  {"list_to_integer", "list_to_integer(String)", "list_to_integer-1"},
  {"list_to_integer", "list_to_integer(String, Base)", "list_to_integer-2"},
  {"list_to_pid", "list_to_pid(String)", "list_to_pid-1"},
  {"list_to_port", "list_to_port(String)", "list_to_port-1"},
  {"list_to_ref", "list_to_ref(String)", "list_to_ref-1"},
  {"list_to_tuple", "list_to_tuple(List)", "list_to_tuple-1"},
  {"load_module", "load_module(Module, Binary)", "load_module-2"},
  {"load_nif", "erlang:load_nif(Path, LoadInfo)", "load_nif-2"},
  {"loaded", "erlang:loaded()", "loaded-0"},
  {"localtime", "erlang:localtime()", "localtime-0"},
  {"localtime_to_universaltime", "erlang:localtime_to_universaltime(Localtime)", "localtime_to_universaltime-1"},
  {"localtime_to_universaltime", "erlang:localtime_to_universaltime(Localtime, IsDst)", "localtime_to_universaltime-2"},
  {"make_ref", "make_ref()", "make_ref-0"},
  {"make_tuple", "erlang:make_tuple(Arity, InitialValue)", "make_tuple-2"},
  {"make_tuple", "erlang:make_tuple(Arity, DefaultValue, InitList)", "make_tuple-3"},
  {"map_get", "map_get(Key, Map)", "map_get-2"},
  {"map_size", "map_size(Map)", "map_size-1"},
  {"match_spec_test", "erlang:match_spec_test(MatchAgainst, MatchSpec, Type)", "match_spec_test-3"},
  {"max", "max(Term1, Term2)", "max-2"},
  {"md5", "erlang:md5(Data)", "md5-1"},
  {"md5_final", "erlang:md5_final(Context)", "md5_final-1"},
  {"md5_init", "erlang:md5_init()", "md5_init-0"},
  {"md5_update", "erlang:md5_update(Context, Data)", "md5_update-2"},
  {"memory", "erlang:memory()", "memory-0"},
  {"memory", "erlang:memory(Type :: memory_type())", "memory-1"},
  {"memory", "erlang:memory(TypeList :: [memory_type()])", "memory-1"},
  {"min", "min(Term1, Term2)", "min-2"},
  {"module_loaded", "module_loaded(Module)", "module_loaded-1"},
  {"monitor", "monitor(Type :: process, Item :: monitor_process_identifier())", "monitor-2"},
  {"monitor", "monitor(Type :: port, Item :: monitor_port_identifier())", "monitor-2"},
  {"monitor", "monitor(Type :: time_offset, Item :: clock_service)", "monitor-2"},
  {"monitor", "monitor(Type :: process,Item :: monitor_process_identifier(),Opts :: [monitor_option()])", "monitor-3"},
  {"monitor", "monitor(Type :: port,Item :: monitor_port_identifier(),Opts :: [monitor_option()])", "monitor-3"},
  {"monitor", "monitor(Type :: time_offset,Item :: clock_service,Opts :: [monitor_option()])", "monitor-3"},
  {"monitor_node", "monitor_node(Node, Flag)", "monitor_node-2"},
  {"monitor_node", "erlang:monitor_node(Node, Flag, Options)", "monitor_node-3"},
  {"monotonic_time", "erlang:monotonic_time()", "monotonic_time-0"},
  {"monotonic_time", "erlang:monotonic_time(Unit)", "monotonic_time-1"},
  {"nif_error", "erlang:nif_error(Reason)", "nif_error-1"},
  {"nif_error", "erlang:nif_error(Reason, Args)", "nif_error-2"},
  {"node", "node()", "node-0"},
  {"node", "node(Arg)", "node-1"},
  {"nodes", "nodes()", "nodes-0"},
  {"nodes", "nodes(Arg)", "nodes-1"},
  {"nodes", "nodes(Arg, InfoOpts)", "nodes-2"},
  {"now", "now()", "now-0"},
  {"open_port", "open_port(PortName, PortSettings)", "open_port-2"},
  {"phash", "erlang:phash(Term, Range)", "phash-2"},
  {"phash2", "erlang:phash2(Term)", "phash2-1"},
  {"phash2", "erlang:phash2(Term, Range)", "phash2-2"},
  {"pid_to_list", "pid_to_list(Pid)", "pid_to_list-1"},
  {"port_call", "erlang:port_call(Port, Operation, Data)", "port_call-3"},
  {"port_close", "port_close(Port)", "port_close-1"},
  {"port_command", "port_command(Port, Data)", "port_command-2"},
  {"port_command", "port_command(Port, Data, OptionList)", "port_command-3"},
  {"port_connect", "port_connect(Port, Pid)", "port_connect-2"},
  {"port_control", "port_control(Port, Operation, Data)", "port_control-3"},
  {"port_info", "erlang:port_info(Port)", "port_info-1"},
  {"port_info", "erlang:port_info(Port, Item :: connected)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: id)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: input)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: links)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: locking)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: memory)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: monitors)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: monitored_by)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: name)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: os_pid)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: output)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: parallelism)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: queue_size)", "port_info-2"},
  {"port_info", "erlang:port_info(Port, Item :: registered_name)", "port_info-2"},
  {"port_to_list", "port_to_list(Port)", "port_to_list-1"},
  {"ports", "erlang:ports()", "ports-0"},
  {"pre_loaded", "pre_loaded()", "pre_loaded-0"},
  {"process_display", "erlang:process_display(Pid, Type)", "process_display-2"},
  {"process_flag", "process_flag(Flag :: async_dist, Boolean)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: trap_exit, Boolean)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: error_handler, Module)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: fullsweep_after, FullsweepAfter)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: min_heap_size, MinHeapSize)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: min_bin_vheap_size, MinBinVHeapSize)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: max_heap_size, MaxHeapSize)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: message_queue_data, MQD)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: priority, Level)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: save_calls, N)", "process_flag-2"},
  {"process_flag", "process_flag(Flag :: sensitive, Boolean)", "process_flag-2"},
  {"process_flag", "process_flag(Pid, Flag, Value)", "process_flag-3"},
  {"process_info", "process_info(Pid)", "process_info-1"},
  {"process_info", "process_info(Pid, Item)", "process_info-2"},
  {"process_info", "process_info(Pid, ItemList)", "process_info-2"},
  {"processes", "processes()", "processes-0"},
  {"purge_module", "purge_module(Module)", "purge_module-1"},
  {"put", "put(Key, Val)", "put-2"},
  {"raise", "erlang:raise(Class, Reason, Stacktrace)", "raise-3"},
  {"read_timer", "erlang:read_timer(TimerRef)", "read_timer-1"},
  {"read_timer", "erlang:read_timer(TimerRef, Options)", "read_timer-2"},
  {"ref_to_list", "ref_to_list(Ref)", "ref_to_list-1"},
  {"register", "register(RegName, PidOrPort)", "register-2"},
  {"registered", "registered()", "registered-0"},
  {"resume_process", "erlang:resume_process(Suspendee)", "resume_process-1"},
  {"round", "round(Number)", "round-1"},
  {"self", "self()", "self-0"},
  {"send", "erlang:send(Dest, Msg)", "send-2"},
  {"send", "erlang:send(Dest, Msg, Options)", "send-3"},
  {"send_after", "erlang:send_after(Time, Dest, Msg)", "send_after-3"},
  {"send_after", "erlang:send_after(Time, Dest, Msg, Options)", "send_after-4"},
  {"send_nosuspend", "erlang:send_nosuspend(Dest, Msg)", "send_nosuspend-2"},
  {"send_nosuspend", "erlang:send_nosuspend(Dest, Msg, Options)", "send_nosuspend-3"},
  {"set_cookie", "erlang:set_cookie(Cookie)", "set_cookie-1"},
  {"set_cookie", "erlang:set_cookie(Node, Cookie)", "set_cookie-2"},
  {"setelement", "setelement(Index, Tuple1, Value)", "setelement-3"},
  {"size", "size(Item)", "size-1"},
  {"spawn", "spawn(Fun)", "spawn-1"},
  {"spawn", "spawn(Node, Fun)", "spawn-2"},
  {"spawn", "spawn(Module, Function, Args)", "spawn-3"},
  {"spawn", "spawn(Node, Module, Function, Args)", "spawn-4"},
  {"spawn_link", "spawn_link(Fun)", "spawn_link-1"},
  {"spawn_link", "spawn_link(Node, Fun)", "spawn_link-2"},
  {"spawn_link", "spawn_link(Module, Function, Args)", "spawn_link-3"},
  {"spawn_link", "spawn_link(Node, Module, Function, Args)", "spawn_link-4"},
  {"spawn_monitor", "spawn_monitor(Fun)", "spawn_monitor-1"},
  {"spawn_monitor", "spawn_monitor(Node, Fun)", "spawn_monitor-2"},
  {"spawn_monitor", "spawn_monitor(Module, Function, Args)", "spawn_monitor-3"},
  {"spawn_monitor", "spawn_monitor(Node, Module, Function, Args)", "spawn_monitor-4"},
  {"spawn_opt", "spawn_opt(Fun, Options)", "spawn_opt-2"},
  {"spawn_opt", "spawn_opt(Node, Fun, Options)", "spawn_opt-3"},
  {"spawn_opt", "spawn_opt(Module, Function, Args, Options)", "spawn_opt-4"},
  {"spawn_opt", "spawn_opt(Node, Module, Function, Args, Options)", "spawn_opt-5"},
  {"spawn_request", "spawn_request(Fun)", "spawn_request-1"},
  {"spawn_request", "spawn_request(Fun, Options)", "spawn_request-2"},
  {"spawn_request", "spawn_request(Node, Fun)", "spawn_request-2"},
  {"spawn_request", "spawn_request(Node, Fun, Options)", "spawn_request-3"},
  {"spawn_request", "spawn_request(Module, Function, Args)", "spawn_request-3"},
  {"spawn_request", "spawn_request(Node, Module, Function, Args)", "spawn_request-4"},
  {"spawn_request", "spawn_request(Module, Function, Args, Options)", "spawn_request-4"},
  {"spawn_request", "spawn_request(Node, Module, Function, Args, Options)", "spawn_request-5"},
  {"spawn_request_abandon", "spawn_request_abandon(ReqId :: reference())", "spawn_request_abandon-1"},
  {"split_binary", "split_binary(Bin, Pos)", "split_binary-2"},
  {"start_timer", "erlang:start_timer(Time, Dest, Msg)", "start_timer-3"},
  {"start_timer", "erlang:start_timer(Time, Dest, Msg, Options)", "start_timer-4"},
  {"statistics", "statistics(Item :: active_tasks)", "statistics-1"},
  {"statistics", "statistics(Item :: active_tasks_all)", "statistics-1"},
  {"statistics", "statistics(Item :: context_switches)", "statistics-1"},
  {"statistics", "statistics(Item :: exact_reductions)", "statistics-1"},
  {"statistics", "statistics(Item :: garbage_collection)", "statistics-1"},
  {"statistics", "statistics(Item :: io)", "statistics-1"},
  {"statistics", "statistics(Item :: microstate_accounting)", "statistics-1"},
  {"statistics", "statistics(Item :: reductions)", "statistics-1"},
  {"statistics", "statistics(Item :: run_queue)", "statistics-1"},
  {"statistics", "statistics(Item :: run_queue_lengths)", "statistics-1"},
  {"statistics", "statistics(Item :: run_queue_lengths_all)", "statistics-1"},
  {"statistics", "statistics(Item :: runtime)", "statistics-1"},
  {"statistics", "statistics(Item :: scheduler_wall_time)", "statistics-1"},
  {"statistics", "statistics(Item :: scheduler_wall_time_all)", "statistics-1"},
  {"statistics", "statistics(Item :: total_active_tasks)", "statistics-1"},
  {"statistics", "statistics(Item :: total_active_tasks_all)", "statistics-1"},
  {"statistics", "statistics(Item :: total_run_queue_lengths)", "statistics-1"},
  {"statistics", "statistics(Item :: total_run_queue_lengths_all)", "statistics-1"},
  {"statistics", "statistics(Item :: wall_clock)", "statistics-1"},
  {"suspend_process", "erlang:suspend_process(Suspendee)", "suspend_process-1"},
  {"suspend_process", "erlang:suspend_process(Suspendee, OptList)", "suspend_process-2"},
  {"system_flag", "erlang:system_flag(Flag :: backtrace_depth, Depth)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: cpu_topology, CpuTopology)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: dirty_cpu_schedulers_online,DirtyCPUSchedulersOnline)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: erts_alloc, Value :: {Alloc, F, V})", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: fullsweep_after, Number)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: microstate_accounting, Action)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: min_heap_size, MinHeapSize)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: min_bin_vheap_size, MinBinVHeapSize)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: max_heap_size, MaxHeapSize)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: multi_scheduling, BlockState)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: outstanding_system_requests_limit,NewLimit)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: scheduler_bind_type, How)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: scheduler_wall_time, Boolean)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: schedulers_online, SchedulersOnline)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: system_logger, Logger)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: trace_control_word, TCW)", "system_flag-2"},
  {"system_flag", "erlang:system_flag(Flag :: time_offset, Value :: finalize)", "system_flag-2"},
  {"system_info", "erlang:system_info(Item :: overview)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: allocated_areas)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: allocator)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: {allocator, Alloc})", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: alloc_util_allocators)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: {allocator_sizes, Alloc})", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: cpu_topology)", "system_info-1"},
  {"system_info", "erlang:system_info(Item ::{cpu_topology, defined | detected | used})", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: cpu_quota)", "system_info-1"},
  {"system_info", "erlang:system_info(Item ::logical_processors |logical_processors_available |logical_processors_online)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: update_cpu_info)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: fullsweep_after)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: garbage_collection)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: heap_sizes)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: heap_type)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: max_heap_size)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: message_queue_data)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: min_heap_size)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: min_bin_vheap_size)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: procs)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: atom_count)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: atom_limit)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: ets_count)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: ets_limit)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: port_parallelism)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: port_count)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: port_limit)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: process_count)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: end_time)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: os_monotonic_time_source)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: os_system_time_source)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: start_time)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: time_correction)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: time_offset)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: time_warp_mode)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: tolerant_timeofday)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dirty_cpu_schedulers)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dirty_cpu_schedulers_online)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dirty_io_schedulers)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: multi_scheduling)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: multi_scheduling_blockers)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: normal_multi_scheduling_blockers)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: scheduler_bind_type)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: scheduler_bindings)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: scheduler_id)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: schedulers | schedulers_online)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: smp_support)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: threads)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: thread_pool_size)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: async_dist)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: creation)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: delayed_node_table_gc)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dist)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dist_buf_busy_limit)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dist_ctrl)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: c_compiler_used)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: check_io)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: compat_rel)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: debug_compiled)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: driver_version)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dynamic_trace)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: dynamic_trace_probes)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: emu_flavor)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: emu_type)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: info)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: kernel_poll)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: loaded)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: machine)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: modified_timing_level)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: nif_version)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: otp_release)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: outstanding_system_requests_limit)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: port_parallelism)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: system_architecture)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: system_logger)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: system_version)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: trace_control_word)", "system_info-1"},
  {"system_info", "erlang:system_info(Item :: version)", "system_info-1"},
  {"system_info", "erlang:system_info(Item ::wordsize |{wordsize, internal} |{wordsize, external})", "system_info-1"},
  {"system_monitor", "erlang:system_monitor()", "system_monitor-0"},
  {"system_monitor", "erlang:system_monitor(Arg)", "system_monitor-1"},
  {"system_monitor", "erlang:system_monitor(MonitorPid, Options)", "system_monitor-2"},
  {"system_profile", "erlang:system_profile()", "system_profile-0"},
  {"system_profile", "erlang:system_profile(ProfilerPid, Options)", "system_profile-2"},
  {"system_time", "erlang:system_time()", "system_time-0"},
  {"system_time", "erlang:system_time(Unit)", "system_time-1"},
  {"term_to_binary", "term_to_binary(Term)", "term_to_binary-1"},
  {"term_to_binary", "term_to_binary(Term, Options)", "term_to_binary-2"},
  {"term_to_iovec", "term_to_iovec(Term)", "term_to_iovec-1"},
  {"term_to_iovec", "term_to_iovec(Term, Options)", "term_to_iovec-2"},
  {"throw", "throw(Any)", "throw-1"},
  {"time", "time()", "time-0"},
  {"time_offset", "erlang:time_offset()", "time_offset-0"},
  {"time_offset", "erlang:time_offset(Unit)", "time_offset-1"},
  {"timestamp", "erlang:timestamp()", "timestamp-0"},
  {"tl", "tl(List)", "tl-1"},
  {"trace", "erlang:trace(PidPortSpec, How, FlagList)", "trace-3"},
  {"trace_delivered", "erlang:trace_delivered(Tracee)", "trace_delivered-1"},
  {"trace_info", "erlang:trace_info(PidPortFuncEvent, Item)", "trace_info-2"},
  {"trace_pattern", "erlang:trace_pattern(MFA, MatchSpec)", "trace_pattern-2"},
  {"trace_pattern", "erlang:trace_pattern(MFA :: send, MatchSpec, FlagList :: [])", "trace_pattern-3"},
  {"trace_pattern", "erlang:trace_pattern(MFA :: 'receive', MatchSpec, FlagList :: [])", "trace_pattern-3"},
  {"trace_pattern", "erlang:trace_pattern(MFA, MatchSpec, FlagList)", "trace_pattern-3"},
  {"trunc", "trunc(Number)", "trunc-1"},
  {"tuple_size", "tuple_size(Tuple)", "tuple_size-1"},
  {"tuple_to_list", "tuple_to_list(Tuple)", "tuple_to_list-1"},
  {"unalias", "unalias(Alias)", "unalias-1"},
  {"unique_integer", "erlang:unique_integer()", "unique_integer-0"},
  {"unique_integer", "erlang:unique_integer(ModifierList)", "unique_integer-1"},
  {"universaltime", "erlang:universaltime()", "universaltime-0"},
  {"universaltime_to_localtime", "erlang:universaltime_to_localtime(Universaltime)", "universaltime_to_localtime-1"},
  {"unlink", "unlink(Id)", "unlink-1"},
  {"unregister", "unregister(RegName)", "unregister-1"},
  {"whereis", "whereis(RegName)", "whereis-1"},
  {"yield", "erlang:yield()", "yield-0"}
]}.
{"erlang.html", {module, "erts"}, ["erlang"]}.
{"erlc.html", {command, "erts"}, ["erlc"]}.
{"erl_driver.html", {function, {"erts", "erl_driver"}}, [
  {"add_driver_entry", "add_driver_entry(ErlDrvEntry *de)", "add_driver_entry"},
  {"driver_alloc", "driver_alloc(ErlDrvSizeT size)", "driver_alloc"},
  {"driver_alloc_binary", "driver_alloc_binary(ErlDrvSizeT size)", "driver_alloc_binary"},
  {"driver_async", "driver_async(ErlDrvPort port, unsigned int* key, void (*async_invoke)(void*), void* async_data, void (*async_free)(void*))", "driver_async"},
  {"driver_async_port_key", "driver_async_port_key(ErlDrvPort port)", "driver_async_port_key"},
  {"driver_binary_dec_refc", "driver_binary_dec_refc(ErlDrvBinary *bin)", "driver_binary_dec_refc"},
  {"driver_binary_get_refc", "driver_binary_get_refc(ErlDrvBinary *bin)", "driver_binary_get_refc"},
  {"driver_binary_inc_refc", "driver_binary_inc_refc(ErlDrvBinary *bin)", "driver_binary_inc_refc"},
  {"driver_caller", "driver_caller(ErlDrvPort port)", "driver_caller"},
  {"driver_cancel_timer", "driver_cancel_timer(ErlDrvPort port)", "driver_cancel_timer"},
  {"driver_compare_monitors", "driver_compare_monitors(const ErlDrvMonitor *monitor1, const ErlDrvMonitor *monitor2)", "driver_compare_monitors"},
  {"driver_connected", "driver_connected(ErlDrvPort port)", "driver_connected"},
  {"driver_create_port", "driver_create_port(ErlDrvPort port, ErlDrvTermData owner_pid, char* name, ErlDrvData drv_data)", "driver_create_port"},
  {"driver_demonitor_process", "driver_demonitor_process(ErlDrvPort port, const ErlDrvMonitor *monitor)", "driver_demonitor_process"},
  {"driver_deq", "driver_deq(ErlDrvPort port, ErlDrvSizeT size)", "driver_deq"},
  {"driver_enq", "driver_enq(ErlDrvPort port, char* buf, ErlDrvSizeT len)", "driver_enq"},
  {"driver_enq_bin", "driver_enq_bin(ErlDrvPort port, ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)", "driver_enq_bin"},
  {"driver_enqv", "driver_enqv(ErlDrvPort port, ErlIOVec *ev, ErlDrvSizeT skip)", "driver_enqv"},
  {"driver_failure", "driver_failure(ErlDrvPort port, int error)", "driver_failure"},
  {"driver_failure_atom", "driver_failure_atom(ErlDrvPort port, char *string)", "driver_failure_atom"},
  {"driver_failure_posix", "driver_failure_posix(ErlDrvPort port, int error)", "driver_failure_posix"},
  {"driver_failure_eof", "driver_failure_eof(ErlDrvPort port)", "driver_failure_eof"},
  {"driver_free", "driver_free(void *ptr)", "driver_free"},
  {"driver_free_binary", "driver_free_binary(ErlDrvBinary *bin)", "driver_free_binary"},
  {"driver_get_monitored_process", "driver_get_monitored_process(ErlDrvPort port, const ErlDrvMonitor *monitor)", "driver_get_monitored_process"},
  {"driver_get_now", "driver_get_now(ErlDrvNowData *now)", "driver_get_now"},
  {"driver_lock_driver", "driver_lock_driver(ErlDrvPort port)", "driver_lock_driver"},
  {"driver_mk_atom", "driver_mk_atom(char* string)", "driver_mk_atom"},
  {"driver_mk_port", "driver_mk_port(ErlDrvPort port)", "driver_mk_port"},
  {"driver_monitor_process", "driver_monitor_process(ErlDrvPort port, ErlDrvTermData process, ErlDrvMonitor *monitor)", "driver_monitor_process"},
  {"driver_output", "driver_output(ErlDrvPort port, char *buf, ErlDrvSizeT len)", "driver_output"},
  {"driver_output_binary", "driver_output_binary(ErlDrvPort port, char *hbuf, ErlDrvSizeT hlen, ErlDrvBinary* bin, ErlDrvSizeT offset, ErlDrvSizeT len)", "driver_output_binary"},
  {"driver_output_term", "driver_output_term(ErlDrvPort port, ErlDrvTermData* term, int n)", "driver_output_term"},
  {"driver_output2", "driver_output2(ErlDrvPort port, char *hbuf, ErlDrvSizeT hlen, char *buf, ErlDrvSizeT len)", "driver_output2"},
  {"driver_outputv", "driver_outputv(ErlDrvPort port, char* hbuf, ErlDrvSizeT hlen, ErlIOVec *ev, ErlDrvSizeT skip)", "driver_outputv"},
  {"driver_pdl_create", "driver_pdl_create(ErlDrvPort port)", "driver_pdl_create"},
  {"driver_pdl_dec_refc", "driver_pdl_dec_refc(ErlDrvPDL pdl)", "driver_pdl_dec_refc"},
  {"driver_pdl_get_refc", "driver_pdl_get_refc(ErlDrvPDL pdl)", "driver_pdl_get_refc"},
  {"driver_pdl_inc_refc", "driver_pdl_inc_refc(ErlDrvPDL pdl)", "driver_pdl_inc_refc"},
  {"driver_pdl_lock", "driver_pdl_lock(ErlDrvPDL pdl)", "driver_pdl_lock"},
  {"driver_pdl_unlock", "driver_pdl_unlock(ErlDrvPDL pdl)", "driver_pdl_unlock"},
  {"driver_peekq", "driver_peekq(ErlDrvPort port, int *vlen)", "driver_peekq"},
  {"driver_peekqv", "driver_peekqv(ErlDrvPort port, ErlIOVec *ev)", "driver_peekqv"},
  {"driver_pushq", "driver_pushq(ErlDrvPort port, char* buf, ErlDrvSizeT len)", "driver_pushq"},
  {"driver_pushq_bin", "driver_pushq_bin(ErlDrvPort port, ErlDrvBinary *bin, ErlDrvSizeT offset, ErlDrvSizeT len)", "driver_pushq_bin"},
  {"driver_pushqv", "driver_pushqv(ErlDrvPort port, ErlIOVec *ev, ErlDrvSizeT skip)", "driver_pushqv"},
  {"driver_read_timer", "driver_read_timer(ErlDrvPort port, unsigned long *time_left)", "driver_read_timer"},
  {"driver_realloc", "driver_realloc(void *ptr, ErlDrvSizeT size)", "driver_realloc"},
  {"driver_realloc_binary", "driver_realloc_binary(ErlDrvBinary *bin, ErlDrvSizeT size)", "driver_realloc_binary"},
  {"driver_select", "driver_select(ErlDrvPort port, ErlDrvEvent event, int mode, int on)", "driver_select"},
  {"driver_send_term", "driver_send_term(ErlDrvPort port, ErlDrvTermData receiver, ErlDrvTermData* term, int n)", "driver_send_term"},
  {"driver_set_timer", "driver_set_timer(ErlDrvPort port, unsigned long time)", "driver_set_timer"},
  {"driver_sizeq", "driver_sizeq(ErlDrvPort port)", "driver_sizeq"},
  {"driver_system_info", "driver_system_info(ErlDrvSysInfo *sys_info_ptr, size_t size)", "driver_system_info"},
  {"driver_vec_to_buf", "driver_vec_to_buf(ErlIOVec *ev, char *buf, ErlDrvSizeT len)", "driver_vec_to_buf"},
  {"erl_drv_busy_msgq_limits", "erl_drv_busy_msgq_limits(ErlDrvPort port, ErlDrvSizeT *low, ErlDrvSizeT *high)", "erl_drv_busy_msgq_limits"},
  {"erl_drv_cond_broadcast", "erl_drv_cond_broadcast(ErlDrvCond *cnd)", "erl_drv_cond_broadcast"},
  {"erl_drv_cond_create", "erl_drv_cond_create(char *name)", "erl_drv_cond_create"},
  {"erl_drv_cond_destroy", "erl_drv_cond_destroy(ErlDrvCond *cnd)", "erl_drv_cond_destroy"},
  {"erl_drv_cond_name", "erl_drv_cond_name(ErlDrvCond *cnd)", "erl_drv_cond_name"},
  {"erl_drv_cond_signal", "erl_drv_cond_signal(ErlDrvCond *cnd)", "erl_drv_cond_signal"},
  {"erl_drv_cond_wait", "erl_drv_cond_wait(ErlDrvCond *cnd, ErlDrvMutex *mtx)", "erl_drv_cond_wait"},
  {"erl_drv_consume_timeslice", "erl_drv_consume_timeslice(ErlDrvPort port, int percent)", "erl_drv_consume_timeslice"},
  {"erl_drv_convert_time_unit", "erl_drv_convert_time_unit(ErlDrvTime val, ErlDrvTimeUnit from, ErlDrvTimeUnit to)", "erl_drv_convert_time_unit"},
  {"erl_drv_equal_tids", "erl_drv_equal_tids(ErlDrvTid tid1, ErlDrvTid tid2)", "erl_drv_equal_tids"},
  {"erl_drv_getenv", "erl_drv_getenv(const char *key, char *value, size_t *value_size)", "erl_drv_getenv"},
  {"erl_drv_init_ack", "erl_drv_init_ack(ErlDrvPort port, ErlDrvData res)", "erl_drv_init_ack"},
  {"erl_drv_monotonic_time", "erl_drv_monotonic_time(ErlDrvTimeUnit time_unit)", "erl_drv_monotonic_time"},
  {"erl_drv_mutex_create", "erl_drv_mutex_create(char *name)", "erl_drv_mutex_create"},
  {"erl_drv_mutex_destroy", "erl_drv_mutex_destroy(ErlDrvMutex *mtx)", "erl_drv_mutex_destroy"},
  {"erl_drv_mutex_lock", "erl_drv_mutex_lock(ErlDrvMutex *mtx)", "erl_drv_mutex_lock"},
  {"erl_drv_mutex_name", "erl_drv_mutex_name(ErlDrvMutex *mtx)", "erl_drv_mutex_name"},
  {"erl_drv_mutex_trylock", "erl_drv_mutex_trylock(ErlDrvMutex *mtx)", "erl_drv_mutex_trylock"},
  {"erl_drv_mutex_unlock", "erl_drv_mutex_unlock(ErlDrvMutex *mtx)", "erl_drv_mutex_unlock"},
  {"erl_drv_output_term", "erl_drv_output_term(ErlDrvTermData port, ErlDrvTermData* term, int n)", "erl_drv_output_term"},
  {"erl_drv_putenv", "erl_drv_putenv(const char *key, char *value)", "erl_drv_putenv"},
  {"erl_drv_rwlock_create", "erl_drv_rwlock_create(char *name)", "erl_drv_rwlock_create"},
  {"erl_drv_rwlock_destroy", "erl_drv_rwlock_destroy(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_destroy"},
  {"erl_drv_rwlock_name", "erl_drv_rwlock_name(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_name"},
  {"erl_drv_rwlock_rlock", "erl_drv_rwlock_rlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_rlock"},
  {"erl_drv_rwlock_runlock", "erl_drv_rwlock_runlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_runlock"},
  {"erl_drv_rwlock_rwlock", "erl_drv_rwlock_rwlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_rwlock"},
  {"erl_drv_rwlock_rwunlock", "erl_drv_rwlock_rwunlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_rwunlock"},
  {"erl_drv_rwlock_tryrlock", "erl_drv_rwlock_tryrlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_tryrlock"},
  {"erl_drv_rwlock_tryrwlock", "erl_drv_rwlock_tryrwlock(ErlDrvRWLock *rwlck)", "erl_drv_rwlock_tryrwlock"},
  {"erl_drv_send_term", "erl_drv_send_term(ErlDrvTermData port, ErlDrvTermData receiver, ErlDrvTermData* term, int n)", "erl_drv_send_term"},
  {"erl_drv_set_os_pid", "erl_drv_set_os_pid(ErlDrvPort port, ErlDrvSInt pid)", "erl_drv_set_os_pid"},
  {"erl_drv_thread_create", "erl_drv_thread_create(char *name, ErlDrvTid *tid, void * (*func)(void *), void *arg, ErlDrvThreadOpts *opts)", "erl_drv_thread_create"},
  {"erl_drv_thread_exit", "erl_drv_thread_exit(void *exit_value)", "erl_drv_thread_exit"},
  {"erl_drv_thread_join", "erl_drv_thread_join(ErlDrvTid tid, void **exit_value)", "erl_drv_thread_join"},
  {"erl_drv_thread_name", "erl_drv_thread_name(ErlDrvTid tid)", "erl_drv_thread_name"},
  {"erl_drv_thread_opts_create", "erl_drv_thread_opts_create(char *name)", "erl_drv_thread_opts_create"},
  {"erl_drv_thread_opts_destroy", "erl_drv_thread_opts_destroy(ErlDrvThreadOpts *opts)", "erl_drv_thread_opts_destroy"},
  {"erl_drv_thread_self", "erl_drv_thread_self(void)", "erl_drv_thread_self"},
  {"erl_drv_time_offset", "erl_drv_time_offset(ErlDrvTimeUnit time_unit)", "erl_drv_time_offset"},
  {"erl_drv_tsd_get", "erl_drv_tsd_get(ErlDrvTSDKey key)", "erl_drv_tsd_get"},
  {"erl_drv_tsd_key_create", "erl_drv_tsd_key_create(char *name, ErlDrvTSDKey *key)", "erl_drv_tsd_key_create"},
  {"erl_drv_tsd_key_destroy", "erl_drv_tsd_key_destroy(ErlDrvTSDKey key)", "erl_drv_tsd_key_destroy"},
  {"erl_drv_tsd_set", "erl_drv_tsd_set(ErlDrvTSDKey key, void *data)", "erl_drv_tsd_set"},
  {"erl_errno_id", "erl_errno_id(int error)", "erl_errno_id"},
  {"remove_driver_entry", "remove_driver_entry(ErlDrvEntry *de)", "remove_driver_entry"},
  {"set_busy_port", "set_busy_port(ErlDrvPort port, int on)", "set_busy_port"},
  {"set_port_control_flags", "set_port_control_flags(ErlDrvPort port, int flags)", "set_port_control_flags"}
]}.
{"erl_driver.html", {clib, "erts"}, ["erl_driver"]}.
{"erl_nif.html", {function, {"erts", "erl_nif"}}, [
  {"enif_alloc", "enif_alloc(size_t size)", "enif_alloc"},
  {"enif_alloc_binary", "enif_alloc_binary(size_t size, ErlNifBinary* bin)", "enif_alloc_binary"},
  {"enif_alloc_env", "enif_alloc_env()", "enif_alloc_env"},
  {"enif_alloc_resource", "enif_alloc_resource(ErlNifResourceType* type, unsigned size)", "enif_alloc_resource"},
  {"enif_binary_to_term", "enif_binary_to_term(ErlNifEnv *env, const unsigned char* data, size_t size, ERL_NIF_TERM *term, ErlNifBinaryToTerm opts)", "enif_binary_to_term"},
  {"enif_clear_env", "enif_clear_env(ErlNifEnv* env)", "enif_clear_env"},
  {"enif_compare", "enif_compare(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)", "enif_compare"},
  {"enif_compare_monitors", "enif_compare_monitors(const ErlNifMonitor *monitor1, const ErlNifMonitor *monitor2)", "enif_compare_monitors"},
  {"enif_compare_pids", "enif_compare_pids(const ErlNifPid *pid1, const ErlNifPid *pid2)", "enif_compare_pids"},
  {"enif_cond_broadcast", "enif_cond_broadcast(ErlNifCond *cnd)", "enif_cond_broadcast"},
  {"enif_cond_create", "enif_cond_create(char *name)", "enif_cond_create"},
  {"enif_cond_destroy", "enif_cond_destroy(ErlNifCond *cnd)", "enif_cond_destroy"},
  {"enif_cond_name", "enif_cond_name(ErlNifCond* cnd)", "enif_cond_name"},
  {"enif_cond_signal", "enif_cond_signal(ErlNifCond *cnd)", "enif_cond_signal"},
  {"enif_cond_wait", "enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx)", "enif_cond_wait"},
  {"enif_consume_timeslice", "enif_consume_timeslice(ErlNifEnv *env, int percent)", "enif_consume_timeslice"},
  {"enif_convert_time_unit", "enif_convert_time_unit(ErlNifTime val, ErlNifTimeUnit from, ErlNifTimeUnit to)", "enif_convert_time_unit"},
  {"enif_cpu_time", "enif_cpu_time(ErlNifEnv *)", "enif_cpu_time"},
  {"enif_demonitor_process", "enif_demonitor_process(ErlNifEnv* caller_env, void* obj, const ErlNifMonitor* mon)", "enif_demonitor_process"},
  {"enif_dynamic_resource_call", "enif_dynamic_resource_call(ErlNifEnv* caller_env, ERL_NIF_TERM rt_module, ERL_NIF_TERM rt_name, ERL_NIF_TERM resource, void* call_data)", "enif_dynamic_resource_call"},
  {"enif_equal_tids", "enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2)", "enif_equal_tids"},
  {"enif_fprintf", "enif_fprintf(FILE *stream, const char *format, ...)", "enif_fprintf"},
  {"enif_free", "enif_free(void* ptr)", "enif_free"},
  {"enif_free_env", "enif_free_env(ErlNifEnv* env)", "enif_free_env"},
  {"enif_free_iovec", "enif_free_iovec(ErlNifIOVec* iov)", "enif_free_iovec"},
  {"enif_get_atom", "enif_get_atom(ErlNifEnv *env, ERL_NIF_TERM term, char *buf, unsigned size, ErlNifCharEncoding encoding)", "enif_get_atom"},
  {"enif_get_atom_length", "enif_get_atom_length(ErlNifEnv *env, ERL_NIF_TERM term, unsigned *len, ErlNifCharEncoding encoding)", "enif_get_atom_length"},
  {"enif_get_double", "enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)", "enif_get_double"},
  {"enif_get_int", "enif_get_int(ErlNifEnv* env, ERL_NIF_TERM term, int* ip)", "enif_get_int"},
  {"enif_get_int64", "enif_get_int64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifSInt64* ip)", "enif_get_int64"},
  {"enif_get_local_pid", "enif_get_local_pid(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPid* pid)", "enif_get_local_pid"},
  {"enif_get_local_port", "enif_get_local_port(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifPort* port_id)", "enif_get_local_port"},
  {"enif_get_list_cell", "enif_get_list_cell(ErlNifEnv* env, ERL_NIF_TERM list, ERL_NIF_TERM* head, ERL_NIF_TERM* tail)", "enif_get_list_cell"},
  {"enif_get_list_length", "enif_get_list_length(ErlNifEnv* env, ERL_NIF_TERM term, unsigned* len)", "enif_get_list_length"},
  {"enif_get_long", "enif_get_long(ErlNifEnv* env, ERL_NIF_TERM term, long int* ip)", "enif_get_long"},
  {"enif_get_map_size", "enif_get_map_size(ErlNifEnv* env, ERL_NIF_TERM term, size_t *size)", "enif_get_map_size"},
  {"enif_get_map_value", "enif_get_map_value(ErlNifEnv* env, ERL_NIF_TERM map, ERL_NIF_TERM key, ERL_NIF_TERM* value)", "enif_get_map_value"},
  {"enif_get_resource", "enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp)", "enif_get_resource"},
  {"enif_get_string", "enif_get_string(ErlNifEnv* env, ERL_NIF_TERM list, char* buf, unsigned size, ErlNifCharEncoding encoding)", "enif_get_string"},
  {"enif_get_string_length", "enif_get_string_length(ErlNifEnv *env, ERL_NIF_TERM list, unsigned *len, ErlNifCharEncoding encoding)", "enif_get_string_length"},
  {"enif_get_tuple", "enif_get_tuple(ErlNifEnv* env, ERL_NIF_TERM term, int* arity, const ERL_NIF_TERM** array)", "enif_get_tuple"},
  {"enif_get_uint", "enif_get_uint(ErlNifEnv* env, ERL_NIF_TERM term, unsigned int* ip)", "enif_get_uint"},
  {"enif_get_uint64", "enif_get_uint64(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifUInt64* ip)", "enif_get_uint64"},
  {"enif_get_ulong", "enif_get_ulong(ErlNifEnv* env, ERL_NIF_TERM term, unsigned long* ip)", "enif_get_ulong"},
  {"enif_getenv", "enif_getenv(const char* key, char* value, size_t *value_size)", "enif_getenv"},
  {"enif_has_pending_exception", "enif_has_pending_exception(ErlNifEnv* env, ERL_NIF_TERM* reason)", "enif_has_pending_exception"},
  {"enif_hash", "enif_hash(ErlNifHash type, ERL_NIF_TERM term, ErlNifUInt64 salt)", "enif_hash"},
  {"enif_inspect_binary", "enif_inspect_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, ErlNifBinary* bin)", "enif_inspect_binary"},
  {"enif_inspect_iolist_as_binary", "enif_inspect_iolist_as_binary(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifBinary* bin)", "enif_inspect_iolist_as_binary"},
  {"enif_inspect_iovec", "enif_inspect_iovec(ErlNifEnv* env, size_t max_elements, ERL_NIF_TERM iovec_term, ERL_NIF_TERM* tail, ErlNifIOVec** iovec)", "enif_inspect_iovec"},
  {"enif_ioq_create", "enif_ioq_create(ErlNifIOQueueOpts opts)", "enif_ioq_create"},
  {"enif_ioq_destroy", "enif_ioq_destroy(ErlNifIOQueue *q)", "enif_ioq_destroy"},
  {"enif_ioq_deq", "enif_ioq_deq(ErlNifIOQueue *q, size_t count, size_t *size)", "enif_ioq_deq"},
  {"enif_ioq_enq_binary", "enif_ioq_enq_binary(ErlNifIOQueue *q, ErlNifBinary *bin, size_t skip)", "enif_ioq_enq_binary"},
  {"enif_ioq_enqv", "enif_ioq_enqv(ErlNifIOQueue *q, ErlNifIOVec *iovec, size_t skip)", "enif_ioq_enqv"},
  {"enif_ioq_peek", "enif_ioq_peek(ErlNifIOQueue *q, int *iovlen)", "enif_ioq_peek"},
  {"enif_ioq_peek_head", "enif_ioq_peek_head(ErlNifEnv *env, ErlNifIOQueue *q, size_t *size, ERL_NIF_TERM *bin_term)", "enif_ioq_peek_head"},
  {"enif_ioq_size", "enif_ioq_size(ErlNifIOQueue *q)", "enif_ioq_size"},
  {"enif_is_atom", "enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_atom"},
  {"enif_is_binary", "enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_binary"},
  {"enif_is_current_process_alive", "enif_is_current_process_alive(ErlNifEnv* env)", "enif_is_current_process_alive"},
  {"enif_is_empty_list", "enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_empty_list"},
  {"enif_is_exception", "enif_is_exception(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_exception"},
  {"enif_is_fun", "enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_fun"},
  {"enif_is_identical", "enif_is_identical(ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)", "enif_is_identical"},
  {"enif_is_list", "enif_is_list(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_list"},
  {"enif_is_map", "enif_is_map(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_map"},
  {"enif_is_number", "enif_is_number(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_number"},
  {"enif_is_pid", "enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_pid"},
  {"enif_is_pid_undefined", "enif_is_pid_undefined(const ErlNifPid* pid)", "enif_is_pid_undefined"},
  {"enif_is_port", "enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_port"},
  {"enif_is_port_alive", "enif_is_port_alive(ErlNifEnv* env, ErlNifPort *port_id)", "enif_is_port_alive"},
  {"enif_is_process_alive", "enif_is_process_alive(ErlNifEnv* env, ErlNifPid *pid)", "enif_is_process_alive"},
  {"enif_is_ref", "enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_ref"},
  {"enif_is_tuple", "enif_is_tuple(ErlNifEnv* env, ERL_NIF_TERM term)", "enif_is_tuple"},
  {"enif_keep_resource", "enif_keep_resource(void* obj)", "enif_keep_resource"},
  {"enif_make_atom", "enif_make_atom(ErlNifEnv *env, const char *name)", "enif_make_atom"},
  {"enif_make_atom_len", "enif_make_atom_len(ErlNifEnv *env, const char *name, size_t len)", "enif_make_atom_len"},
  {"enif_make_badarg", "enif_make_badarg(ErlNifEnv* env)", "enif_make_badarg"},
  {"enif_make_binary", "enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)", "enif_make_binary"},
  {"enif_make_copy", "enif_make_copy(ErlNifEnv* dst_env, ERL_NIF_TERM src_term)", "enif_make_copy"},
  {"enif_make_double", "enif_make_double(ErlNifEnv* env, double d)", "enif_make_double"},
  {"enif_make_existing_atom", "enif_make_existing_atom(ErlNifEnv *env, const char *name, ERL_NIF_TERM *atom, ErlNifCharEncoding encoding)", "enif_make_existing_atom"},
  {"enif_make_existing_atom_len", "enif_make_existing_atom_len(ErlNifEnv *env, const char *name, size_t len, ERL_NIF_TERM *atom, ErlNifCharEncoding encoding)", "enif_make_existing_atom_len"},
  {"enif_make_int", "enif_make_int(ErlNifEnv* env, int i)", "enif_make_int"},
  {"enif_make_int64", "enif_make_int64(ErlNifEnv* env, ErlNifSInt64 i)", "enif_make_int64"},
  {"enif_make_list", "enif_make_list(ErlNifEnv* env, unsigned cnt, ...)", "enif_make_list"},
  {"enif_make_list1", "enif_make_list1(ErlNifEnv* env, ERL_NIF_TERM e1)", "enif_make_list1"},
  {"enif_make_list2", "enif_make_list2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2)", "enif_make_list2"},
  {"enif_make_list3", "enif_make_list3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3)", "enif_make_list3"},
  {"enif_make_list4", "enif_make_list4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4)", "enif_make_list4"},
  {"enif_make_list5", "enif_make_list5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5)", "enif_make_list5"},
  {"enif_make_list6", "enif_make_list6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6)", "enif_make_list6"},
  {"enif_make_list7", "enif_make_list7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7)", "enif_make_list7"},
  {"enif_make_list8", "enif_make_list8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8)", "enif_make_list8"},
  {"enif_make_list9", "enif_make_list9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)", "enif_make_list9"},
  {"enif_make_list_cell", "enif_make_list_cell(ErlNifEnv* env, ERL_NIF_TERM head, ERL_NIF_TERM tail)", "enif_make_list_cell"},
  {"enif_make_list_from_array", "enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)", "enif_make_list_from_array"},
  {"enif_make_long", "enif_make_long(ErlNifEnv* env, long int i)", "enif_make_long"},
  {"enif_make_map_put", "enif_make_map_put(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM value, ERL_NIF_TERM* map_out)", "enif_make_map_put"},
  {"enif_make_map_remove", "enif_make_map_remove(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM* map_out)", "enif_make_map_remove"},
  {"enif_make_map_update", "enif_make_map_update(ErlNifEnv* env, ERL_NIF_TERM map_in, ERL_NIF_TERM key, ERL_NIF_TERM new_value, ERL_NIF_TERM* map_out)", "enif_make_map_update"},
  {"enif_make_map_from_arrays", "enif_make_map_from_arrays(ErlNifEnv* env, ERL_NIF_TERM keys[], ERL_NIF_TERM values[], size_t cnt, ERL_NIF_TERM *map_out)", "enif_make_map_from_arrays"},
  {"enif_make_monitor_term", "enif_make_monitor_term(ErlNifEnv* env, const ErlNifMonitor* mon)", "enif_make_monitor_term"},
  {"enif_make_new_atom", "enif_make_new_atom(ErlNifEnv *env, const char *name, ERL_NIF_TERM *atom, ErlNifCharEncoding encoding)", "enif_make_new_atom"},
  {"enif_make_new_atom_len", "enif_make_new_atom_len(ErlNifEnv *env, const char *name, size_t len, ERL_NIF_TERM *atom, ErlNifCharEncoding encoding)", "enif_make_new_atom_len"},
  {"enif_make_new_binary", "enif_make_new_binary(ErlNifEnv* env, size_t size, ERL_NIF_TERM* termp)", "enif_make_new_binary"},
  {"enif_make_new_map", "enif_make_new_map(ErlNifEnv* env)", "enif_make_new_map"},
  {"enif_make_pid", "enif_make_pid(ErlNifEnv* env, const ErlNifPid* pid)", "enif_make_pid"},
  {"enif_make_ref", "enif_make_ref(ErlNifEnv* env)", "enif_make_ref"},
  {"enif_make_resource", "enif_make_resource(ErlNifEnv* env, void* obj)", "enif_make_resource"},
  {"enif_make_resource_binary", "enif_make_resource_binary(ErlNifEnv* env, void* obj, const void* data, size_t size)", "enif_make_resource_binary"},
  {"enif_make_reverse_list", "enif_make_reverse_list(ErlNifEnv* env, ERL_NIF_TERM list_in, ERL_NIF_TERM *list_out)", "enif_make_reverse_list"},
  {"enif_make_string", "enif_make_string(ErlNifEnv *env, const char *string, ErlNifCharEncoding encoding)", "enif_make_string"},
  {"enif_make_string_len", "enif_make_string_len(ErlNifEnv *env, const char *string, size_t len, ErlNifCharEncoding encoding)", "enif_make_string_len"},
  {"enif_make_sub_binary", "enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, size_t pos, size_t size)", "enif_make_sub_binary"},
  {"enif_make_tuple", "enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)", "enif_make_tuple"},
  {"enif_make_tuple1", "enif_make_tuple1(ErlNifEnv* env, ERL_NIF_TERM e1)", "enif_make_tuple1"},
  {"enif_make_tuple2", "enif_make_tuple2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2)", "enif_make_tuple2"},
  {"enif_make_tuple3", "enif_make_tuple3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3)", "enif_make_tuple3"},
  {"enif_make_tuple4", "enif_make_tuple4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4)", "enif_make_tuple4"},
  {"enif_make_tuple5", "enif_make_tuple5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5)", "enif_make_tuple5"},
  {"enif_make_tuple6", "enif_make_tuple6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6)", "enif_make_tuple6"},
  {"enif_make_tuple7", "enif_make_tuple7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7)", "enif_make_tuple7"},
  {"enif_make_tuple8", "enif_make_tuple8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8)", "enif_make_tuple8"},
  {"enif_make_tuple9", "enif_make_tuple9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)", "enif_make_tuple9"},
  {"enif_make_tuple_from_array", "enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)", "enif_make_tuple_from_array"},
  {"enif_make_uint", "enif_make_uint(ErlNifEnv* env, unsigned int i)", "enif_make_uint"},
  {"enif_make_uint64", "enif_make_uint64(ErlNifEnv* env, ErlNifUInt64 i)", "enif_make_uint64"},
  {"enif_make_ulong", "enif_make_ulong(ErlNifEnv* env, unsigned long i)", "enif_make_ulong"},
  {"enif_make_unique_integer", "enif_make_unique_integer(ErlNifEnv *env, ErlNifUniqueInteger properties)", "enif_make_unique_integer"},
  {"enif_map_iterator_create", "enif_map_iterator_create(ErlNifEnv *env, ERL_NIF_TERM map, ErlNifMapIterator *iter, ErlNifMapIteratorEntry entry)", "enif_map_iterator_create"},
  {"enif_map_iterator_destroy", "enif_map_iterator_destroy(ErlNifEnv *env, ErlNifMapIterator *iter)", "enif_map_iterator_destroy"},
  {"enif_map_iterator_get_pair", "enif_map_iterator_get_pair(ErlNifEnv *env, ErlNifMapIterator *iter, ERL_NIF_TERM *key, ERL_NIF_TERM *value)", "enif_map_iterator_get_pair"},
  {"enif_map_iterator_is_head", "enif_map_iterator_is_head(ErlNifEnv *env, ErlNifMapIterator *iter)", "enif_map_iterator_is_head"},
  {"enif_map_iterator_is_tail", "enif_map_iterator_is_tail(ErlNifEnv *env, ErlNifMapIterator *iter)", "enif_map_iterator_is_tail"},
  {"enif_map_iterator_next", "enif_map_iterator_next(ErlNifEnv *env, ErlNifMapIterator *iter)", "enif_map_iterator_next"},
  {"enif_map_iterator_prev", "enif_map_iterator_prev(ErlNifEnv *env, ErlNifMapIterator *iter)", "enif_map_iterator_prev"},
  {"enif_monitor_process", "enif_monitor_process(ErlNifEnv* caller_env, void* obj, const ErlNifPid* target_pid, ErlNifMonitor* mon)", "enif_monitor_process"},
  {"enif_monotonic_time", "enif_monotonic_time(ErlNifTimeUnit time_unit)", "enif_monotonic_time"},
  {"enif_mutex_create", "enif_mutex_create(char *name)", "enif_mutex_create"},
  {"enif_mutex_destroy", "enif_mutex_destroy(ErlNifMutex *mtx)", "enif_mutex_destroy"},
  {"enif_mutex_lock", "enif_mutex_lock(ErlNifMutex *mtx)", "enif_mutex_lock"},
  {"enif_mutex_name", "enif_mutex_name(ErlNifMutex* mtx)", "enif_mutex_name"},
  {"enif_mutex_trylock", "enif_mutex_trylock(ErlNifMutex *mtx)", "enif_mutex_trylock"},
  {"enif_mutex_unlock", "enif_mutex_unlock(ErlNifMutex *mtx)", "enif_mutex_unlock"},
  {"enif_now_time", "enif_now_time(ErlNifEnv *env)", "enif_now_time"},
  {"enif_open_resource_type", "enif_open_resource_type(ErlNifEnv* env, const char* module_str, const char* name, ErlNifResourceDtor* dtor, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)", "enif_open_resource_type"},
  {"enif_open_resource_type_x", "enif_open_resource_type_x(ErlNifEnv* env, const char* name, const ErlNifResourceTypeInit* init, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)", "enif_open_resource_type_x"},
  {"enif_init_resource_type", "enif_init_resource_type(ErlNifEnv* env, const char* name, const ErlNifResourceTypeInit* init, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)", "enif_init_resource_type"},
  {"enif_port_command", "enif_port_command(ErlNifEnv* env, const ErlNifPort* to_port, ErlNifEnv *msg_env, ERL_NIF_TERM msg)", "enif_port_command"},
  {"enif_priv_data", "enif_priv_data(ErlNifEnv* env)", "enif_priv_data"},
  {"enif_raise_exception", "enif_raise_exception(ErlNifEnv* env, ERL_NIF_TERM reason)", "enif_raise_exception"},
  {"enif_realloc", "enif_realloc(void* ptr, size_t size)", "enif_realloc"},
  {"enif_realloc_binary", "enif_realloc_binary(ErlNifBinary* bin, size_t size)", "enif_realloc_binary"},
  {"enif_release_binary", "enif_release_binary(ErlNifBinary* bin)", "enif_release_binary"},
  {"enif_release_resource", "enif_release_resource(void* obj)", "enif_release_resource"},
  {"enif_rwlock_create", "enif_rwlock_create(char *name)", "enif_rwlock_create"},
  {"enif_rwlock_destroy", "enif_rwlock_destroy(ErlNifRWLock *rwlck)", "enif_rwlock_destroy"},
  {"enif_rwlock_name", "enif_rwlock_name(ErlNifRWLock* rwlck)", "enif_rwlock_name"},
  {"enif_rwlock_rlock", "enif_rwlock_rlock(ErlNifRWLock *rwlck)", "enif_rwlock_rlock"},
  {"enif_rwlock_runlock", "enif_rwlock_runlock(ErlNifRWLock *rwlck)", "enif_rwlock_runlock"},
  {"enif_rwlock_rwlock", "enif_rwlock_rwlock(ErlNifRWLock *rwlck)", "enif_rwlock_rwlock"},
  {"enif_rwlock_rwunlock", "enif_rwlock_rwunlock(ErlNifRWLock *rwlck)", "enif_rwlock_rwunlock"},
  {"enif_rwlock_tryrlock", "enif_rwlock_tryrlock(ErlNifRWLock *rwlck)", "enif_rwlock_tryrlock"},
  {"enif_rwlock_tryrwlock", "enif_rwlock_tryrwlock(ErlNifRWLock *rwlck)", "enif_rwlock_tryrwlock"},
  {"enif_schedule_nif", "enif_schedule_nif( ErlNifEnv* caller_env, const char* fun_name, int flags, ERL_NIF_TERM (*fp)(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]), int argc, const ERL_NIF_TERM argv[])", "enif_schedule_nif"},
  {"enif_select", "enif_select(ErlNifEnv* env, ErlNifEvent event, enum ErlNifSelectFlags mode, void* obj, const ErlNifPid* pid, ERL_NIF_TERM ref)", "enif_select"},
  {"enif_select_read", "enif_select_read(ErlNifEnv* env, ErlNifEvent event, void* obj, const ErlNifPid* pid, ERL_NIF_TERM msg, ErlNifEnv* msg_env)", "enif_select_read"},
  {"enif_select_write", "enif_select_write(ErlNifEnv* env, ErlNifEvent event, void* obj, const ErlNifPid* pid, ERL_NIF_TERM msg, ErlNifEnv* msg_env)", "enif_select_write"},
  {"enif_self", "enif_self(ErlNifEnv* caller_env, ErlNifPid* pid)", "enif_self"},
  {"enif_send", "enif_send(ErlNifEnv* caller_env, ErlNifPid* to_pid, ErlNifEnv* msg_env, ERL_NIF_TERM msg)", "enif_send"},
  {"enif_set_option", "enif_set_option(ErlNifEnv *env, ErlNifOption opt, ...)", "enif_set_option"},
  {"enif_set_pid_undefined", "enif_set_pid_undefined(ErlNifPid* pid)", "enif_set_pid_undefined"},
  {"enif_sizeof_resource", "enif_sizeof_resource(void* obj)", "enif_sizeof_resource"},
  {"enif_snprintf", "enif_snprintf(char *str, size_t size, const char *format, ...)", "enif_snprintf"},
  {"enif_system_info", "enif_system_info(ErlNifSysInfo *sys_info_ptr, size_t size)", "enif_system_info"},
  {"enif_term_to_binary", "enif_term_to_binary(ErlNifEnv *env, ERL_NIF_TERM term, ErlNifBinary *bin)", "enif_term_to_binary"},
  {"enif_term_type", "enif_term_type(ErlNifEnv *env, ERL_NIF_TERM term)", "enif_term_type"},
  {"enif_thread_create", "enif_thread_create(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts)", "enif_thread_create"},
  {"enif_thread_exit", "enif_thread_exit(void *resp)", "enif_thread_exit"},
  {"enif_thread_join", "enif_thread_join(ErlNifTid, void **respp)", "enif_thread_join"},
  {"enif_thread_name", "enif_thread_name(ErlNifTid tid)", "enif_thread_name"},
  {"enif_thread_opts_create", "enif_thread_opts_create(char *name)", "enif_thread_opts_create"},
  {"enif_thread_opts_destroy", "enif_thread_opts_destroy(ErlNifThreadOpts *opts)", "enif_thread_opts_destroy"},
  {"enif_thread_self", "enif_thread_self(void)", "enif_thread_self"},
  {"enif_thread_type", "enif_thread_type(void)", "enif_thread_type"},
  {"enif_time_offset", "enif_time_offset(ErlNifTimeUnit time_unit)", "enif_time_offset"},
  {"enif_tsd_get", "enif_tsd_get(ErlNifTSDKey key)", "enif_tsd_get"},
  {"enif_tsd_key_create", "enif_tsd_key_create(char *name, ErlNifTSDKey *key)", "enif_tsd_key_create"},
  {"enif_tsd_key_destroy", "enif_tsd_key_destroy(ErlNifTSDKey key)", "enif_tsd_key_destroy"},
  {"enif_tsd_set", "enif_tsd_set(ErlNifTSDKey key, void *data)", "enif_tsd_set"},
  {"enif_vfprintf", "enif_vfprintf(FILE *stream, const char *format, va_list ap)", "enif_vfprintf"},
  {"enif_vsnprintf", "enif_vsnprintf(char *str, size_t size, const char *format, va_list ap)", "enif_vsnprintf"},
  {"enif_whereis_pid", "enif_whereis_pid(ErlNifEnv *caller_env, ERL_NIF_TERM name, ErlNifPid *pid)", "enif_whereis_pid"},
  {"enif_whereis_port", "enif_whereis_port(ErlNifEnv *caller_env, ERL_NIF_TERM name, ErlNifPort *port)", "enif_whereis_port"}
]}.
{"erl_nif.html", {clib, "erts"}, ["erl_nif"]}.
{"erl_prim_loader.html", {function, {"erts", "erl_prim_loader"}},
[
  {"get_file", "get_file(Filename)", "get_file-1"},
  {"get_path", "get_path()", "get_path-0"},
  {"list_dir", "list_dir(Dir)", "list_dir-1"},
  {"read_file_info", "read_file_info(Filename)", "read_file_info-1"},
  {"read_link_info", "read_link_info(Filename)", "read_link_info-1"},
  {"set_path", "set_path(Path)", "set_path-1"}
]}.
{"erl_prim_loader.html", {module, "erts"}, ["erl_prim_loader"]}.
{"erlsrv.html", {command, "erts"}, ["erlsrv"]}.
{"erl_tracer.html", {function, {"erts", "erl_tracer"}},
[
  {"Module:enabled", "Module:enabled(TraceTag, TracerState, Tracee)", "Module:enabled-3"},
  {"Module:enabled_call", "Module:enabled_call(TraceTag, TracerState, Tracee)", "Module:enabled_call-3"},
  {"Module:enabled_garbage_collection", "Module:enabled_garbage_collection(TraceTag, TracerState, Tracee)", "Module:enabled_garbage_collection-3"},
  {"Module:enabled_ports", "Module:enabled_ports(TraceTag, TracerState, Tracee)", "Module:enabled_ports-3"},
  {"Module:enabled_procs", "Module:enabled_procs(TraceTag, TracerState, Tracee)", "Module:enabled_procs-3"},
  {"Module:enabled_receive", "Module:enabled_receive(TraceTag, TracerState, Tracee)", "Module:enabled_receive-3"},
  {"Module:enabled_running_ports", "Module:enabled_running_ports(TraceTag, TracerState, Tracee)", "Module:enabled_running_ports-3"},
  {"Module:enabled_running_procs", "Module:enabled_running_procs(TraceTag, TracerState, Tracee)", "Module:enabled_running_procs-3"},
  {"Module:enabled_send", "Module:enabled_send(TraceTag, TracerState, Tracee)", "Module:enabled_send-3"},
  {"Module:trace", "Module:trace(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace-5"},
  {"Module:trace", "Module:trace(seq_trace, TracerState, Label, SeqTraceInfo, Opts)", "Module:trace-5"},
  {"Module:trace_call", "Module:trace_call(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_call-5"},
  {"Module:trace_garbage_collection", "Module:trace_garbage_collection(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_garbage_collection-5"},
  {"Module:trace_ports", "Module:trace_ports(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_ports-5"},
  {"Module:trace_procs", "Module:trace_procs(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_procs-5"},
  {"Module:trace_receive", "Module:trace_receive(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_receive-5"},
  {"Module:trace_running_ports", "Module:trace_running_ports(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_running_ports-5"},
  {"Module:trace_running_procs", "Module:trace_running_procs(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_running_procs-5"},
  {"Module:trace_send", "Module:trace_send(TraceTag, TracerState, Tracee, TraceTerm, Opts)", "Module:trace_send-5"}
]}.
{"erl_tracer.html", {module, "erts"}, ["erl_tracer"]}.
{"erts_alloc.html", {function, {"erts", "erts_alloc"}}, [
]}.
{"erts_alloc.html", {clib, "erts"}, ["erts_alloc"]}.
{"escript.html", {command, "erts"}, ["escript"]}.
{"init.html", {function, {"erts", "init"}},
[
  {"boot", "boot(BootArgs)", "boot-1"},
  {"get_argument", "get_argument(Flag)", "get_argument-1"},
  {"get_arguments", "get_arguments()", "get_arguments-0"},
  {"get_plain_arguments", "get_plain_arguments()", "get_plain_arguments-0"},
  {"get_status", "get_status()", "get_status-0"},
  {"reboot", "reboot()", "reboot-0"},
  {"restart", "restart()", "restart-0"},
  {"restart", "restart(Opts :: [{mode, mode()}])", "restart-1"},
  {"script_id", "script_id()", "script_id-0"},
  {"stop", "stop()", "stop-0"},
  {"stop", "stop(Status)", "stop-1"}
]}.
{"init.html", {module, "erts"}, ["init"]}.
{"persistent_term.html", {function, {"erts", "persistent_term"}},
[
  {"erase", "erase(Key)", "erase-1"},
  {"get", "get()", "get-0"},
  {"get", "get(Key)", "get-1"},
  {"get", "get(Key, Default)", "get-2"},
  {"info", "info()", "info-0"},
  {"put", "put(Key, Value)", "put-2"}
]}.
{"persistent_term.html", {module, "erts"}, ["persistent_term"]}.
{"run_erl.html", {command, "erts"}, ["run_erl"]}.
{"start.html", {command, "erts"}, ["start"]}.
{"start_erl.html", {command, "erts"}, ["start_erl"]}.
{"werl.html", {command, "erts"}, ["werl"]}.
{"zlib.html", {function, {"erts", "zlib"}},
[
  {"adler32", "adler32(Z, Data)", "adler32-2"},
  {"adler32", "adler32(Z, PrevAdler, Data)", "adler32-3"},
  {"adler32_combine", "adler32_combine(Z, Adler1, Adler2, Size2)", "adler32_combine-4"},
  {"close", "close(Z)", "close-1"},
  {"compress", "compress(Data)", "compress-1"},
  {"crc32", "crc32(Z)", "crc32-1"},
  {"crc32", "crc32(Z, Data)", "crc32-2"},
  {"crc32", "crc32(Z, PrevCRC, Data)", "crc32-3"},
  {"crc32_combine", "crc32_combine(Z, CRC1, CRC2, Size2)", "crc32_combine-4"},
  {"deflate", "deflate(Z, Data)", "deflate-2"},
  {"deflate", "deflate(Z, Data, Flush)", "deflate-3"},
  {"deflateEnd", "deflateEnd(Z)", "deflateEnd-1"},
  {"deflateInit", "deflateInit(Z)", "deflateInit-1"},
  {"deflateInit", "deflateInit(Z, Level)", "deflateInit-2"},
  {"deflateInit", "deflateInit(Z, Level, Method, WindowBits, MemLevel, Strategy)", "deflateInit-6"},
  {"deflateParams", "deflateParams(Z, Level, Strategy)", "deflateParams-3"},
  {"deflateReset", "deflateReset(Z)", "deflateReset-1"},
  {"deflateSetDictionary", "deflateSetDictionary(Z, Dictionary)", "deflateSetDictionary-2"},
  {"getBufSize", "getBufSize(Z)", "getBufSize-1"},
  {"gunzip", "gunzip(Data)", "gunzip-1"},
  {"gzip", "gzip(Data)", "gzip-1"},
  {"inflate", "inflate(Z, Data)", "inflate-2"},
  {"inflate", "inflate(Z, Data, Options)", "inflate-3"},
  {"inflateChunk", "inflateChunk(Z)", "inflateChunk-1"},
  {"inflateChunk", "inflateChunk(Z, Data)", "inflateChunk-2"},
  {"inflateEnd", "inflateEnd(Z)", "inflateEnd-1"},
  {"inflateGetDictionary", "inflateGetDictionary(Z)", "inflateGetDictionary-1"},
  {"inflateInit", "inflateInit(Z)", "inflateInit-1"},
  {"inflateInit", "inflateInit(Z, WindowBits)", "inflateInit-2"},
  {"inflateReset", "inflateReset(Z)", "inflateReset-1"},
  {"inflateSetDictionary", "inflateSetDictionary(Z, Dictionary)", "inflateSetDictionary-2"},
  {"open", "open()", "open-0"},
  {"safeInflate", "safeInflate(Z, Data)", "safeInflate-2"},
  {"setBufSize", "setBufSize(Z, Size)", "setBufSize-2"},
  {"set_controlling_process", "set_controlling_process(Z, Pid)", "set_controlling_process-2"},
  {"uncompress", "uncompress(Data)", "uncompress-1"},
  {"unzip", "unzip(Data)", "unzip-1"},
  {"zip", "zip(Data)", "zip-1"}
]}.
{"zlib.html", {module, "erts"}, ["zlib"]}.
{notused, application, ["erts"]}.
