%% 
%% Search data file for stdlib 3.11
%% generated December  9, 2019
%% 
{"STDLIB_app.html", {app, "stdlib"}, ["STDLIB"]}.
{"array.html", {function, {"stdlib", "array"}},
[
  {"default", "default(Array :: array(Type))", "default-1"},
  {"fix", "fix(Array :: array(Type))", "fix-1"},
  {"foldl", "foldl(Function, InitialAcc :: A, Array :: array(Type))", "foldl-3"},
  {"foldr", "foldr(Function, InitialAcc :: A, Array :: array(Type))", "foldr-3"},
  {"from_list", "from_list(List :: [Value :: Type])", "from_list-1"},
  {"from_list", "from_list(List :: [Value :: Type], Default :: term())", "from_list-2"},
  {"from_orddict", "from_orddict(Orddict :: indx_pairs(Value :: Type))", "from_orddict-1"},
  {"from_orddict", "from_orddict(Orddict :: indx_pairs(Value :: Type),Default :: Type)", "from_orddict-2"},
  {"get", "get(I :: array_indx(), Array :: array(Type))", "get-2"},
  {"is_array", "is_array(X :: term())", "is_array-1"},
  {"is_fix", "is_fix(Array :: array())", "is_fix-1"},
  {"map", "map(Function, Array :: array(Type1))", "map-2"},
  {"new", "new()", "new-0"},
  {"new", "new(Options :: array_opts())", "new-1"},
  {"new", "new(Size :: integer() >= 0, Options :: array_opts())", "new-2"},
  {"relax", "relax(Array :: array(Type))", "relax-1"},
  {"reset", "reset(I :: array_indx(), Array :: array(Type))", "reset-2"},
  {"resize", "resize(Array :: array(Type))", "resize-1"},
  {"resize", "resize(Size :: integer() >= 0, Array :: array(Type))", "resize-2"},
  {"set", "set(I :: array_indx(), Value :: Type, Array :: array(Type))", "set-3"},
  {"size", "size(Array :: array())", "size-1"},
  {"sparse_foldl", "sparse_foldl(Function, InitialAcc :: A, Array :: array(Type))", "sparse_foldl-3"},
  {"sparse_foldr", "sparse_foldr(Function, InitialAcc :: A, Array :: array(Type))", "sparse_foldr-3"},
  {"sparse_map", "sparse_map(Function, Array :: array(Type1))", "sparse_map-2"},
  {"sparse_size", "sparse_size(Array :: array())", "sparse_size-1"},
  {"sparse_to_list", "sparse_to_list(Array :: array(Type))", "sparse_to_list-1"},
  {"sparse_to_orddict", "sparse_to_orddict(Array :: array(Type))", "sparse_to_orddict-1"},
  {"to_list", "to_list(Array :: array(Type))", "to_list-1"},
  {"to_orddict", "to_orddict(Array :: array(Type))", "to_orddict-1"}
]}.
{"array.html", {module, "stdlib"}, ["array"]}.
{"assert.hrl.html", {file, "stdlib"}, ["assert.hrl"]}.
{"base64.html", {function, {"stdlib", "base64"}},
[
  {"decode", "decode(Base64)", "decode-1"},
  {"decode_to_string", "decode_to_string(Base64)", "decode_to_string-1"},
  {"mime_decode", "mime_decode(Base64)", "mime_decode-1"},
  {"mime_decode_to_string", "mime_decode_to_string(Base64)", "mime_decode_to_string-1"},
  {"encode", "encode(Data)", "encode-1"},
  {"encode_to_string", "encode_to_string(Data)", "encode_to_string-1"}
]}.
{"base64.html", {module, "stdlib"}, ["base64"]}.
{"beam_lib.html", {function, {"stdlib", "beam_lib"}},
[
  {"all_chunks", "all_chunks(File :: beam())", "all_chunks-1"},
  {"build_module", "build_module(Chunks)", "build_module-1"},
  {"chunks", "chunks(Beam, ChunkRefs)", "chunks-2"},
  {"chunks", "chunks(Beam, ChunkRefs, Options)", "chunks-3"},
  {"clear_crypto_key_fun", "clear_crypto_key_fun()", "clear_crypto_key_fun-0"},
  {"cmp", "cmp(Beam1, Beam2)", "cmp-2"},
  {"cmp_dirs", "cmp_dirs(Dir1, Dir2)", "cmp_dirs-2"},
  {"crypto_key_fun", "crypto_key_fun(CryptoKeyFun)", "crypto_key_fun-1"},
  {"diff_dirs", "diff_dirs(Dir1, Dir2)", "diff_dirs-2"},
  {"format_error", "format_error(Reason)", "format_error-1"},
  {"info", "info(Beam)", "info-1"},
  {"md5", "md5(Beam)", "md5-1"},
  {"strip", "strip(Beam1)", "strip-1"},
  {"strip", "strip(Beam1, AdditionalChunks)", "strip-2"},
  {"strip_files", "strip_files(Files)", "strip_files-1"},
  {"strip_files", "strip_files(Files, AdditionalChunks)", "strip_files-2"},
  {"strip_release", "strip_release(Dir)", "strip_release-1"},
  {"strip_release", "strip_release(Dir, AdditionalChunks)", "strip_release-2"},
  {"version", "version(Beam)", "version-1"}
]}.
{"beam_lib.html", {module, "stdlib"}, ["beam_lib"]}.
{"binary.html", {function, {"stdlib", "binary"}},
[
  {"at", "at(Subject, Pos)", "at-2"},
  {"bin_to_list", "bin_to_list(Subject)", "bin_to_list-1"},
  {"bin_to_list", "bin_to_list(Subject, PosLen)", "bin_to_list-2"},
  {"bin_to_list", "bin_to_list(Subject, Pos, Len)", "bin_to_list-3"},
  {"compile_pattern", "compile_pattern(Pattern)", "compile_pattern-1"},
  {"copy", "copy(Subject)", "copy-1"},
  {"copy", "copy(Subject, N)", "copy-2"},
  {"decode_unsigned", "decode_unsigned(Subject)", "decode_unsigned-1"},
  {"decode_unsigned", "decode_unsigned(Subject, Endianness)", "decode_unsigned-2"},
  {"encode_unsigned", "encode_unsigned(Unsigned)", "encode_unsigned-1"},
  {"encode_unsigned", "encode_unsigned(Unsigned, Endianness)", "encode_unsigned-2"},
  {"first", "first(Subject)", "first-1"},
  {"last", "last(Subject)", "last-1"},
  {"list_to_bin", "list_to_bin(ByteList)", "list_to_bin-1"},
  {"longest_common_prefix", "longest_common_prefix(Binaries)", "longest_common_prefix-1"},
  {"longest_common_suffix", "longest_common_suffix(Binaries)", "longest_common_suffix-1"},
  {"match", "match(Subject, Pattern)", "match-2"},
  {"match", "match(Subject, Pattern, Options)", "match-3"},
  {"matches", "matches(Subject, Pattern)", "matches-2"},
  {"matches", "matches(Subject, Pattern, Options)", "matches-3"},
  {"part", "part(Subject, PosLen)", "part-2"},
  {"part", "part(Subject, Pos, Len)", "part-3"},
  {"referenced_byte_size", "referenced_byte_size(Binary)", "referenced_byte_size-1"},
  {"replace", "replace(Subject, Pattern, Replacement)", "replace-3"},
  {"replace", "replace(Subject, Pattern, Replacement, Options)", "replace-4"},
  {"split", "split(Subject, Pattern)", "split-2"},
  {"split", "split(Subject, Pattern, Options)", "split-3"}
]}.
{"binary.html", {module, "stdlib"}, ["binary"]}.
{"c.html", {function, {"stdlib", "c"}},
[
  {"bt", "bt(Pid)", "bt-1"},
  {"c", "c(Module)", "c-1"},
  {"c", "c(Module, Options)", "c-2"},
  {"c", "c(Module, Options, Filter)", "c-3"},
  {"cd", "cd(Dir)", "cd-1"},
  {"erlangrc", "erlangrc(PathList)", "erlangrc-1"},
  {"flush", "flush()", "flush-0"},
  {"help", "help()", "help-0"},
  {"i", "i()", "i-0"},
  {"ni", "ni()", "ni-0"},
  {"i", "i(X, Y, Z)", "i-3"},
  {"l", "l(Module)", "l-1"},
  {"lc", "lc(Files)", "lc-1"},
  {"lm", "lm()", "lm-0"},
  {"ls", "ls()", "ls-0"},
  {"ls", "ls(Dir)", "ls-1"},
  {"m", "m()", "m-0"},
  {"m", "m(Module)", "m-1"},
  {"mm", "mm()", "mm-0"},
  {"memory", "memory()", "memory-0"},
  {"memory", "memory(Type)", "memory-1"},
  {"memory", "memory(Types)", "memory-1"},
  {"nc", "nc(File)", "nc-1"},
  {"nc", "nc(File, Options)", "nc-2"},
  {"nl", "nl(Module)", "nl-1"},
  {"pid", "pid(X, Y, Z)", "pid-3"},
  {"pwd", "pwd()", "pwd-0"},
  {"q", "q()", "q-0"},
  {"regs", "regs()", "regs-0"},
  {"nregs", "nregs()", "nregs-0"},
  {"uptime", "uptime()", "uptime-0"},
  {"xm", "xm(ModSpec)", "xm-1"},
  {"y", "y(File)", "y-1"},
  {"y", "y(File, Options)", "y-2"}
]}.
{"c.html", {module, "stdlib"}, ["c"]}.
{"calendar.html", {function, {"stdlib", "calendar"}},
[
  {"date_to_gregorian_days", "date_to_gregorian_days(Date)", "date_to_gregorian_days-1"},
  {"date_to_gregorian_days", "date_to_gregorian_days(Year, Month, Day)", "date_to_gregorian_days-3"},
  {"datetime_to_gregorian_seconds", "datetime_to_gregorian_seconds(DateTime)", "datetime_to_gregorian_seconds-1"},
  {"day_of_the_week", "day_of_the_week(Date)", "day_of_the_week-1"},
  {"day_of_the_week", "day_of_the_week(Year, Month, Day)", "day_of_the_week-3"},
  {"gregorian_days_to_date", "gregorian_days_to_date(Days)", "gregorian_days_to_date-1"},
  {"gregorian_seconds_to_datetime", "gregorian_seconds_to_datetime(Seconds)", "gregorian_seconds_to_datetime-1"},
  {"is_leap_year", "is_leap_year(Year)", "is_leap_year-1"},
  {"iso_week_number", "iso_week_number()", "iso_week_number-0"},
  {"iso_week_number", "iso_week_number(Date)", "iso_week_number-1"},
  {"last_day_of_the_month", "last_day_of_the_month(Year, Month)", "last_day_of_the_month-2"},
  {"local_time", "local_time()", "local_time-0"},
  {"local_time_to_universal_time", "local_time_to_universal_time(DateTime1)", "local_time_to_universal_time-1"},
  {"local_time_to_universal_time_dst", "local_time_to_universal_time_dst(DateTime1)", "local_time_to_universal_time_dst-1"},
  {"now_to_datetime", "now_to_datetime(Now)", "now_to_datetime-1"},
  {"now_to_local_time", "now_to_local_time(Now)", "now_to_local_time-1"},
  {"now_to_universal_time", "now_to_universal_time(Now)", "now_to_universal_time-1"},
  {"rfc3339_to_system_time", "rfc3339_to_system_time(DateTimeString)", "rfc3339_to_system_time-1"},
  {"rfc3339_to_system_time", "rfc3339_to_system_time(DateTimeString, Options)", "rfc3339_to_system_time-2"},
  {"seconds_to_daystime", "seconds_to_daystime(Seconds)", "seconds_to_daystime-1"},
  {"seconds_to_time", "seconds_to_time(Seconds)", "seconds_to_time-1"},
  {"system_time_to_local_time", "system_time_to_local_time(Time, TimeUnit)", "system_time_to_local_time-2"},
  {"system_time_to_rfc3339", "system_time_to_rfc3339(Time)", "system_time_to_rfc3339-1"},
  {"system_time_to_rfc3339", "system_time_to_rfc3339(Time, Options)", "system_time_to_rfc3339-2"},
  {"system_time_to_universal_time", "system_time_to_universal_time(Time, TimeUnit)", "system_time_to_universal_time-2"},
  {"time_difference", "time_difference(T1, T2)", "time_difference-2"},
  {"time_to_seconds", "time_to_seconds(Time)", "time_to_seconds-1"},
  {"universal_time", "universal_time()", "universal_time-0"},
  {"universal_time_to_local_time", "universal_time_to_local_time(DateTime)", "universal_time_to_local_time-1"},
  {"valid_date", "valid_date(Date)", "valid_date-1"},
  {"valid_date", "valid_date(Year, Month, Day)", "valid_date-3"}
]}.
{"calendar.html", {module, "stdlib"}, ["calendar"]}.
{"dets.html", {function, {"stdlib", "dets"}},
[
  {"all", "all()", "all-0"},
  {"bchunk", "bchunk(Name, Continuation)", "bchunk-2"},
  {"close", "close(Name)", "close-1"},
  {"delete", "delete(Name, Key)", "delete-2"},
  {"delete_all_objects", "delete_all_objects(Name)", "delete_all_objects-1"},
  {"delete_object", "delete_object(Name, Object)", "delete_object-2"},
  {"first", "first(Name)", "first-1"},
  {"foldl", "foldl(Function, Acc0, Name)", "foldl-3"},
  {"foldr", "foldr(Function, Acc0, Name)", "foldr-3"},
  {"from_ets", "from_ets(Name, EtsTab)", "from_ets-2"},
  {"info", "info(Name)", "info-1"},
  {"info", "info(Name, Item)", "info-2"},
  {"init_table", "init_table(Name, InitFun)", "init_table-2"},
  {"init_table", "init_table(Name, InitFun, Options)", "init_table-3"},
  {"insert", "insert(Name, Objects)", "insert-2"},
  {"insert_new", "insert_new(Name, Objects)", "insert_new-2"},
  {"is_compatible_bchunk_format", "is_compatible_bchunk_format(Name, BchunkFormat)", "is_compatible_bchunk_format-2"},
  {"is_dets_file", "is_dets_file(Filename)", "is_dets_file-1"},
  {"lookup", "lookup(Name, Key)", "lookup-2"},
  {"match", "match(Continuation)", "match-1"},
  {"match", "match(Name, Pattern)", "match-2"},
  {"match", "match(Name, Pattern, N)", "match-3"},
  {"match_delete", "match_delete(Name, Pattern)", "match_delete-2"},
  {"match_object", "match_object(Continuation)", "match_object-1"},
  {"match_object", "match_object(Name, Pattern)", "match_object-2"},
  {"match_object", "match_object(Name, Pattern, N)", "match_object-3"},
  {"member", "member(Name, Key)", "member-2"},
  {"next", "next(Name, Key1)", "next-2"},
  {"open_file", "open_file(Filename)", "open_file-1"},
  {"open_file", "open_file(Name, Args)", "open_file-2"},
  {"pid2name", "pid2name(Pid)", "pid2name-1"},
  {"repair_continuation", "repair_continuation(Continuation, MatchSpec)", "repair_continuation-2"},
  {"safe_fixtable", "safe_fixtable(Name, Fix)", "safe_fixtable-2"},
  {"select", "select(Continuation)", "select-1"},
  {"select", "select(Name, MatchSpec)", "select-2"},
  {"select", "select(Name, MatchSpec, N)", "select-3"},
  {"select_delete", "select_delete(Name, MatchSpec)", "select_delete-2"},
  {"slot", "slot(Name, I)", "slot-2"},
  {"sync", "sync(Name)", "sync-1"},
  {"table", "table(Name)", "table-1"},
  {"table", "table(Name, Options)", "table-2"},
  {"to_ets", "to_ets(Name, EtsTab)", "to_ets-2"},
  {"traverse", "traverse(Name, Fun)", "traverse-2"},
  {"update_counter", "update_counter(Name, Key, Increment)", "update_counter-3"}
]}.
{"dets.html", {module, "stdlib"}, ["dets"]}.
{"dict.html", {function, {"stdlib", "dict"}},
[
  {"append", "append(Key, Value, Dict1)", "append-3"},
  {"append_list", "append_list(Key, ValList, Dict1)", "append_list-3"},
  {"erase", "erase(Key, Dict1)", "erase-2"},
  {"fetch", "fetch(Key, Dict)", "fetch-2"},
  {"fetch_keys", "fetch_keys(Dict)", "fetch_keys-1"},
  {"take", "take(Key, Dict)", "take-2"},
  {"filter", "filter(Pred, Dict1)", "filter-2"},
  {"find", "find(Key, Dict)", "find-2"},
  {"fold", "fold(Fun, Acc0, Dict)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"is_empty", "is_empty(Dict)", "is_empty-1"},
  {"is_key", "is_key(Key, Dict)", "is_key-2"},
  {"map", "map(Fun, Dict1)", "map-2"},
  {"merge", "merge(Fun, Dict1, Dict2)", "merge-3"},
  {"new", "new()", "new-0"},
  {"size", "size(Dict)", "size-1"},
  {"store", "store(Key, Value, Dict1)", "store-3"},
  {"to_list", "to_list(Dict)", "to_list-1"},
  {"update", "update(Key, Fun, Dict1)", "update-3"},
  {"update", "update(Key, Fun, Initial, Dict1)", "update-4"},
  {"update_counter", "update_counter(Key, Increment, Dict1)", "update_counter-3"}
]}.
{"dict.html", {module, "stdlib"}, ["dict"]}.
{"digraph.html", {function, {"stdlib", "digraph"}},
[
  {"add_edge", "add_edge(G, V1, V2)", "add_edge-3"},
  {"add_edge", "add_edge(G, V1, V2, Label)", "add_edge-4"},
  {"add_edge", "add_edge(G, E, V1, V2, Label)", "add_edge-5"},
  {"add_vertex", "add_vertex(G)", "add_vertex-1"},
  {"add_vertex", "add_vertex(G, V)", "add_vertex-2"},
  {"add_vertex", "add_vertex(G, V, Label)", "add_vertex-3"},
  {"del_edge", "del_edge(G, E)", "del_edge-2"},
  {"del_edges", "del_edges(G, Edges)", "del_edges-2"},
  {"del_path", "del_path(G, V1, V2)", "del_path-3"},
  {"del_vertex", "del_vertex(G, V)", "del_vertex-2"},
  {"del_vertices", "del_vertices(G, Vertices)", "del_vertices-2"},
  {"delete", "delete(G)", "delete-1"},
  {"edge", "edge(G, E)", "edge-2"},
  {"edges", "edges(G)", "edges-1"},
  {"edges", "edges(G, V)", "edges-2"},
  {"get_cycle", "get_cycle(G, V)", "get_cycle-2"},
  {"get_path", "get_path(G, V1, V2)", "get_path-3"},
  {"get_short_cycle", "get_short_cycle(G, V)", "get_short_cycle-2"},
  {"get_short_path", "get_short_path(G, V1, V2)", "get_short_path-3"},
  {"in_degree", "in_degree(G, V)", "in_degree-2"},
  {"in_edges", "in_edges(G, V)", "in_edges-2"},
  {"in_neighbours", "in_neighbours(G, V)", "in_neighbours-2"},
  {"info", "info(G)", "info-1"},
  {"new", "new()", "new-0"},
  {"new", "new(Type)", "new-1"},
  {"no_edges", "no_edges(G)", "no_edges-1"},
  {"no_vertices", "no_vertices(G)", "no_vertices-1"},
  {"out_degree", "out_degree(G, V)", "out_degree-2"},
  {"out_edges", "out_edges(G, V)", "out_edges-2"},
  {"out_neighbours", "out_neighbours(G, V)", "out_neighbours-2"},
  {"vertex", "vertex(G, V)", "vertex-2"},
  {"vertices", "vertices(G)", "vertices-1"}
]}.
{"digraph.html", {module, "stdlib"}, ["digraph"]}.
{"digraph_utils.html", {function, {"stdlib", "digraph_utils"}},
[
  {"arborescence_root", "arborescence_root(Digraph)", "arborescence_root-1"},
  {"components", "components(Digraph)", "components-1"},
  {"condensation", "condensation(Digraph)", "condensation-1"},
  {"cyclic_strong_components", "cyclic_strong_components(Digraph)", "cyclic_strong_components-1"},
  {"is_acyclic", "is_acyclic(Digraph)", "is_acyclic-1"},
  {"is_arborescence", "is_arborescence(Digraph)", "is_arborescence-1"},
  {"is_tree", "is_tree(Digraph)", "is_tree-1"},
  {"loop_vertices", "loop_vertices(Digraph)", "loop_vertices-1"},
  {"postorder", "postorder(Digraph)", "postorder-1"},
  {"preorder", "preorder(Digraph)", "preorder-1"},
  {"reachable", "reachable(Vertices, Digraph)", "reachable-2"},
  {"reachable_neighbours", "reachable_neighbours(Vertices, Digraph)", "reachable_neighbours-2"},
  {"reaching", "reaching(Vertices, Digraph)", "reaching-2"},
  {"reaching_neighbours", "reaching_neighbours(Vertices, Digraph)", "reaching_neighbours-2"},
  {"strong_components", "strong_components(Digraph)", "strong_components-1"},
  {"subgraph", "subgraph(Digraph, Vertices)", "subgraph-2"},
  {"subgraph", "subgraph(Digraph, Vertices, Options)", "subgraph-3"},
  {"topsort", "topsort(Digraph)", "topsort-1"}
]}.
{"digraph_utils.html", {module, "stdlib"}, ["digraph_utils"]}.
{"epp.html", {function, {"stdlib", "epp"}},
[
  {"close", "close(Epp)", "close-1"},
  {"default_encoding", "default_encoding()", "default_encoding-0"},
  {"encoding_to_string", "encoding_to_string(Encoding)", "encoding_to_string-1"},
  {"format_error", "format_error(ErrorDescriptor)", "format_error-1"},
  {"open", "open(Options)", "open-1"},
  {"open", "open(FileName, IncludePath)", "open-2"},
  {"open", "open(FileName, IncludePath, PredefMacros)", "open-3"},
  {"parse_erl_form", "parse_erl_form(Epp)", "parse_erl_form-1"},
  {"parse_file", "parse_file(FileName, Options)", "parse_file-2"},
  {"parse_file", "parse_file(FileName, IncludePath, PredefMacros)", "parse_file-3"},
  {"read_encoding", "read_encoding(FileName)", "read_encoding-1"},
  {"read_encoding", "read_encoding(FileName, Options)", "read_encoding-2"},
  {"read_encoding_from_binary", "read_encoding_from_binary(Binary)", "read_encoding_from_binary-1"},
  {"read_encoding_from_binary", "read_encoding_from_binary(Binary, Options)", "read_encoding_from_binary-2"},
  {"set_encoding", "set_encoding(File)", "set_encoding-1"},
  {"set_encoding", "set_encoding(File, Default)", "set_encoding-2"}
]}.
{"epp.html", {module, "stdlib"}, ["epp"]}.
{"erl_anno.html", {function, {"stdlib", "erl_anno"}},
[
  {"column", "column(Anno)", "column-1"},
  {"end_location", "end_location(Anno)", "end_location-1"},
  {"file", "file(Anno)", "file-1"},
  {"from_term", "from_term(Term)", "from_term-1"},
  {"generated", "generated(Anno)", "generated-1"},
  {"is_anno", "is_anno(Term)", "is_anno-1"},
  {"line", "line(Anno)", "line-1"},
  {"location", "location(Anno)", "location-1"},
  {"new", "new(Location)", "new-1"},
  {"set_file", "set_file(File, Anno)", "set_file-2"},
  {"set_generated", "set_generated(Generated, Anno)", "set_generated-2"},
  {"set_line", "set_line(Line, Anno)", "set_line-2"},
  {"set_location", "set_location(Location, Anno)", "set_location-2"},
  {"set_record", "set_record(Record, Anno)", "set_record-2"},
  {"set_text", "set_text(Text, Anno)", "set_text-2"},
  {"text", "text(Anno)", "text-1"},
  {"to_term", "to_term(Anno)", "to_term-1"}
]}.
{"erl_anno.html", {module, "stdlib"}, ["erl_anno"]}.
{"erl_eval.html", {function, {"stdlib", "erl_eval"}},
[
  {"add_binding", "add_binding(Name, Value, BindingStruct)", "add_binding-3"},
  {"binding", "binding(Name, BindingStruct)", "binding-2"},
  {"bindings", "bindings(BindingStruct :: binding_struct())", "bindings-1"},
  {"del_binding", "del_binding(Name, BindingStruct)", "del_binding-2"},
  {"expr", "expr(Expression, Bindings)", "expr-2"},
  {"expr", "expr(Expression, Bindings, LocalFunctionHandler)", "expr-3"},
  {"expr", "expr(Expression, Bindings, LocalFunctionHandler,NonLocalFunctionHandler)", "expr-4"},
  {"expr", "expr(Expression, Bindings, LocalFunctionHandler,NonLocalFunctionHandler, ReturnFormat)", "expr-5"},
  {"expr_list", "expr_list(ExpressionList, Bindings)", "expr_list-2"},
  {"expr_list", "expr_list(ExpressionList, Bindings, LocalFunctionHandler)", "expr_list-3"},
  {"expr_list", "expr_list(ExpressionList, Bindings, LocalFunctionHandler,NonLocalFunctionHandler)", "expr_list-4"},
  {"exprs", "exprs(Expressions, Bindings)", "exprs-2"},
  {"exprs", "exprs(Expressions, Bindings, LocalFunctionHandler)", "exprs-3"},
  {"exprs", "exprs(Expressions, Bindings, LocalFunctionHandler,NonLocalFunctionHandler)", "exprs-4"},
  {"new_bindings", "new_bindings()", "new_bindings-0"}
]}.
{"erl_eval.html", {module, "stdlib"}, ["erl_eval"]}.
{"erl_expand_records.html", {function, {"stdlib", "erl_expand_records"}},
[
  {"module", "module(AbsForms, CompileOptions)", "module-2"}
]}.
{"erl_expand_records.html", {module, "stdlib"}, ["erl_expand_records"]}.
{"erl_id_trans.html", {function, {"stdlib", "erl_id_trans"}},
[
  {"parse_transform", "parse_transform(Forms, Options)", "parse_transform-2"}
]}.
{"erl_id_trans.html", {module, "stdlib"}, ["erl_id_trans"]}.
{"erl_internal.html", {function, {"stdlib", "erl_internal"}},
[
  {"add_predefined_functions", "add_predefined_functions(Forms)", "add_predefined_functions-1"},
  {"arith_op", "arith_op(OpName, Arity)", "arith_op-2"},
  {"bif", "bif(Name, Arity)", "bif-2"},
  {"bool_op", "bool_op(OpName, Arity)", "bool_op-2"},
  {"comp_op", "comp_op(OpName, Arity)", "comp_op-2"},
  {"guard_bif", "guard_bif(Name, Arity)", "guard_bif-2"},
  {"list_op", "list_op(OpName, Arity)", "list_op-2"},
  {"op_type", "op_type(OpName, Arity)", "op_type-2"},
  {"send_op", "send_op(OpName, Arity)", "send_op-2"},
  {"type_test", "type_test(Name, Arity)", "type_test-2"}
]}.
{"erl_internal.html", {module, "stdlib"}, ["erl_internal"]}.
{"erl_lint.html", {function, {"stdlib", "erl_lint"}},
[
  {"format_error", "format_error(ErrorDescriptor)", "format_error-1"},
  {"is_guard_test", "is_guard_test(Expr)", "is_guard_test-1"},
  {"module", "module(AbsForms)", "module-1"},
  {"module", "module(AbsForms, FileName)", "module-2"},
  {"module", "module(AbsForms, FileName, CompileOptions)", "module-3"}
]}.
{"erl_lint.html", {module, "stdlib"}, ["erl_lint"]}.
{"erl_parse.html", {function, {"stdlib", "erl_parse"}},
[
  {"abstract", "abstract(Data)", "abstract-1"},
  {"abstract", "abstract(Data, Options)", "abstract-2"},
  {"anno_from_term", "anno_from_term(Term)", "anno_from_term-1"},
  {"anno_to_term", "anno_to_term(Abstr)", "anno_to_term-1"},
  {"fold_anno", "fold_anno(Fun, Acc0, Abstr)", "fold_anno-3"},
  {"format_error", "format_error(ErrorDescriptor)", "format_error-1"},
  {"map_anno", "map_anno(Fun, Abstr)", "map_anno-2"},
  {"mapfold_anno", "mapfold_anno(Fun, Acc0, Abstr)", "mapfold_anno-3"},
  {"new_anno", "new_anno(Term)", "new_anno-1"},
  {"normalise", "normalise(AbsTerm)", "normalise-1"},
  {"parse_exprs", "parse_exprs(Tokens)", "parse_exprs-1"},
  {"parse_form", "parse_form(Tokens)", "parse_form-1"},
  {"parse_term", "parse_term(Tokens)", "parse_term-1"},
  {"tokens", "tokens(AbsTerm)", "tokens-1"},
  {"tokens", "tokens(AbsTerm, MoreTokens)", "tokens-2"}
]}.
{"erl_parse.html", {module, "stdlib"}, ["erl_parse"]}.
{"erl_pp.html", {function, {"stdlib", "erl_pp"}},
[
  {"attribute", "attribute(Attribute)", "attribute-1"},
  {"attribute", "attribute(Attribute, Options)", "attribute-2"},
  {"expr", "expr(Expression)", "expr-1"},
  {"expr", "expr(Expression, Options)", "expr-2"},
  {"expr", "expr(Expression, Indent, Options)", "expr-3"},
  {"expr", "expr(Expression, Indent, Precedence, Options)", "expr-4"},
  {"exprs", "exprs(Expressions)", "exprs-1"},
  {"exprs", "exprs(Expressions, Options)", "exprs-2"},
  {"exprs", "exprs(Expressions, Indent, Options)", "exprs-3"},
  {"form", "form(Form)", "form-1"},
  {"form", "form(Form, Options)", "form-2"},
  {"function", "function(Function)", "function-1"},
  {"function", "function(Function, Options)", "function-2"},
  {"guard", "guard(Guard)", "guard-1"},
  {"guard", "guard(Guard, Options)", "guard-2"}
]}.
{"erl_pp.html", {module, "stdlib"}, ["erl_pp"]}.
{"erl_scan.html", {function, {"stdlib", "erl_scan"}},
[
  {"category", "category(Token)", "category-1"},
  {"column", "column(Token)", "column-1"},
  {"end_location", "end_location(Token)", "end_location-1"},
  {"format_error", "format_error(ErrorDescriptor)", "format_error-1"},
  {"line", "line(Token)", "line-1"},
  {"location", "location(Token)", "location-1"},
  {"reserved_word", "reserved_word(Atom :: atom())", "reserved_word-1"},
  {"string", "string(String)", "string-1"},
  {"string", "string(String, StartLocation)", "string-2"},
  {"string", "string(String, StartLocation, Options)", "string-3"},
  {"symbol", "symbol(Token)", "symbol-1"},
  {"text", "text(Token)", "text-1"},
  {"tokens", "tokens(Continuation, CharSpec, StartLocation)", "tokens-3"},
  {"tokens", "tokens(Continuation, CharSpec, StartLocation, Options)", "tokens-4"}
]}.
{"erl_scan.html", {module, "stdlib"}, ["erl_scan"]}.
{"erl_tar.html", {function, {"stdlib", "erl_tar"}},
[
  {"add", "add(TarDescriptor, AddType, Options)", "add-3"},
  {"add", "add(TarDescriptor, Filename, NameInArchive, Options)", "add-4"},
  {"close", "close(TarDescriptor :: tar_descriptor())", "close-1"},
  {"create", "create(Name :: file:filename_all(), FileList :: filelist())", "create-2"},
  {"create", "create(Name :: file:filename_all(),FileList :: filelist(),Options :: [create_opt()])", "create-3"},
  {"extract", "extract(Open :: open_type())", "extract-1"},
  {"extract", "extract(Open :: open_type(), Opts :: [extract_opt()])", "extract-2"},
  {"format_error", "format_error(Atom :: term())", "format_error-1"},
  {"init", "init(UserData :: user_data(),AccessMode :: write | read,Fun :: file_op())", "init-3"},
  {"open", "open(Open :: open_type(), Mode :: [write | compressed | cooked])", "open-2"},
  {"table", "table(Open :: open_type())", "table-1"},
  {"table", "table(Open :: open_type(),Opts :: [compressed | verbose | cooked])", "table-2"},
  {"t", "t(Name :: file:filename())", "t-1"},
  {"tt", "tt(Name :: open_type())", "tt-1"}
]}.
{"erl_tar.html", {module, "stdlib"}, ["erl_tar"]}.
{"ets.html", {function, {"stdlib", "ets"}},
[
  {"all", "all()", "all-0"},
  {"delete", "delete(Tab)", "delete-1"},
  {"delete", "delete(Tab, Key)", "delete-2"},
  {"delete_all_objects", "delete_all_objects(Tab)", "delete_all_objects-1"},
  {"delete_object", "delete_object(Tab, Object)", "delete_object-2"},
  {"file2tab", "file2tab(Filename)", "file2tab-1"},
  {"file2tab", "file2tab(Filename, Options)", "file2tab-2"},
  {"first", "first(Tab)", "first-1"},
  {"foldl", "foldl(Function, Acc0, Tab)", "foldl-3"},
  {"foldr", "foldr(Function, Acc0, Tab)", "foldr-3"},
  {"from_dets", "from_dets(Tab, DetsTab)", "from_dets-2"},
  {"fun2ms", "fun2ms(LiteralFun)", "fun2ms-1"},
  {"give_away", "give_away(Tab, Pid, GiftData)", "give_away-3"},
  {"i", "i()", "i-0"},
  {"i", "i(Tab)", "i-1"},
  {"info", "info(Tab)", "info-1"},
  {"info", "info(Tab, Item)", "info-2"},
  {"init_table", "init_table(Tab, InitFun)", "init_table-2"},
  {"insert", "insert(Tab, ObjectOrObjects)", "insert-2"},
  {"insert_new", "insert_new(Tab, ObjectOrObjects)", "insert_new-2"},
  {"is_compiled_ms", "is_compiled_ms(Term)", "is_compiled_ms-1"},
  {"last", "last(Tab)", "last-1"},
  {"lookup", "lookup(Tab, Key)", "lookup-2"},
  {"lookup_element", "lookup_element(Tab, Key, Pos)", "lookup_element-3"},
  {"match", "match(Continuation)", "match-1"},
  {"match", "match(Tab, Pattern)", "match-2"},
  {"match", "match(Tab, Pattern, Limit)", "match-3"},
  {"match_delete", "match_delete(Tab, Pattern)", "match_delete-2"},
  {"match_object", "match_object(Continuation)", "match_object-1"},
  {"match_object", "match_object(Tab, Pattern)", "match_object-2"},
  {"match_object", "match_object(Tab, Pattern, Limit)", "match_object-3"},
  {"match_spec_compile", "match_spec_compile(MatchSpec)", "match_spec_compile-1"},
  {"match_spec_run", "match_spec_run(List, CompiledMatchSpec)", "match_spec_run-2"},
  {"member", "member(Tab, Key)", "member-2"},
  {"new", "new(Name, Options)", "new-2"},
  {"next", "next(Tab, Key1)", "next-2"},
  {"prev", "prev(Tab, Key1)", "prev-2"},
  {"rename", "rename(Tab, Name)", "rename-2"},
  {"repair_continuation", "repair_continuation(Continuation, MatchSpec)", "repair_continuation-2"},
  {"safe_fixtable", "safe_fixtable(Tab, Fix)", "safe_fixtable-2"},
  {"select", "select(Continuation)", "select-1"},
  {"select", "select(Tab, MatchSpec)", "select-2"},
  {"select", "select(Tab, MatchSpec, Limit)", "select-3"},
  {"select_count", "select_count(Tab, MatchSpec)", "select_count-2"},
  {"select_delete", "select_delete(Tab, MatchSpec)", "select_delete-2"},
  {"select_replace", "select_replace(Tab, MatchSpec)", "select_replace-2"},
  {"select_reverse", "select_reverse(Continuation)", "select_reverse-1"},
  {"select_reverse", "select_reverse(Tab, MatchSpec)", "select_reverse-2"},
  {"select_reverse", "select_reverse(Tab, MatchSpec, Limit)", "select_reverse-3"},
  {"setopts", "setopts(Tab, Opts)", "setopts-2"},
  {"slot", "slot(Tab, I)", "slot-2"},
  {"tab2file", "tab2file(Tab, Filename)", "tab2file-2"},
  {"tab2file", "tab2file(Tab, Filename, Options)", "tab2file-3"},
  {"tab2list", "tab2list(Tab)", "tab2list-1"},
  {"tabfile_info", "tabfile_info(Filename)", "tabfile_info-1"},
  {"table", "table(Tab)", "table-1"},
  {"table", "table(Tab, Options)", "table-2"},
  {"take", "take(Tab, Key)", "take-2"},
  {"test_ms", "test_ms(Tuple, MatchSpec)", "test_ms-2"},
  {"to_dets", "to_dets(Tab, DetsTab)", "to_dets-2"},
  {"update_counter", "update_counter(Tab, Key, UpdateOp)", "update_counter-3"},
  {"update_counter", "update_counter(Tab, Key, UpdateOp, Default)", "update_counter-4"},
  {"update_counter", "update_counter(Tab, Key, X3 :: [UpdateOp])", "update_counter-3"},
  {"update_counter", "update_counter(Tab, Key, X3 :: [UpdateOp], Default)", "update_counter-4"},
  {"update_counter", "update_counter(Tab, Key, Incr)", "update_counter-3"},
  {"update_counter", "update_counter(Tab, Key, Incr, Default)", "update_counter-4"},
  {"update_element", "update_element(Tab, Key, ElementSpec :: {Pos, Value})", "update_element-3"},
  {"update_element", "update_element(Tab, Key, ElementSpec :: [{Pos, Value}])", "update_element-3"},
  {"whereis", "whereis(TableName)", "whereis-1"}
]}.
{"ets.html", {module, "stdlib"}, ["ets"]}.
{"file_sorter.html", {function, {"stdlib", "file_sorter"}},
[
  {"check", "check(FileName)", "check-1"},
  {"check", "check(FileNames, Options)", "check-2"},
  {"keycheck", "keycheck(KeyPos, FileName)", "keycheck-2"},
  {"keycheck", "keycheck(KeyPos, FileNames, Options)", "keycheck-3"},
  {"keymerge", "keymerge(KeyPos, FileNames, Output)", "keymerge-3"},
  {"keymerge", "keymerge(KeyPos, FileNames, Output, Options)", "keymerge-4"},
  {"keysort", "keysort(KeyPos, FileName)", "keysort-2"},
  {"keysort", "keysort(KeyPos, Input, Output)", "keysort-3"},
  {"keysort", "keysort(KeyPos, Input, Output, Options)", "keysort-4"},
  {"merge", "merge(FileNames, Output)", "merge-2"},
  {"merge", "merge(FileNames, Output, Options)", "merge-3"},
  {"sort", "sort(FileName)", "sort-1"},
  {"sort", "sort(Input, Output)", "sort-2"},
  {"sort", "sort(Input, Output, Options)", "sort-3"}
]}.
{"file_sorter.html", {module, "stdlib"}, ["file_sorter"]}.
{"filelib.html", {function, {"stdlib", "filelib"}},
[
  {"ensure_dir", "ensure_dir(Name)", "ensure_dir-1"},
  {"file_size", "file_size(Filename)", "file_size-1"},
  {"fold_files", "fold_files(Dir, RegExp, Recursive, Fun, AccIn)", "fold_files-5"},
  {"is_dir", "is_dir(Name)", "is_dir-1"},
  {"is_file", "is_file(Name)", "is_file-1"},
  {"is_regular", "is_regular(Name)", "is_regular-1"},
  {"last_modified", "last_modified(Name)", "last_modified-1"},
  {"wildcard", "wildcard(Wildcard)", "wildcard-1"},
  {"wildcard", "wildcard(Wildcard, Cwd)", "wildcard-2"},
  {"find_file", "find_file(Filename :: filename(), Dir :: filename())", "find_file-2"},
  {"find_file", "find_file(Filename :: filename(),Dir :: filename(),Rules :: [find_file_rule()])", "find_file-3"},
  {"find_source", "find_source(FilePath :: filename())", "find_source-1"},
  {"find_source", "find_source(Filename :: filename(), Dir :: filename())", "find_source-2"},
  {"find_source", "find_source(Filename :: filename(),Dir :: filename(),Rules :: [find_source_rule()])", "find_source-3"}
]}.
{"filelib.html", {module, "stdlib"}, ["filelib"]}.
{"filename.html", {function, {"stdlib", "filename"}},
[
  {"absname", "absname(Filename)", "absname-1"},
  {"absname", "absname(Filename, Dir)", "absname-2"},
  {"absname_join", "absname_join(Dir, Filename)", "absname_join-2"},
  {"basedir", "basedir(PathType, Application)", "basedir-2"},
  {"basedir", "basedir(PathsType, Application)", "basedir-2"},
  {"basedir", "basedir(PathType, Application, Opts)", "basedir-3"},
  {"basedir", "basedir(PathsType, Application, Opts)", "basedir-3"},
  {"basename", "basename(Filename)", "basename-1"},
  {"basename", "basename(Filename, Ext)", "basename-2"},
  {"dirname", "dirname(Filename)", "dirname-1"},
  {"extension", "extension(Filename)", "extension-1"},
  {"find_src", "find_src(Beam)", "find_src-1"},
  {"find_src", "find_src(Beam, Rules)", "find_src-2"},
  {"flatten", "flatten(Filename)", "flatten-1"},
  {"join", "join(Components)", "join-1"},
  {"join", "join(Name1, Name2)", "join-2"},
  {"nativename", "nativename(Path)", "nativename-1"},
  {"pathtype", "pathtype(Path)", "pathtype-1"},
  {"rootname", "rootname(Filename)", "rootname-1"},
  {"rootname", "rootname(Filename, Ext)", "rootname-2"},
  {"safe_relative_path", "safe_relative_path(Filename)", "safe_relative_path-1"},
  {"split", "split(Filename)", "split-1"}
]}.
{"filename.html", {module, "stdlib"}, ["filename"]}.
{"gb_sets.html", {function, {"stdlib", "gb_sets"}},
[
  {"add", "add(Element, Set1)", "add-2"},
  {"add_element", "add_element(Element, Set1)", "add_element-2"},
  {"balance", "balance(Set1)", "balance-1"},
  {"del_element", "del_element(Element, Set1)", "del_element-2"},
  {"delete", "delete(Element, Set1)", "delete-2"},
  {"delete_any", "delete_any(Element, Set1)", "delete_any-2"},
  {"difference", "difference(Set1, Set2)", "difference-2"},
  {"empty", "empty()", "empty-0"},
  {"filter", "filter(Pred, Set1)", "filter-2"},
  {"fold", "fold(Function, Acc0, Set)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"from_ordset", "from_ordset(List)", "from_ordset-1"},
  {"insert", "insert(Element, Set1)", "insert-2"},
  {"intersection", "intersection(SetList)", "intersection-1"},
  {"intersection", "intersection(Set1, Set2)", "intersection-2"},
  {"is_disjoint", "is_disjoint(Set1, Set2)", "is_disjoint-2"},
  {"is_element", "is_element(Element, Set)", "is_element-2"},
  {"is_empty", "is_empty(Set)", "is_empty-1"},
  {"is_member", "is_member(Element, Set)", "is_member-2"},
  {"is_set", "is_set(Term)", "is_set-1"},
  {"is_subset", "is_subset(Set1, Set2)", "is_subset-2"},
  {"iterator", "iterator(Set)", "iterator-1"},
  {"iterator_from", "iterator_from(Element, Set)", "iterator_from-2"},
  {"largest", "largest(Set)", "largest-1"},
  {"new", "new()", "new-0"},
  {"next", "next(Iter1)", "next-1"},
  {"singleton", "singleton(Element)", "singleton-1"},
  {"size", "size(Set)", "size-1"},
  {"smallest", "smallest(Set)", "smallest-1"},
  {"subtract", "subtract(Set1, Set2)", "subtract-2"},
  {"take_largest", "take_largest(Set1)", "take_largest-1"},
  {"take_smallest", "take_smallest(Set1)", "take_smallest-1"},
  {"to_list", "to_list(Set)", "to_list-1"},
  {"union", "union(SetList)", "union-1"},
  {"union", "union(Set1, Set2)", "union-2"}
]}.
{"gb_sets.html", {module, "stdlib"}, ["gb_sets"]}.
{"gb_trees.html", {function, {"stdlib", "gb_trees"}},
[
  {"balance", "balance(Tree1)", "balance-1"},
  {"delete", "delete(Key, Tree1)", "delete-2"},
  {"delete_any", "delete_any(Key, Tree1)", "delete_any-2"},
  {"take", "take(Key, Tree1)", "take-2"},
  {"take_any", "take_any(Key, Tree1)", "take_any-2"},
  {"empty", "empty()", "empty-0"},
  {"enter", "enter(Key, Value, Tree1)", "enter-3"},
  {"from_orddict", "from_orddict(List)", "from_orddict-1"},
  {"get", "get(Key, Tree)", "get-2"},
  {"insert", "insert(Key, Value, Tree1)", "insert-3"},
  {"is_defined", "is_defined(Key, Tree)", "is_defined-2"},
  {"is_empty", "is_empty(Tree)", "is_empty-1"},
  {"iterator", "iterator(Tree)", "iterator-1"},
  {"iterator_from", "iterator_from(Key, Tree)", "iterator_from-2"},
  {"keys", "keys(Tree)", "keys-1"},
  {"largest", "largest(Tree)", "largest-1"},
  {"lookup", "lookup(Key, Tree)", "lookup-2"},
  {"map", "map(Function, Tree1)", "map-2"},
  {"next", "next(Iter1)", "next-1"},
  {"size", "size(Tree)", "size-1"},
  {"smallest", "smallest(Tree)", "smallest-1"},
  {"take_largest", "take_largest(Tree1)", "take_largest-1"},
  {"take_smallest", "take_smallest(Tree1)", "take_smallest-1"},
  {"to_list", "to_list(Tree)", "to_list-1"},
  {"update", "update(Key, Value, Tree1)", "update-3"},
  {"values", "values(Tree)", "values-1"}
]}.
{"gb_trees.html", {module, "stdlib"}, ["gb_trees"]}.
{"gen_event.html", {function, {"stdlib", "gen_event"}},
[
  {"add_handler", "add_handler(EventMgrRef, Handler, Args)", "add_handler-3"},
  {"add_sup_handler", "add_sup_handler(EventMgrRef, Handler, Args)", "add_sup_handler-3"},
  {"call", "call(EventMgrRef, Handler, Request)", "call-3"},
  {"call", "call(EventMgrRef, Handler, Request, Timeout)", "call-4"},
  {"delete_handler", "delete_handler(EventMgrRef, Handler, Args)", "delete_handler-3"},
  {"notify", "notify(EventMgrRef, Event)", "notify-2"},
  {"sync_notify", "sync_notify(EventMgrRef, Event)", "sync_notify-2"},
  {"start", "start()", "start-0"},
  {"start", "start(EventMgrName | Options)", "start-1"},
  {"start", "start(EventMgrName, Options)", "start-2"},
  {"start_link", "start_link()", "start_link-0"},
  {"start_link", "start_link(EventMgrName | Options)", "start_link-1"},
  {"start_link", "start_link(EventMgrName, Options)", "start_link-2"},
  {"stop", "stop(EventMgrRef)", "stop-1"},
  {"stop", "stop(EventMgrRef, Reason, Timeout)", "stop-3"},
  {"swap_handler", "swap_handler(EventMgrRef, {Handler1,Args1}, {Handler2,Args2})", "swap_handler-3"},
  {"swap_sup_handler", "swap_sup_handler(EventMgrRef, {Handler1,Args1}, {Handler2,Args2})", "swap_sup_handler-3"},
  {"which_handlers", "which_handlers(EventMgrRef)", "which_handlers-1"},
  {"Module:code_change", "Module:code_change(OldVsn, State, Extra)", "Module:code_change-3"},
  {"Module:format_status", "Module:format_status(Opt, [PDict, State])", "Module:format_status-2"},
  {"Module:handle_call", "Module:handle_call(Request, State)", "Module:handle_call-2"},
  {"Module:handle_event", "Module:handle_event(Event, State)", "Module:handle_event-2"},
  {"Module:handle_info", "Module:handle_info(Info, State)", "Module:handle_info-2"},
  {"Module:init", "Module:init(InitArgs)", "Module:init-1"},
  {"Module:terminate", "Module:terminate(Arg, State)", "Module:terminate-2"}
]}.
{"gen_event.html", {module, "stdlib"}, ["gen_event"]}.
{"gen_fsm.html", {function, {"stdlib", "gen_fsm"}},
[
]}.
{"gen_fsm.html", {module, "stdlib"}, ["gen_fsm"]}.
{"gen_server.html", {function, {"stdlib", "gen_server"}},
[
  {"abcast", "abcast(Name, Request)", "abcast-2"},
  {"abcast", "abcast(Nodes, Name, Request)", "abcast-3"},
  {"call", "call(ServerRef, Request)", "call-2"},
  {"call", "call(ServerRef, Request, Timeout)", "call-3"},
  {"cast", "cast(ServerRef, Request)", "cast-2"},
  {"enter_loop", "enter_loop(Module, Options, State)", "enter_loop"},
  {"enter_loop", "enter_loop(Module, Options, State, ServerName)", "enter_loop"},
  {"enter_loop", "enter_loop(Module, Options, State, Timeout)", "enter_loop"},
  {"enter_loop", "enter_loop(Module, Options, State, ServerName, Timeout)", "enter_loop"},
  {"multi_call", "multi_call(Name, Request)", "multi_call-2"},
  {"multi_call", "multi_call(Nodes, Name, Request)", "multi_call-3"},
  {"multi_call", "multi_call(Nodes, Name, Request, Timeout)", "multi_call-4"},
  {"reply", "reply(Client, Reply)", "reply-2"},
  {"start", "start(Module, Args, Options)", "start-3"},
  {"start", "start(ServerName, Module, Args, Options)", "start-4"},
  {"start_link", "start_link(Module, Args, Options)", "start_link-3"},
  {"start_link", "start_link(ServerName, Module, Args, Options)", "start_link-4"},
  {"stop", "stop(ServerRef)", "stop-1"},
  {"stop", "stop(ServerRef, Reason, Timeout)", "stop-3"},
  {"Module:code_change", "Module:code_change(OldVsn, State, Extra)", "Module:code_change-3"},
  {"Module:format_status", "Module:format_status(Opt, [PDict, State])", "Module:format_status-2"},
  {"Module:handle_call", "Module:handle_call(Request, From, State)", "Module:handle_call-3"},
  {"Module:handle_cast", "Module:handle_cast(Request, State)", "Module:handle_cast-2"},
  {"Module:handle_continue", "Module:handle_continue(Continue, State)", "Module:handle_continue-2"},
  {"Module:handle_info", "Module:handle_info(Info, State)", "Module:handle_info-2"},
  {"Module:init", "Module:init(Args)", "Module:init-1"},
  {"Module:terminate", "Module:terminate(Reason, State)", "Module:terminate"}
]}.
{"gen_server.html", {module, "stdlib"}, ["gen_server"]}.
{"gen_statem.html", {function, {"stdlib", "gen_statem"}},
[
  {"call", "call(ServerRef :: server_ref(), Request :: term())", "call-2"},
  {"call", "call(ServerRef :: server_ref(),Request :: term(),Timeout ::timeout() |{clean_timeout, T :: timeout()} |{dirty_timeout, T :: timeout()})", "call-3"},
  {"cast", "cast(ServerRef :: server_ref(), Msg :: term())", "cast-2"},
  {"enter_loop", "enter_loop(Module :: module(),Opts :: [enter_loop_opt()],State :: state(),Data :: data())", "enter_loop-4"},
  {"enter_loop", "enter_loop(Module :: module(),Opts :: [enter_loop_opt()],State :: state(),Data :: data(),Server_or_Actions :: server_name() | pid() | [action()])", "enter_loop-5"},
  {"enter_loop", "enter_loop(Module :: module(),Opts :: [enter_loop_opt()],State :: state(),Data :: data(),Server :: server_name() | pid(),Actions :: [action()] | action())", "enter_loop-6"},
  {"reply", "reply(Replies :: [reply_action()] | reply_action())", "reply-1"},
  {"reply", "reply(From :: from(), Reply :: term())", "reply-2"},
  {"start", "start(Module :: module(), Args :: term(), Opts :: [start_opt()])", "start-3"},
  {"start", "start(ServerName :: server_name(),Module :: module(),Args :: term(),Opts :: [start_opt()])", "start-4"},
  {"start_link", "start_link(Module :: module(),Args :: term(),Opts :: [start_opt()])", "start_link-3"},
  {"start_link", "start_link(ServerName :: server_name(),Module :: module(),Args :: term(),Opts :: [start_opt()])", "start_link-4"},
  {"stop", "stop(ServerRef :: server_ref())", "stop-1"},
  {"stop", "stop(ServerRef :: server_ref(),Reason :: term(),Timeout :: timeout())", "stop-3"},
  {"Module:callback_mode", "Module:callback_mode()", "Module:callback_mode-0"},
  {"Module:code_change", "Module:code_change(OldVsn, OldState, OldData, Extra)", "Module:code_change-4"},
  {"Module:init", "Module:init(Args)", "Module:init-1"},
  {"Module:format_status", "Module:format_status(Opt, [PDict,State,Data])", "Module:format_status-2"},
  {"Module:StateName", "Module:StateName(enter, OldState, Data)", "Module:StateName-3"},
  {"Module:StateName", "Module:StateName(EventType, EventContent, Data)", "Module:StateName-3"},
  {"Module:handle_event", "Module:handle_event(enter, OldState, State, Data)", "Module:handle_event-4"},
  {"Module:handle_event", "Module:handle_event(EventType, EventContent, State, Data)", "Module:handle_event-4"},
  {"Module:terminate", "Module:terminate(Reason, State, Data)", "Module:terminate-3"}
]}.
{"gen_statem.html", {module, "stdlib"}, ["gen_statem"]}.
{"io.html", {function, {"stdlib", "io"}},
[
  {"columns", "columns()", "columns-0"},
  {"columns", "columns(IoDevice)", "columns-1"},
  {"format", "format(Format)", "format-1"},
  {"format", "format(Format, Data)", "format-2"},
  {"format", "format(IoDevice, Format, Data)", "format-3"},
  {"fwrite", "fwrite(Format)", "fwrite-1"},
  {"fwrite", "fwrite(Format, Data)", "fwrite-2"},
  {"fwrite", "fwrite(IoDevice, Format, Data)", "fwrite-3"},
  {"fread", "fread(Prompt, Format)", "fread-2"},
  {"fread", "fread(IoDevice, Prompt, Format)", "fread-3"},
  {"get_chars", "get_chars(Prompt, Count)", "get_chars-2"},
  {"get_chars", "get_chars(IoDevice, Prompt, Count)", "get_chars-3"},
  {"get_line", "get_line(Prompt)", "get_line-1"},
  {"get_line", "get_line(IoDevice, Prompt)", "get_line-2"},
  {"getopts", "getopts()", "getopts-0"},
  {"getopts", "getopts(IoDevice)", "getopts-1"},
  {"nl", "nl()", "nl-0"},
  {"nl", "nl(IoDevice)", "nl-1"},
  {"parse_erl_exprs", "parse_erl_exprs(Prompt)", "parse_erl_exprs-1"},
  {"parse_erl_exprs", "parse_erl_exprs(IoDevice, Prompt)", "parse_erl_exprs-2"},
  {"parse_erl_exprs", "parse_erl_exprs(IoDevice, Prompt, StartLocation)", "parse_erl_exprs-3"},
  {"parse_erl_exprs", "parse_erl_exprs(IoDevice, Prompt, StartLocation, Options)", "parse_erl_exprs-4"},
  {"parse_erl_form", "parse_erl_form(Prompt)", "parse_erl_form-1"},
  {"parse_erl_form", "parse_erl_form(IoDevice, Prompt)", "parse_erl_form-2"},
  {"parse_erl_form", "parse_erl_form(IoDevice, Prompt, StartLocation)", "parse_erl_form-3"},
  {"parse_erl_form", "parse_erl_form(IoDevice, Prompt, StartLocation, Options)", "parse_erl_form-4"},
  {"printable_range", "printable_range()", "printable_range-0"},
  {"put_chars", "put_chars(CharData)", "put_chars-1"},
  {"put_chars", "put_chars(IoDevice, CharData)", "put_chars-2"},
  {"read", "read(Prompt)", "read-1"},
  {"read", "read(IoDevice, Prompt)", "read-2"},
  {"read", "read(IoDevice, Prompt, StartLocation)", "read-3"},
  {"read", "read(IoDevice, Prompt, StartLocation, Options)", "read-4"},
  {"rows", "rows()", "rows-0"},
  {"rows", "rows(IoDevice)", "rows-1"},
  {"scan_erl_exprs", "scan_erl_exprs(Prompt)", "scan_erl_exprs-1"},
  {"scan_erl_exprs", "scan_erl_exprs(Device, Prompt)", "scan_erl_exprs-2"},
  {"scan_erl_exprs", "scan_erl_exprs(Device, Prompt, StartLocation)", "scan_erl_exprs-3"},
  {"scan_erl_exprs", "scan_erl_exprs(Device, Prompt, StartLocation, Options)", "scan_erl_exprs-4"},
  {"scan_erl_form", "scan_erl_form(Prompt)", "scan_erl_form-1"},
  {"scan_erl_form", "scan_erl_form(IoDevice, Prompt)", "scan_erl_form-2"},
  {"scan_erl_form", "scan_erl_form(IoDevice, Prompt, StartLocation)", "scan_erl_form-3"},
  {"scan_erl_form", "scan_erl_form(IoDevice, Prompt, StartLocation, Options)", "scan_erl_form-4"},
  {"setopts", "setopts(Opts)", "setopts-1"},
  {"setopts", "setopts(IoDevice, Opts)", "setopts-2"},
  {"write", "write(Term)", "write-1"},
  {"write", "write(IoDevice, Term)", "write-2"}
]}.
{"io.html", {module, "stdlib"}, ["io"]}.
{"io_lib.html", {function, {"stdlib", "io_lib"}},
[
  {"build_text", "build_text(FormatList)", "build_text-1"},
  {"char_list", "char_list(Term)", "char_list-1"},
  {"deep_char_list", "deep_char_list(Term)", "deep_char_list-1"},
  {"deep_latin1_char_list", "deep_latin1_char_list(Term)", "deep_latin1_char_list-1"},
  {"format", "format(Format, Data)", "format-2"},
  {"fwrite", "fwrite(Format, Data)", "fwrite-2"},
  {"format", "format(Format, Data, Options)", "format-3"},
  {"fwrite", "fwrite(Format, Data, Options)", "fwrite-3"},
  {"fread", "fread(Format, String)", "fread-2"},
  {"fread", "fread(Continuation, CharSpec, Format)", "fread-3"},
  {"indentation", "indentation(String, StartIndent)", "indentation-2"},
  {"latin1_char_list", "latin1_char_list(Term)", "latin1_char_list-1"},
  {"nl", "nl()", "nl-0"},
  {"print", "print(Term)", "print-1"},
  {"print", "print(Term, Column, LineLength, Depth)", "print-4"},
  {"printable_latin1_list", "printable_latin1_list(Term)", "printable_latin1_list-1"},
  {"printable_list", "printable_list(Term)", "printable_list-1"},
  {"printable_unicode_list", "printable_unicode_list(Term)", "printable_unicode_list-1"},
  {"scan_format", "scan_format(Format, Data)", "scan_format-2"},
  {"unscan_format", "unscan_format(FormatList)", "unscan_format-1"},
  {"write", "write(Term)", "write-1"},
  {"write", "write(Term, Depth)", "write-2"},
  {"write", "write(Term, Options)", "write-2"},
  {"write_atom", "write_atom(Atom)", "write_atom-1"},
  {"write_atom_as_latin1", "write_atom_as_latin1(Atom)", "write_atom_as_latin1-1"},
  {"write_char", "write_char(Char)", "write_char-1"},
  {"write_char_as_latin1", "write_char_as_latin1(Char)", "write_char_as_latin1-1"},
  {"write_latin1_char", "write_latin1_char(Latin1Char)", "write_latin1_char-1"},
  {"write_latin1_string", "write_latin1_string(Latin1String)", "write_latin1_string-1"},
  {"write_string", "write_string(String)", "write_string-1"},
  {"write_string_as_latin1", "write_string_as_latin1(String)", "write_string_as_latin1-1"}
]}.
{"io_lib.html", {module, "stdlib"}, ["io_lib"]}.
{"lists.html", {function, {"stdlib", "lists"}},
[
  {"all", "all(Pred, List)", "all-2"},
  {"any", "any(Pred, List)", "any-2"},
  {"append", "append(ListOfLists)", "append-1"},
  {"append", "append(List1, List2)", "append-2"},
  {"concat", "concat(Things)", "concat-1"},
  {"delete", "delete(Elem, List1)", "delete-2"},
  {"droplast", "droplast(List)", "droplast-1"},
  {"dropwhile", "dropwhile(Pred, List1)", "dropwhile-2"},
  {"duplicate", "duplicate(N, Elem)", "duplicate-2"},
  {"filter", "filter(Pred, List1)", "filter-2"},
  {"filtermap", "filtermap(Fun, List1)", "filtermap-2"},
  {"flatlength", "flatlength(DeepList)", "flatlength-1"},
  {"flatmap", "flatmap(Fun, List1)", "flatmap-2"},
  {"flatten", "flatten(DeepList)", "flatten-1"},
  {"flatten", "flatten(DeepList, Tail)", "flatten-2"},
  {"foldl", "foldl(Fun, Acc0, List)", "foldl-3"},
  {"foldr", "foldr(Fun, Acc0, List)", "foldr-3"},
  {"join", "join(Sep, List1)", "join-2"},
  {"foreach", "foreach(Fun, List)", "foreach-2"},
  {"keydelete", "keydelete(Key, N, TupleList1)", "keydelete-3"},
  {"keyfind", "keyfind(Key, N, TupleList)", "keyfind-3"},
  {"keymap", "keymap(Fun, N, TupleList1)", "keymap-3"},
  {"keymember", "keymember(Key, N, TupleList)", "keymember-3"},
  {"keymerge", "keymerge(N, TupleList1, TupleList2)", "keymerge-3"},
  {"keyreplace", "keyreplace(Key, N, TupleList1, NewTuple)", "keyreplace-4"},
  {"keysearch", "keysearch(Key, N, TupleList)", "keysearch-3"},
  {"keysort", "keysort(N, TupleList1)", "keysort-2"},
  {"keystore", "keystore(Key, N, TupleList1, NewTuple)", "keystore-4"},
  {"keytake", "keytake(Key, N, TupleList1)", "keytake-3"},
  {"last", "last(List)", "last-1"},
  {"map", "map(Fun, List1)", "map-2"},
  {"mapfoldl", "mapfoldl(Fun, Acc0, List1)", "mapfoldl-3"},
  {"mapfoldr", "mapfoldr(Fun, Acc0, List1)", "mapfoldr-3"},
  {"max", "max(List)", "max-1"},
  {"member", "member(Elem, List)", "member-2"},
  {"merge", "merge(ListOfLists)", "merge-1"},
  {"merge", "merge(List1, List2)", "merge-2"},
  {"merge", "merge(Fun, List1, List2)", "merge-3"},
  {"merge3", "merge3(List1, List2, List3)", "merge3-3"},
  {"min", "min(List)", "min-1"},
  {"nth", "nth(N, List)", "nth-2"},
  {"nthtail", "nthtail(N, List)", "nthtail-2"},
  {"partition", "partition(Pred, List)", "partition-2"},
  {"prefix", "prefix(List1, List2)", "prefix-2"},
  {"reverse", "reverse(List1)", "reverse-1"},
  {"reverse", "reverse(List1, Tail)", "reverse-2"},
  {"search", "search(Pred, List)", "search-2"},
  {"seq", "seq(From, To)", "seq-2"},
  {"seq", "seq(From, To, Incr)", "seq-3"},
  {"sort", "sort(List1)", "sort-1"},
  {"sort", "sort(Fun, List1)", "sort-2"},
  {"split", "split(N, List1)", "split-2"},
  {"splitwith", "splitwith(Pred, List)", "splitwith-2"},
  {"sublist", "sublist(List1, Len)", "sublist-2"},
  {"sublist", "sublist(List1, Start, Len)", "sublist-3"},
  {"subtract", "subtract(List1, List2)", "subtract-2"},
  {"suffix", "suffix(List1, List2)", "suffix-2"},
  {"sum", "sum(List)", "sum-1"},
  {"takewhile", "takewhile(Pred, List1)", "takewhile-2"},
  {"ukeymerge", "ukeymerge(N, TupleList1, TupleList2)", "ukeymerge-3"},
  {"ukeysort", "ukeysort(N, TupleList1)", "ukeysort-2"},
  {"umerge", "umerge(ListOfLists)", "umerge-1"},
  {"umerge", "umerge(List1, List2)", "umerge-2"},
  {"umerge", "umerge(Fun, List1, List2)", "umerge-3"},
  {"umerge3", "umerge3(List1, List2, List3)", "umerge3-3"},
  {"unzip", "unzip(List1)", "unzip-1"},
  {"unzip3", "unzip3(List1)", "unzip3-1"},
  {"usort", "usort(List1)", "usort-1"},
  {"usort", "usort(Fun, List1)", "usort-2"},
  {"zip", "zip(List1, List2)", "zip-2"},
  {"zip3", "zip3(List1, List2, List3)", "zip3-3"},
  {"zipwith", "zipwith(Combine, List1, List2)", "zipwith-3"},
  {"zipwith3", "zipwith3(Combine, List1, List2, List3)", "zipwith3-4"}
]}.
{"lists.html", {module, "stdlib"}, ["lists"]}.
{"log_mf_h.html", {function, {"stdlib", "log_mf_h"}},
[
  {"init", "init(Dir, MaxBytes, MaxFiles)", "init-3"},
  {"init", "init(Dir, MaxBytes, MaxFiles, Pred)", "init-4"}
]}.
{"log_mf_h.html", {module, "stdlib"}, ["log_mf_h"]}.
{"maps.html", {function, {"stdlib", "maps"}},
[
  {"filter", "filter(Pred, MapOrIter)", "filter-2"},
  {"find", "find(Key, Map)", "find-2"},
  {"fold", "fold(Fun, Init, MapOrIter)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"get", "get(Key, Map)", "get-2"},
  {"get", "get(Key, Map, Default)", "get-3"},
  {"is_key", "is_key(Key, Map)", "is_key-2"},
  {"iterator", "iterator(Map)", "iterator-1"},
  {"keys", "keys(Map)", "keys-1"},
  {"map", "map(Fun, MapOrIter)", "map-2"},
  {"merge", "merge(Map1, Map2)", "merge-2"},
  {"new", "new()", "new-0"},
  {"next", "next(Iterator)", "next-1"},
  {"put", "put(Key, Value, Map1)", "put-3"},
  {"remove", "remove(Key, Map1)", "remove-2"},
  {"size", "size(Map)", "size-1"},
  {"take", "take(Key, Map1)", "take-2"},
  {"to_list", "to_list(Map)", "to_list-1"},
  {"update", "update(Key, Value, Map1)", "update-3"},
  {"update_with", "update_with(Key, Fun, Map1)", "update_with-3"},
  {"update_with", "update_with(Key, Fun, Init, Map1)", "update_with-4"},
  {"values", "values(Map)", "values-1"},
  {"with", "with(Ks, Map1)", "with-2"},
  {"without", "without(Ks, Map1)", "without-2"}
]}.
{"maps.html", {module, "stdlib"}, ["maps"]}.
{"math.html", {function, {"stdlib", "math"}},
[
  {"acos", "acos(X)", "acos-1"},
  {"acosh", "acosh(X)", "acosh-1"},
  {"asin", "asin(X)", "asin-1"},
  {"asinh", "asinh(X)", "asinh-1"},
  {"atan", "atan(X)", "atan-1"},
  {"atan2", "atan2(Y, X)", "atan2-2"},
  {"atanh", "atanh(X)", "atanh-1"},
  {"ceil", "ceil(X)", "ceil-1"},
  {"cos", "cos(X)", "cos-1"},
  {"cosh", "cosh(X)", "cosh-1"},
  {"exp", "exp(X)", "exp-1"},
  {"floor", "floor(X)", "floor-1"},
  {"fmod", "fmod(X, Y)", "fmod-2"},
  {"log", "log(X)", "log-1"},
  {"log10", "log10(X)", "log10-1"},
  {"log2", "log2(X)", "log2-1"},
  {"pow", "pow(X, Y)", "pow-2"},
  {"sin", "sin(X)", "sin-1"},
  {"sinh", "sinh(X)", "sinh-1"},
  {"sqrt", "sqrt(X)", "sqrt-1"},
  {"tan", "tan(X)", "tan-1"},
  {"tanh", "tanh(X)", "tanh-1"},
  {"erf", "erf(X)", "erf-1"},
  {"erfc", "erfc(X)", "erfc-1"},
  {"pi", "pi()", "pi-0"}
]}.
{"math.html", {module, "stdlib"}, ["math"]}.
{"ms_transform.html", {function, {"stdlib", "ms_transform"}},
[
  {"format_error", "format_error(Error)", "format_error-1"},
  {"parse_transform", "parse_transform(Forms, Options)", "parse_transform-2"},
  {"transform_from_shell", "transform_from_shell(Dialect, Clauses, BoundEnvironment)", "transform_from_shell-3"}
]}.
{"ms_transform.html", {module, "stdlib"}, ["ms_transform"]}.
{"orddict.html", {function, {"stdlib", "orddict"}},
[
  {"append", "append(Key, Value, Orddict1)", "append-3"},
  {"append_list", "append_list(Key, ValList, Orddict1)", "append_list-3"},
  {"erase", "erase(Key, Orddict1)", "erase-2"},
  {"fetch", "fetch(Key, Orddict)", "fetch-2"},
  {"fetch_keys", "fetch_keys(Orddict)", "fetch_keys-1"},
  {"take", "take(Key, Orddict)", "take-2"},
  {"filter", "filter(Pred, Orddict1)", "filter-2"},
  {"find", "find(Key, Orddict)", "find-2"},
  {"fold", "fold(Fun, Acc0, Orddict)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"is_empty", "is_empty(Orddict)", "is_empty-1"},
  {"is_key", "is_key(Key, Orddict)", "is_key-2"},
  {"map", "map(Fun, Orddict1)", "map-2"},
  {"merge", "merge(Fun, Orddict1, Orddict2)", "merge-3"},
  {"new", "new()", "new-0"},
  {"size", "size(Orddict)", "size-1"},
  {"store", "store(Key, Value, Orddict1)", "store-3"},
  {"to_list", "to_list(Orddict)", "to_list-1"},
  {"update", "update(Key, Fun, Orddict1)", "update-3"},
  {"update", "update(Key, Fun, Initial, Orddict1)", "update-4"},
  {"update_counter", "update_counter(Key, Increment, Orddict1)", "update_counter-3"}
]}.
{"orddict.html", {module, "stdlib"}, ["orddict"]}.
{"ordsets.html", {function, {"stdlib", "ordsets"}},
[
  {"add_element", "add_element(Element, Ordset1)", "add_element-2"},
  {"del_element", "del_element(Element, Ordset1)", "del_element-2"},
  {"filter", "filter(Pred, Ordset1)", "filter-2"},
  {"fold", "fold(Function, Acc0, Ordset)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"intersection", "intersection(OrdsetList)", "intersection-1"},
  {"intersection", "intersection(Ordset1, Ordset2)", "intersection-2"},
  {"is_disjoint", "is_disjoint(Ordset1, Ordset2)", "is_disjoint-2"},
  {"is_element", "is_element(Element, Ordset)", "is_element-2"},
  {"is_empty", "is_empty(Ordset)", "is_empty-1"},
  {"is_set", "is_set(Ordset)", "is_set-1"},
  {"is_subset", "is_subset(Ordset1, Ordset2)", "is_subset-2"},
  {"new", "new()", "new-0"},
  {"size", "size(Ordset)", "size-1"},
  {"subtract", "subtract(Ordset1, Ordset2)", "subtract-2"},
  {"to_list", "to_list(Ordset)", "to_list-1"},
  {"union", "union(OrdsetList)", "union-1"},
  {"union", "union(Ordset1, Ordset2)", "union-2"}
]}.
{"ordsets.html", {module, "stdlib"}, ["ordsets"]}.
{"pool.html", {function, {"stdlib", "pool"}},
[
  {"attach", "attach(Node)", "attach-1"},
  {"get_node", "get_node()", "get_node-0"},
  {"get_nodes", "get_nodes()", "get_nodes-0"},
  {"pspawn", "pspawn(Mod, Fun, Args)", "pspawn-3"},
  {"pspawn_link", "pspawn_link(Mod, Fun, Args)", "pspawn_link-3"},
  {"start", "start(Name)", "start-1"},
  {"start", "start(Name, Args)", "start-2"},
  {"stop", "stop()", "stop-0"}
]}.
{"pool.html", {module, "stdlib"}, ["pool"]}.
{"proc_lib.html", {function, {"stdlib", "proc_lib"}},
[
  {"format", "format(CrashReport)", "format-1"},
  {"format", "format(CrashReport, Encoding)", "format-2"},
  {"format", "format(CrashReport, Encoding, Depth)", "format-3"},
  {"hibernate", "hibernate(Module, Function, Args)", "hibernate-3"},
  {"init_ack", "init_ack(Ret)", "init_ack-1"},
  {"init_ack", "init_ack(Parent, Ret)", "init_ack-2"},
  {"initial_call", "initial_call(Process)", "initial_call-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_opt", "spawn_opt(Fun, SpawnOpts)", "spawn_opt-2"},
  {"spawn_opt", "spawn_opt(Node, Function, SpawnOpts)", "spawn_opt-3"},
  {"spawn_opt", "spawn_opt(Module, Function, Args, SpawnOpts)", "spawn_opt-4"},
  {"spawn_opt", "spawn_opt(Node, Module, Function, Args, SpawnOpts)", "spawn_opt-5"},
  {"start", "start(Module, Function, Args)", "start-3"},
  {"start", "start(Module, Function, Args, Time)", "start-4"},
  {"start", "start(Module, Function, Args, Time, SpawnOpts)", "start-5"},
  {"start_link", "start_link(Module, Function, Args)", "start_link-3"},
  {"start_link", "start_link(Module, Function, Args, Time)", "start_link-4"},
  {"start_link", "start_link(Module, Function, Args, Time, SpawnOpts)", "start_link-5"},
  {"stop", "stop(Process)", "stop-1"},
  {"stop", "stop(Process, Reason, Timeout)", "stop-3"},
  {"translate_initial_call", "translate_initial_call(Process)", "translate_initial_call-1"}
]}.
{"proc_lib.html", {module, "stdlib"}, ["proc_lib"]}.
{"proplists.html", {function, {"stdlib", "proplists"}},
[
  {"append_values", "append_values(Key, ListIn)", "append_values-2"},
  {"compact", "compact(ListIn)", "compact-1"},
  {"delete", "delete(Key, List)", "delete-2"},
  {"expand", "expand(Expansions, ListIn)", "expand-2"},
  {"get_all_values", "get_all_values(Key, List)", "get_all_values-2"},
  {"get_bool", "get_bool(Key, List)", "get_bool-2"},
  {"get_keys", "get_keys(List)", "get_keys-1"},
  {"get_value", "get_value(Key, List)", "get_value-2"},
  {"get_value", "get_value(Key, List, Default)", "get_value-3"},
  {"is_defined", "is_defined(Key, List)", "is_defined-2"},
  {"lookup", "lookup(Key, List)", "lookup-2"},
  {"lookup_all", "lookup_all(Key, List)", "lookup_all-2"},
  {"normalize", "normalize(ListIn, Stages)", "normalize-2"},
  {"property", "property(PropertyIn)", "property-1"},
  {"property", "property(Key, Value)", "property-2"},
  {"split", "split(List, Keys)", "split-2"},
  {"substitute_aliases", "substitute_aliases(Aliases, ListIn)", "substitute_aliases-2"},
  {"substitute_negations", "substitute_negations(Negations, ListIn)", "substitute_negations-2"},
  {"unfold", "unfold(ListIn)", "unfold-1"}
]}.
{"proplists.html", {module, "stdlib"}, ["proplists"]}.
{"qlc.html", {function, {"stdlib", "qlc"}},
[
  {"append", "append(QHL)", "append-1"},
  {"append", "append(QH1, QH2)", "append-2"},
  {"cursor", "cursor(QH)", "cursor-1"},
  {"cursor", "cursor(QH, Options)", "cursor-2"},
  {"delete_cursor", "delete_cursor(QueryCursor)", "delete_cursor-1"},
  {"e", "e(QH)", "e-1"},
  {"e", "e(QH, Options)", "e-2"},
  {"eval", "eval(QH)", "eval-1"},
  {"eval", "eval(QH, Options)", "eval-2"},
  {"fold", "fold(Function, Acc0, QH)", "fold-3"},
  {"fold", "fold(Function, Acc0, QH, Options)", "fold-4"},
  {"format_error", "format_error(Error)", "format_error-1"},
  {"info", "info(QH)", "info-1"},
  {"info", "info(QH, Options)", "info-2"},
  {"keysort", "keysort(KeyPos, QH1)", "keysort-2"},
  {"keysort", "keysort(KeyPos, QH1, SortOptions)", "keysort-3"},
  {"next_answers", "next_answers(QueryCursor)", "next_answers-1"},
  {"next_answers", "next_answers(QueryCursor, NumberOfAnswers)", "next_answers-2"},
  {"q", "q(QLC)", "q-1"},
  {"q", "q(QLC, Options)", "q-2"},
  {"sort", "sort(QH1)", "sort-1"},
  {"sort", "sort(QH1, SortOptions)", "sort-2"},
  {"string_to_handle", "string_to_handle(QueryString)", "string_to_handle-1"},
  {"string_to_handle", "string_to_handle(QueryString, Options)", "string_to_handle-2"},
  {"string_to_handle", "string_to_handle(QueryString, Options, Bindings)", "string_to_handle-3"},
  {"table", "table(TraverseFun, Options)", "table-2"}
]}.
{"qlc.html", {module, "stdlib"}, ["qlc"]}.
{"queue.html", {function, {"stdlib", "queue"}},
[
  {"filter", "filter(Fun, Q1 :: queue(Item))", "filter-2"},
  {"from_list", "from_list(L :: [Item])", "from_list-1"},
  {"in", "in(Item, Q1 :: queue(Item))", "in-2"},
  {"in_r", "in_r(Item, Q1 :: queue(Item))", "in_r-2"},
  {"is_empty", "is_empty(Q :: queue())", "is_empty-1"},
  {"is_queue", "is_queue(Term :: term())", "is_queue-1"},
  {"join", "join(Q1 :: queue(Item), Q2 :: queue(Item))", "join-2"},
  {"len", "len(Q :: queue())", "len-1"},
  {"member", "member(Item, Q :: queue(Item))", "member-2"},
  {"new", "new()", "new-0"},
  {"out", "out(Q1 :: queue(Item))", "out-1"},
  {"out_r", "out_r(Q1 :: queue(Item))", "out_r-1"},
  {"reverse", "reverse(Q1 :: queue(Item))", "reverse-1"},
  {"split", "split(N :: integer() >= 0, Q1 :: queue(Item))", "split-2"},
  {"to_list", "to_list(Q :: queue(Item))", "to_list-1"},
  {"drop", "drop(Q1 :: queue(Item))", "drop-1"},
  {"drop_r", "drop_r(Q1 :: queue(Item))", "drop_r-1"},
  {"get", "get(Q :: queue(Item))", "get-1"},
  {"get_r", "get_r(Q :: queue(Item))", "get_r-1"},
  {"peek", "peek(Q :: queue(Item))", "peek-1"},
  {"peek_r", "peek_r(Q :: queue(Item))", "peek_r-1"},
  {"cons", "cons(Item, Q1 :: queue(Item))", "cons-2"},
  {"daeh", "daeh(Q :: queue(Item))", "daeh-1"},
  {"head", "head(Q :: queue(Item))", "head-1"},
  {"init", "init(Q1 :: queue(Item))", "init-1"},
  {"lait", "lait(Q1 :: queue(Item))", "lait-1"},
  {"last", "last(Q :: queue(Item))", "last-1"},
  {"liat", "liat(Q1 :: queue(Item))", "liat-1"},
  {"snoc", "snoc(Q1 :: queue(Item), Item)", "snoc-2"},
  {"tail", "tail(Q1 :: queue(Item))", "tail-1"}
]}.
{"queue.html", {module, "stdlib"}, ["queue"]}.
{"rand.html", {function, {"stdlib", "rand"}},
[
  {"export_seed", "export_seed()", "export_seed-0"},
  {"export_seed_s", "export_seed_s(State :: state())", "export_seed_s-1"},
  {"jump", "jump()", "jump-0"},
  {"jump", "jump(State :: state())", "jump-1"},
  {"normal", "normal()", "normal-0"},
  {"normal", "normal(Mean :: number(), Variance :: number())", "normal-2"},
  {"normal_s", "normal_s(State :: state())", "normal_s-1"},
  {"normal_s", "normal_s(Mean :: number(),Variance :: number(),State0 :: state())", "normal_s-3"},
  {"seed", "seed(AlgOrStateOrExpState ::builtin_alg() | state() | export_state())", "seed-1"},
  {"seed", "seed(Alg :: builtin_alg(), Seed :: seed())", "seed-2"},
  {"seed_s", "seed_s(AlgOrStateOrExpState ::builtin_alg() | state() | export_state())", "seed_s-1"},
  {"seed_s", "seed_s(Alg :: builtin_alg(), Seed :: seed())", "seed_s-2"},
  {"uniform", "uniform()", "uniform-0"},
  {"uniform_real", "uniform_real()", "uniform_real-0"},
  {"uniform", "uniform(N :: integer() >= 1)", "uniform-1"},
  {"uniform_s", "uniform_s(State :: state())", "uniform_s-1"},
  {"uniform_real_s", "uniform_real_s(State :: state())", "uniform_real_s-1"},
  {"uniform_s", "uniform_s(N :: integer() >= 1, State :: state())", "uniform_s-2"}
]}.
{"rand.html", {module, "stdlib"}, ["rand"]}.
{"random.html", {function, {"stdlib", "random"}},
[
  {"seed", "seed()", "seed-0"},
  {"seed", "seed(SValue)", "seed-1"},
  {"seed", "seed(A1, A2, A3)", "seed-3"},
  {"seed0", "seed0()", "seed0-0"},
  {"uniform", "uniform()", "uniform-0"},
  {"uniform", "uniform(N)", "uniform-1"},
  {"uniform_s", "uniform_s(State0)", "uniform_s-1"},
  {"uniform_s", "uniform_s(N, State0)", "uniform_s-2"}
]}.
{"random.html", {module, "stdlib"}, ["random"]}.
{"re.html", {function, {"stdlib", "re"}},
[
  {"version", "version()", "version-0"},
  {"compile", "compile(Regexp)", "compile-1"},
  {"compile", "compile(Regexp, Options)", "compile-2"},
  {"inspect", "inspect(MP, Item)", "inspect-2"},
  {"replace", "replace(Subject, RE, Replacement)", "replace-3"},
  {"replace", "replace(Subject, RE, Replacement, Options)", "replace-4"},
  {"run", "run(Subject, RE)", "run-2"},
  {"run", "run(Subject, RE, Options)", "run-3"},
  {"split", "split(Subject, RE)", "split-2"},
  {"split", "split(Subject, RE, Options)", "split-3"}
]}.
{"re.html", {module, "stdlib"}, ["re"]}.
{"sets.html", {function, {"stdlib", "sets"}},
[
  {"add_element", "add_element(Element, Set1)", "add_element-2"},
  {"del_element", "del_element(Element, Set1)", "del_element-2"},
  {"filter", "filter(Pred, Set1)", "filter-2"},
  {"fold", "fold(Function, Acc0, Set)", "fold-3"},
  {"from_list", "from_list(List)", "from_list-1"},
  {"intersection", "intersection(SetList)", "intersection-1"},
  {"intersection", "intersection(Set1, Set2)", "intersection-2"},
  {"is_disjoint", "is_disjoint(Set1, Set2)", "is_disjoint-2"},
  {"is_element", "is_element(Element, Set)", "is_element-2"},
  {"is_empty", "is_empty(Set)", "is_empty-1"},
  {"is_set", "is_set(Set)", "is_set-1"},
  {"is_subset", "is_subset(Set1, Set2)", "is_subset-2"},
  {"new", "new()", "new-0"},
  {"size", "size(Set)", "size-1"},
  {"subtract", "subtract(Set1, Set2)", "subtract-2"},
  {"to_list", "to_list(Set)", "to_list-1"},
  {"union", "union(SetList)", "union-1"},
  {"union", "union(Set1, Set2)", "union-2"}
]}.
{"sets.html", {module, "stdlib"}, ["sets"]}.
{"shell.html", {function, {"stdlib", "shell"}},
[
  {"catch_exception", "catch_exception(Bool)", "catch_exception-1"},
  {"history", "history(N)", "history-1"},
  {"prompt_func", "prompt_func(PromptFunc)", "prompt_func-1"},
  {"results", "results(N)", "results-1"},
  {"start_restricted", "start_restricted(Module)", "start_restricted-1"},
  {"stop_restricted", "stop_restricted()", "stop_restricted-0"},
  {"strings", "strings(Strings)", "strings-1"}
]}.
{"shell.html", {module, "stdlib"}, ["shell"]}.
{"shell_default.html", {function, {"stdlib", "shell_default"}},
[
]}.
{"shell_default.html", {module, "stdlib"}, ["shell_default"]}.
{"slave.html", {function, {"stdlib", "slave"}},
[
  {"pseudo", "pseudo([Master | ServerList])", "pseudo-1"},
  {"pseudo", "pseudo(Master, ServerList)", "pseudo-2"},
  {"relay", "relay(Pid)", "relay-1"},
  {"start", "start(Host)", "start-1"},
  {"start", "start(Host, Name)", "start-2"},
  {"start", "start(Host, Name, Args)", "start-3"},
  {"start_link", "start_link(Host)", "start_link-1"},
  {"start_link", "start_link(Host, Name)", "start_link-2"},
  {"start_link", "start_link(Host, Name, Args)", "start_link-3"},
  {"stop", "stop(Node)", "stop-1"}
]}.
{"slave.html", {module, "stdlib"}, ["slave"]}.
{"sofs.html", {function, {"stdlib", "sofs"}},
[
  {"a_function", "a_function(Tuples)", "a_function-1"},
  {"a_function", "a_function(Tuples, Type)", "a_function-2"},
  {"canonical_relation", "canonical_relation(SetOfSets)", "canonical_relation-1"},
  {"composite", "composite(Function1, Function2)", "composite-2"},
  {"constant_function", "constant_function(Set, AnySet)", "constant_function-2"},
  {"converse", "converse(BinRel1)", "converse-1"},
  {"difference", "difference(Set1, Set2)", "difference-2"},
  {"digraph_to_family", "digraph_to_family(Graph)", "digraph_to_family-1"},
  {"digraph_to_family", "digraph_to_family(Graph, Type)", "digraph_to_family-2"},
  {"domain", "domain(BinRel)", "domain-1"},
  {"drestriction", "drestriction(BinRel1, Set)", "drestriction-2"},
  {"drestriction", "drestriction(SetFun, Set1, Set2)", "drestriction-3"},
  {"empty_set", "empty_set()", "empty_set-0"},
  {"extension", "extension(BinRel1, Set, AnySet)", "extension-3"},
  {"family", "family(Tuples)", "family-1"},
  {"family", "family(Tuples, Type)", "family-2"},
  {"family_difference", "family_difference(Family1, Family2)", "family_difference-2"},
  {"family_domain", "family_domain(Family1)", "family_domain-1"},
  {"family_field", "family_field(Family1)", "family_field-1"},
  {"family_intersection", "family_intersection(Family1)", "family_intersection-1"},
  {"family_intersection", "family_intersection(Family1, Family2)", "family_intersection-2"},
  {"family_projection", "family_projection(SetFun, Family1)", "family_projection-2"},
  {"family_range", "family_range(Family1)", "family_range-1"},
  {"family_specification", "family_specification(Fun, Family1)", "family_specification-2"},
  {"family_to_digraph", "family_to_digraph(Family)", "family_to_digraph-1"},
  {"family_to_digraph", "family_to_digraph(Family, GraphType)", "family_to_digraph-2"},
  {"family_to_relation", "family_to_relation(Family)", "family_to_relation-1"},
  {"family_union", "family_union(Family1)", "family_union-1"},
  {"family_union", "family_union(Family1, Family2)", "family_union-2"},
  {"field", "field(BinRel)", "field-1"},
  {"from_external", "from_external(ExternalSet, Type)", "from_external-2"},
  {"from_sets", "from_sets(ListOfSets)", "from_sets-1"},
  {"from_sets", "from_sets(TupleOfSets)", "from_sets-1"},
  {"from_term", "from_term(Term)", "from_term-1"},
  {"from_term", "from_term(Term, Type)", "from_term-2"},
  {"image", "image(BinRel, Set1)", "image-2"},
  {"intersection", "intersection(SetOfSets)", "intersection-1"},
  {"intersection", "intersection(Set1, Set2)", "intersection-2"},
  {"intersection_of_family", "intersection_of_family(Family)", "intersection_of_family-1"},
  {"inverse", "inverse(Function1)", "inverse-1"},
  {"inverse_image", "inverse_image(BinRel, Set1)", "inverse_image-2"},
  {"is_a_function", "is_a_function(BinRel)", "is_a_function-1"},
  {"is_disjoint", "is_disjoint(Set1, Set2)", "is_disjoint-2"},
  {"is_empty_set", "is_empty_set(AnySet)", "is_empty_set-1"},
  {"is_equal", "is_equal(AnySet1, AnySet2)", "is_equal-2"},
  {"is_set", "is_set(AnySet)", "is_set-1"},
  {"is_sofs_set", "is_sofs_set(Term)", "is_sofs_set-1"},
  {"is_subset", "is_subset(Set1, Set2)", "is_subset-2"},
  {"is_type", "is_type(Term)", "is_type-1"},
  {"join", "join(Relation1, I, Relation2, J)", "join-4"},
  {"multiple_relative_product", "multiple_relative_product(TupleOfBinRels, BinRel1)", "multiple_relative_product-2"},
  {"no_elements", "no_elements(ASet)", "no_elements-1"},
  {"partition", "partition(SetOfSets)", "partition-1"},
  {"partition", "partition(SetFun, Set)", "partition-2"},
  {"partition", "partition(SetFun, Set1, Set2)", "partition-3"},
  {"partition_family", "partition_family(SetFun, Set)", "partition_family-2"},
  {"product", "product(TupleOfSets)", "product-1"},
  {"product", "product(Set1, Set2)", "product-2"},
  {"projection", "projection(SetFun, Set1)", "projection-2"},
  {"range", "range(BinRel)", "range-1"},
  {"relation", "relation(Tuples)", "relation-1"},
  {"relation", "relation(Tuples, Type)", "relation-2"},
  {"relation_to_family", "relation_to_family(BinRel)", "relation_to_family-1"},
  {"relative_product", "relative_product(ListOfBinRels)", "relative_product-1"},
  {"relative_product", "relative_product(ListOfBinRels, BinRel1)", "relative_product-2"},
  {"relative_product", "relative_product(BinRel1, BinRel2)", "relative_product-2"},
  {"relative_product1", "relative_product1(BinRel1, BinRel2)", "relative_product1-2"},
  {"restriction", "restriction(BinRel1, Set)", "restriction-2"},
  {"restriction", "restriction(SetFun, Set1, Set2)", "restriction-3"},
  {"set", "set(Terms)", "set-1"},
  {"set", "set(Terms, Type)", "set-2"},
  {"specification", "specification(Fun, Set1)", "specification-2"},
  {"strict_relation", "strict_relation(BinRel1)", "strict_relation-1"},
  {"substitution", "substitution(SetFun, Set1)", "substitution-2"},
  {"symdiff", "symdiff(Set1, Set2)", "symdiff-2"},
  {"symmetric_partition", "symmetric_partition(Set1, Set2)", "symmetric_partition-2"},
  {"to_external", "to_external(AnySet)", "to_external-1"},
  {"to_sets", "to_sets(ASet)", "to_sets-1"},
  {"type", "type(AnySet)", "type-1"},
  {"union", "union(SetOfSets)", "union-1"},
  {"union", "union(Set1, Set2)", "union-2"},
  {"union_of_family", "union_of_family(Family)", "union_of_family-1"},
  {"weak_relation", "weak_relation(BinRel1)", "weak_relation-1"}
]}.
{"sofs.html", {module, "stdlib"}, ["sofs"]}.
{"string.html", {function, {"stdlib", "string"}},
[
  {"casefold", "casefold(String :: unicode:chardata())", "casefold-1"},
  {"chomp", "chomp(String :: unicode:chardata())", "chomp-1"},
  {"equal", "equal(A, B)", "equal-2"},
  {"equal", "equal(A, B, IgnoreCase)", "equal-3"},
  {"equal", "equal(A, B, IgnoreCase, Norm)", "equal-4"},
  {"find", "find(String, SearchPattern)", "find-2"},
  {"find", "find(String, SearchPattern, Dir)", "find-3"},
  {"is_empty", "is_empty(String :: unicode:chardata())", "is_empty-1"},
  {"length", "length(String :: unicode:chardata())", "length-1"},
  {"lexemes", "lexemes(String :: unicode:chardata(),SeparatorList :: [grapheme_cluster()])", "lexemes-2"},
  {"lowercase", "lowercase(String :: unicode:chardata())", "lowercase-1"},
  {"next_codepoint", "next_codepoint(String :: unicode:chardata())", "next_codepoint-1"},
  {"next_grapheme", "next_grapheme(String :: unicode:chardata())", "next_grapheme-1"},
  {"nth_lexeme", "nth_lexeme(String, N, SeparatorList)", "nth_lexeme-3"},
  {"pad", "pad(String, Length)", "pad-2"},
  {"pad", "pad(String, Length, Dir)", "pad-3"},
  {"pad", "pad(String, Length, Dir, Char)", "pad-4"},
  {"prefix", "prefix(String :: unicode:chardata(), Prefix :: unicode:chardata())", "prefix-2"},
  {"replace", "replace(String, SearchPattern, Replacement)", "replace-3"},
  {"replace", "replace(String, SearchPattern, Replacement, Where)", "replace-4"},
  {"reverse", "reverse(String :: unicode:chardata())", "reverse-1"},
  {"slice", "slice(String, Start)", "slice-2"},
  {"slice", "slice(String, Start, Length)", "slice-3"},
  {"split", "split(String, SearchPattern)", "split-2"},
  {"split", "split(String, SearchPattern, Where)", "split-3"},
  {"take", "take(String, Characters)", "take-2"},
  {"take", "take(String, Characters, Complement)", "take-3"},
  {"take", "take(String, Characters, Complement, Dir)", "take-4"},
  {"titlecase", "titlecase(String :: unicode:chardata())", "titlecase-1"},
  {"to_float", "to_float(String)", "to_float-1"},
  {"to_integer", "to_integer(String)", "to_integer-1"},
  {"to_graphemes", "to_graphemes(String :: unicode:chardata())", "to_graphemes-1"},
  {"trim", "trim(String)", "trim-1"},
  {"trim", "trim(String, Dir)", "trim-2"},
  {"trim", "trim(String, Dir, Characters)", "trim-3"},
  {"uppercase", "uppercase(String :: unicode:chardata())", "uppercase-1"},
  {"centre", "centre(String, Number)", "centre-2"},
  {"centre", "centre(String, Number, Character)", "centre-3"},
  {"chars", "chars(Character, Number)", "chars-2"},
  {"chars", "chars(Character, Number, Tail)", "chars-3"},
  {"chr", "chr(String, Character)", "chr-2"},
  {"concat", "concat(String1, String2)", "concat-2"},
  {"copies", "copies(String, Number)", "copies-2"},
  {"cspan", "cspan(String, Chars)", "cspan-2"},
  {"join", "join(StringList, Separator)", "join-2"},
  {"left", "left(String, Number)", "left-2"},
  {"left", "left(String, Number, Character)", "left-3"},
  {"len", "len(String)", "len-1"},
  {"rchr", "rchr(String, Character)", "rchr-2"},
  {"right", "right(String, Number)", "right-2"},
  {"right", "right(String, Number, Character)", "right-3"},
  {"rstr", "rstr(String, SubString)", "rstr-2"},
  {"span", "span(String, Chars)", "span-2"},
  {"str", "str(String, SubString)", "str-2"},
  {"strip", "strip(String :: string())", "strip-1"},
  {"strip", "strip(String, Direction)", "strip-2"},
  {"strip", "strip(String, Direction, Character)", "strip-3"},
  {"sub_string", "sub_string(String, Start)", "sub_string-2"},
  {"sub_string", "sub_string(String, Start, Stop)", "sub_string-3"},
  {"substr", "substr(String, Start)", "substr-2"},
  {"substr", "substr(String, Start, Length)", "substr-3"},
  {"sub_word", "sub_word(String, Number)", "sub_word-2"},
  {"sub_word", "sub_word(String, Number, Character)", "sub_word-3"},
  {"to_lower", "to_lower(String)", "to_lower-1"},
  {"to_lower", "to_lower(Char)", "to_lower-1"},
  {"to_upper", "to_upper(String)", "to_upper-1"},
  {"to_upper", "to_upper(Char)", "to_upper-1"},
  {"tokens", "tokens(String, SeparatorList)", "tokens-2"},
  {"words", "words(String)", "words-1"},
  {"words", "words(String, Character)", "words-2"}
]}.
{"string.html", {module, "stdlib"}, ["string"]}.
{"supervisor.html", {function, {"stdlib", "supervisor"}},
[
  {"check_childspecs", "check_childspecs(ChildSpecs)", "check_childspecs-1"},
  {"count_children", "count_children(SupRef)", "count_children-1"},
  {"delete_child", "delete_child(SupRef, Id)", "delete_child-2"},
  {"get_childspec", "get_childspec(SupRef, Id)", "get_childspec-2"},
  {"restart_child", "restart_child(SupRef, Id)", "restart_child-2"},
  {"start_child", "start_child(SupRef, ChildSpec)", "start_child-2"},
  {"start_link", "start_link(Module, Args)", "start_link-2"},
  {"start_link", "start_link(SupName, Module, Args)", "start_link-3"},
  {"terminate_child", "terminate_child(SupRef, Id)", "terminate_child-2"},
  {"which_children", "which_children(SupRef)", "which_children-1"},
  {"Module:init", "Module:init(Args)", "Module:init-1"}
]}.
{"supervisor.html", {module, "stdlib"}, ["supervisor"]}.
{"supervisor_bridge.html", {function, {"stdlib", "supervisor_bridge"}},
[
  {"start_link", "start_link(Module, Args)", "start_link-2"},
  {"start_link", "start_link(SupBridgeName, Module, Args)", "start_link-3"},
  {"Module:init", "Module:init(Args)", "Module:init-1"},
  {"Module:terminate", "Module:terminate(Reason, State)", "Module:terminate"}
]}.
{"supervisor_bridge.html", {module, "stdlib"}, ["supervisor_bridge"]}.
{"sys.html", {function, {"stdlib", "sys"}},
[
  {"change_code", "change_code(Name, Module, OldVsn, Extra)", "change_code-4"},
  {"change_code", "change_code(Name, Module, OldVsn, Extra, Timeout)", "change_code-5"},
  {"get_state", "get_state(Name)", "get_state-1"},
  {"get_state", "get_state(Name, Timeout)", "get_state-2"},
  {"get_status", "get_status(Name)", "get_status-1"},
  {"get_status", "get_status(Name, Timeout)", "get_status-2"},
  {"install", "install(Name, FuncSpec)", "install-2"},
  {"install", "install(Name, FuncSpec, Timeout)", "install-3"},
  {"log", "log(Name, Flag)", "log-2"},
  {"log", "log(Name, Flag, Timeout)", "log-3"},
  {"log_to_file", "log_to_file(Name, Flag)", "log_to_file-2"},
  {"log_to_file", "log_to_file(Name, Flag, Timeout)", "log_to_file-3"},
  {"no_debug", "no_debug(Name)", "no_debug-1"},
  {"no_debug", "no_debug(Name, Timeout)", "no_debug-2"},
  {"remove", "remove(Name, FuncOrFuncId :: Func | FuncId)", "remove-2"},
  {"remove", "remove(Name, FuncOrFuncId :: Func | FuncId, Timeout)", "remove-3"},
  {"replace_state", "replace_state(Name, StateFun)", "replace_state-2"},
  {"replace_state", "replace_state(Name, StateFun, Timeout)", "replace_state-3"},
  {"resume", "resume(Name)", "resume-1"},
  {"resume", "resume(Name, Timeout)", "resume-2"},
  {"statistics", "statistics(Name, Flag)", "statistics-2"},
  {"statistics", "statistics(Name, Flag, Timeout)", "statistics-3"},
  {"suspend", "suspend(Name)", "suspend-1"},
  {"suspend", "suspend(Name, Timeout)", "suspend-2"},
  {"terminate", "terminate(Name, Reason)", "terminate-2"},
  {"terminate", "terminate(Name, Reason, Timeout)", "terminate-3"},
  {"trace", "trace(Name, Flag)", "trace-2"},
  {"trace", "trace(Name, Flag, Timeout)", "trace-3"},
  {"debug_options", "debug_options(Options :: [Opt :: debug_option()])", "debug_options-1"},
  {"get_debug", "get_debug(Item, Debug, Default)", "get_debug-3"},
  {"handle_debug", "handle_debug(Debug, FormFunc, Extra, Event)", "handle_debug-4"},
  {"handle_system_msg", "handle_system_msg(Msg, From, Parent, Module, Debug, Misc)", "handle_system_msg-6"},
  {"print_log", "print_log(Debug)", "print_log-1"},
  {"get_log", "get_log(Debug)", "get_log-1"},
  {"Module:system_code_change", "Module:system_code_change(Misc, Module, OldVsn, Extra)", "Module:system_code_change-4"},
  {"Module:system_continue", "Module:system_continue(Parent, Debug, Misc)", "Module:system_continue-3"},
  {"Module:system_get_state", "Module:system_get_state(Misc)", "Module:system_get_state-1"},
  {"Module:system_replace_state", "Module:system_replace_state(StateFun, Misc)", "Module:system_replace_state-2"},
  {"Module:system_terminate", "Module:system_terminate(Reason, Parent, Debug, Misc)", "Module:system_terminate-4"}
]}.
{"sys.html", {module, "stdlib"}, ["sys"]}.
{"timer.html", {function, {"stdlib", "timer"}},
[
  {"apply_after", "apply_after(Time, Module, Function, Arguments)", "apply_after-4"},
  {"apply_interval", "apply_interval(Time, Module, Function, Arguments)", "apply_interval-4"},
  {"cancel", "cancel(TRef)", "cancel-1"},
  {"exit_after", "exit_after(Time, Reason1)", "exit_after-2"},
  {"exit_after", "exit_after(Time, Pid, Reason1)", "exit_after-3"},
  {"hms", "hms(Hours, Minutes, Seconds)", "hms-3"},
  {"hours", "hours(Hours)", "hours-1"},
  {"kill_after", "kill_after(Time)", "kill_after-1"},
  {"kill_after", "kill_after(Time, Pid)", "kill_after-2"},
  {"minutes", "minutes(Minutes)", "minutes-1"},
  {"now_diff", "now_diff(T2, T1)", "now_diff-2"},
  {"seconds", "seconds(Seconds)", "seconds-1"},
  {"send_after", "send_after(Time, Message)", "send_after-2"},
  {"send_after", "send_after(Time, Pid, Message)", "send_after-3"},
  {"send_interval", "send_interval(Time, Message)", "send_interval-2"},
  {"send_interval", "send_interval(Time, Pid, Message)", "send_interval-3"},
  {"sleep", "sleep(Time)", "sleep-1"},
  {"start", "start()", "start-0"},
  {"tc", "tc(Fun)", "tc-1"},
  {"tc", "tc(Fun, Arguments)", "tc-2"},
  {"tc", "tc(Module, Function, Arguments)", "tc-3"}
]}.
{"timer.html", {module, "stdlib"}, ["timer"]}.
{"unicode.html", {function, {"stdlib", "unicode"}},
[
  {"bom_to_encoding", "bom_to_encoding(Bin)", "bom_to_encoding-1"},
  {"characters_to_binary", "characters_to_binary(Data)", "characters_to_binary-1"},
  {"characters_to_binary", "characters_to_binary(Data, InEncoding)", "characters_to_binary-2"},
  {"characters_to_binary", "characters_to_binary(Data, InEncoding, OutEncoding)", "characters_to_binary-3"},
  {"characters_to_list", "characters_to_list(Data)", "characters_to_list-1"},
  {"characters_to_list", "characters_to_list(Data, InEncoding)", "characters_to_list-2"},
  {"characters_to_nfc_list", "characters_to_nfc_list(CD :: chardata())", "characters_to_nfc_list-1"},
  {"characters_to_nfc_binary", "characters_to_nfc_binary(CD :: chardata())", "characters_to_nfc_binary-1"},
  {"characters_to_nfd_list", "characters_to_nfd_list(CD :: chardata())", "characters_to_nfd_list-1"},
  {"characters_to_nfd_binary", "characters_to_nfd_binary(CD :: chardata())", "characters_to_nfd_binary-1"},
  {"characters_to_nfkc_list", "characters_to_nfkc_list(CD :: chardata())", "characters_to_nfkc_list-1"},
  {"characters_to_nfkc_binary", "characters_to_nfkc_binary(CD :: chardata())", "characters_to_nfkc_binary-1"},
  {"characters_to_nfkd_list", "characters_to_nfkd_list(CD :: chardata())", "characters_to_nfkd_list-1"},
  {"characters_to_nfkd_binary", "characters_to_nfkd_binary(CD :: chardata())", "characters_to_nfkd_binary-1"},
  {"encoding_to_bom", "encoding_to_bom(InEncoding)", "encoding_to_bom-1"}
]}.
{"unicode.html", {module, "stdlib"}, ["unicode"]}.
{"uri_string.html", {function, {"stdlib", "uri_string"}},
[
  {"compose_query", "compose_query(QueryList)", "compose_query-1"},
  {"compose_query", "compose_query(QueryList, Options)", "compose_query-2"},
  {"dissect_query", "dissect_query(QueryString)", "dissect_query-1"},
  {"normalize", "normalize(URI)", "normalize-1"},
  {"normalize", "normalize(URI, Options)", "normalize-2"},
  {"parse", "parse(URIString)", "parse-1"},
  {"recompose", "recompose(URIMap)", "recompose-1"},
  {"transcode", "transcode(URIString, Options)", "transcode-2"}
]}.
{"uri_string.html", {module, "stdlib"}, ["uri_string"]}.
{"win32reg.html", {function, {"stdlib", "win32reg"}},
[
  {"change_key", "change_key(RegHandle, Key)", "change_key-2"},
  {"change_key_create", "change_key_create(RegHandle, Key)", "change_key_create-2"},
  {"close", "close(RegHandle)", "close-1"},
  {"current_key", "current_key(RegHandle)", "current_key-1"},
  {"delete_key", "delete_key(RegHandle)", "delete_key-1"},
  {"delete_value", "delete_value(RegHandle, Name)", "delete_value-2"},
  {"expand", "expand(String)", "expand-1"},
  {"format_error", "format_error(ErrorId)", "format_error-1"},
  {"open", "open(OpenModeList)", "open-1"},
  {"set_value", "set_value(RegHandle, Name, Value)", "set_value-3"},
  {"sub_keys", "sub_keys(RegHandle)", "sub_keys-1"},
  {"value", "value(RegHandle, Name)", "value-2"},
  {"values", "values(RegHandle)", "values-1"}
]}.
{"win32reg.html", {module, "stdlib"}, ["win32reg"]}.
{"zip.html", {function, {"stdlib", "zip"}},
[
  {"foldl", "foldl(Fun, Acc0, Archive)", "foldl-3"},
  {"list_dir", "list_dir(Archive)", "list_dir-1"},
  {"list_dir", "list_dir(Archive, Options)", "list_dir-2"},
  {"table", "table(Archive)", "table-1"},
  {"table", "table(Archive, Options)", "table-2"},
  {"t", "t(Archive)", "t-1"},
  {"tt", "tt(Archive)", "tt-1"},
  {"unzip", "unzip(Archive)", "unzip-1"},
  {"unzip", "unzip(Archive, Options)", "unzip-2"},
  {"extract", "extract(Archive)", "extract-1"},
  {"extract", "extract(Archive, Options)", "extract-2"},
  {"zip", "zip(Name, FileList)", "zip-2"},
  {"zip", "zip(Name, FileList, Options)", "zip-3"},
  {"create", "create(Name, FileList)", "create-2"},
  {"create", "create(Name, FileList, Options)", "create-3"},
  {"zip_close", "zip_close(ZipHandle)", "zip_close-1"},
  {"zip_get", "zip_get(ZipHandle)", "zip_get-1"},
  {"zip_get", "zip_get(FileName, ZipHandle)", "zip_get-2"},
  {"zip_list_dir", "zip_list_dir(ZipHandle)", "zip_list_dir-1"},
  {"zip_open", "zip_open(Archive)", "zip_open-1"},
  {"zip_open", "zip_open(Archive, Options)", "zip_open-2"}
]}.
{"zip.html", {module, "stdlib"}, ["zip"]}.
{notused, application, ["stdlib"]}.
