diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..d791bb8 --- /dev/null +++ b/.clang-format @@ -0,0 +1,24 @@ +# Linux kernel style +BasedOnStyle: LLVM +IndentWidth: 8 +UseTab: Always +AlignAfterOpenBracket: true +AlignEscapedNewlinesLeft: false +AlignTrailingComments: true +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortFunctionsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakBeforeMultilineStrings: true +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeBraces: Linux +BreakStringLiterals: false +ContinuationIndentWidth: 8 +IndentCaseLabels: false +MaxEmptyLinesToKeep: 2 +SortIncludes: false + +# Custom +DerivePointerAlignment: false +PointerAlignment: Left +SpaceAfterCStyleCast: true diff --git a/ext/nicehash b/ext/nicehash index da9f3a0..71152e7 160000 --- a/ext/nicehash +++ b/ext/nicehash @@ -1 +1 @@ -Subproject commit da9f3a02644f7bd7fc24ad29832c289460854eae +Subproject commit 71152e7ed6e4b1e59d1eac7f583d8e3830632973 diff --git a/lib/nicehash b/lib/nicehash index e69bf48..386a7b6 120000 --- a/lib/nicehash +++ b/lib/nicehash @@ -1 +1 @@ -../ext/nicehash/src/main/c \ No newline at end of file +../ext/nicehash/src \ No newline at end of file diff --git a/notes/code/double-underscore-files.md b/notes/code/double-underscore-files.md deleted file mode 100644 index e7d7d8d..0000000 --- a/notes/code/double-underscore-files.md +++ /dev/null @@ -1,8 +0,0 @@ -# Double underscore files - -## __main__.c - -- Provide initialise function -- Include all sources for easy usage (single usage) - -## __base__.c diff --git a/notes/code/scope-naming.md b/notes/code/scope-naming.md new file mode 100644 index 0000000..7eaaf3b --- /dev/null +++ b/notes/code/scope-naming.md @@ -0,0 +1,22 @@ +# Scope naming + +## Public + +```c +int hb_sub_function_name(int a, int b); +``` + +## Internal use only + +Used across multiple files but should only be used by this project's code. + +```c +int _hb_sub_function_name(int a, int b); +``` + +## Within same file only + +```c +// Don't declare in header file +static int _function_name(int a, int b) {} +``` diff --git a/src/__main__.c b/src/__main__.c deleted file mode 100644 index 3ff07a1..0000000 --- a/src/__main__.c +++ /dev/null @@ -1,4 +0,0 @@ -void hb_init(void) { - // Set up rules - hbr_init(); -} diff --git a/src/cli.c b/src/cli.c deleted file mode 100644 index 928f111..0000000 --- a/src/cli.c +++ /dev/null @@ -1,142 +0,0 @@ -#include -#include "./stream/content/html.c" -#include "./__main__.c" - -int main(int argc, char **argv) { - hb_init(); - - hbe_err_t err = NULL; - hbe_err_t *hbe_err = &err; - - hbu_fstreamout_t output = NULL; - hbu_list_char_t output_buffer = NULL; - - // Prepare config - char *input_path = NULL; - char *output_path = NULL; - int logging = 0; - int config_keep = 0; - int config_buffer = 0; - hbu_streamoptions_t config_stream = hbu_streamoptions_create(); - - int nondefault_ex_collapse_whitespace = 0; - int nondefault_ex_destroy_whole_whitespace = 0; - int nondefault_ex_trim_whitespace = 0; - - // Parse arguments - while (1) { - struct option long_options[] = { - {"keep", no_argument, &config_keep, 1}, - {"buffer", no_argument, &config_buffer, 1}, - {"verbose", no_argument, &logging, 1}, - {"input", required_argument, NULL, 'i'}, - {"output", required_argument, NULL, 'o'}, - {"suppress", required_argument, NULL, 's'}, - - {"MXcollapseWhitespace", optional_argument, NULL, 40}, - {"MXdestroyWholeWhitespace", optional_argument, NULL, 41}, - {"MXtrimWhitespace", optional_argument, NULL, 42}, - - {"MXtrimClassAttr", no_argument, &(config_stream->trim_class_attr), 0}, - {"MXdecEnt", no_argument, &(config_stream->decode_entities), 0}, - {"MXcondComments", no_argument, &(config_stream->min_conditional_comments), 0}, - {"MXattrQuotes", no_argument, &(config_stream->decode_entities), 0}, - {"MXcomments", no_argument, &(config_stream->remove_comments), 0}, - {"MXoptTags", no_argument, &(config_stream->remove_optional_tags), 0}, - {"MXtagWS", no_argument, &(config_stream->remove_tag_whitespace), 0}, - - {0, 0, 0, 0} - }; - - int option_index = 0; - int c = getopt_long(argc, argv, "kbvi:o:s:", long_options, &option_index); - - if (c == -1) { - if (optind != argc) { - HBE_THROW_F(HBE_CLI_TOO_MANY_OPTIONS, "Too many arguments provided"); - } - break; - } - - switch (c) { - case 'i': - input_path = optarg; - break; - - case 'o': - output_path = optarg; - break; - - case 's': - HBE_CATCH_F(hbu_streamoptions_parse_and_add_errors_to_suppress, config_stream->suppressed_errors, optarg); - break; - - case 40: - nondefault_ex_collapse_whitespace = 1; - config_stream->ex_collapse_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); - break; - - case 41: - nondefault_ex_destroy_whole_whitespace = 1; - config_stream->ex_destroy_whole_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); - break; - - case 42: - nondefault_ex_trim_whitespace = 1; - config_stream->ex_trim_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); - break; - } - } - - if (!nondefault_ex_collapse_whitespace) config_stream->ex_collapse_whitespace = hbu_streamoptions_default_ex_collapse_whitespace(); - if (!nondefault_ex_destroy_whole_whitespace) config_stream->ex_destroy_whole_whitespace = hbu_streamoptions_default_ex_destroy_whole_whitespace(); - if (!nondefault_ex_trim_whitespace) config_stream->ex_trim_whitespace = hbu_streamoptions_default_ex_trim_whitespace(); - - if (logging) { - hbl_info_kv_string("Input", input_path); - hbl_info_kv_string("Output", output_path); - hbl_info_kv_boolean("Buffer output until success", config_buffer); - hbl_info_kv_boolean("Keep output file on error", config_keep); - hbu_streamoptions_log(config_stream); - } - - hbu_pipe_t pipe = hbu_pipe_create_blank(input_path); - - hbu_fstreamin_t input = HBE_CATCH_F(hbu_fstreamin_create, input_path); - hbu_pipe_blank_set_input_fstreamin(pipe, input); - - if (config_buffer) { - output_buffer = hbu_list_char_create(); - hbu_pipe_blank_set_output_buffer(pipe, output_buffer); - } else { - output = HBE_CATCH_F(hbu_fstreamout_create, output_path); - hbu_pipe_blank_set_output_fstreamout(pipe, output); - } - - HBE_CATCH_F(hbs_content, config_stream, pipe, NULL); - - if (config_buffer) { - output = HBE_CATCH_F(hbu_fstreamout_create, output_path); - HBE_CATCH_F(hbu_fstreamout_write_buffer, output, output_buffer); - } - - finally: - if (err != NULL) { - hbl_error(err); - if (output != NULL && !config_keep && !config_buffer) { - // Delete only after opening output stream (don't delete before existing file has not been touched) - // Don't need to set if $config_buffer, as it won't write anything anyway - if (unlink(output_path)) { - hbl_log(HBL_LOG_WARN, "Failed to delete file %s with error %d", output_path, errno); - } else { - hbl_log(HBL_LOG_INFO, "%s has been deleted", output_path); - } - } - exit(err->code); - } - - if (logging) { - hbl_log(HBL_LOG_INFO, "All done!"); - } - exit(0); -} diff --git a/src/hb-cli.c b/src/hb-cli.c new file mode 100644 index 0000000..9e09fa0 --- /dev/null +++ b/src/hb-cli.c @@ -0,0 +1,270 @@ +#pragma once + +#include +#include "./stream/content/html.c" +#include "./__main__.c" + +nh_set_str_t hbu_streamoptions_parse_list_of_tags(hbe_err_t *hbe_err, char *argv) { + nh_set_str_t set = NULL; + hb_list_charlist_t list = NULL; + + if (argv != NULL && strcmp(argv, "*")) { + return NULL; + } + + set = nh_set_str_create(); + + if (argv == NULL) { + return set; + } + + list = hb_list_charlist_create_from_split((hb_proc_char_t *) argv, ','); + + for (size_t i = 0; i < list->length; i++) { + hb_list_char_t part = hb_list_charlist_get(list, i); + hb_proc_char_t *part_c = hb_list_char_underlying(part); + + if (hb_list_char_get(part, 0) == '$') { + // Set of tags + hb_list_char_shift(part); + HBE_CATCH_F(hbu_streamoptions_parse_and_add_tag_set, (char *) part_c, set); + + } else { + // Single tag + if (!hb_rule_tags_check(part_c)) { + HBE_THROW_F(HBE_CLI_INVALID_TAG, "%s is not a standard tag and was provided as part of an argument's value", part_c); + } + nh_set_str_add(set, (char *) hb_list_char_underlying_copy(part)); + } + } + + finally: + if (list != NULL) { + hb_list_charlist_destroy_from_split(list); + list = NULL; + } + if (*hbe_err != NULL) { + if (set != NULL) { + nh_set_str_destroy(set); + set = NULL; + } + } + return set; +} + + + +void hbu_streamoptions_parse_and_add_errors_to_suppress(hbe_err_t *hbe_err, nh_set_int32_t suppressed_errors, char *argv) { + hb_list_charlist_t list = NULL; + + if (argv == NULL) { + return; + } + + list = hb_list_charlist_create_from_split((hb_proc_char_t *) argv, ','); + + for (size_t i = 0; i < list->length; i++) { + hb_list_char_t part = hb_list_charlist_get(list, i); + + if (hb_list_char_compare_lit(part, "MALFORMED_ENTITY") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_MALFORMED_ENTITY); + } else if (hb_list_char_compare_lit(part, "BARE_AMPERSAND") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_BARE_AMPERSAND); + } else if (hb_list_char_compare_lit(part, "INVALID_ENTITY") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_INVALID_ENTITY); + } else if (hb_list_char_compare_lit(part, "NONSTANDARD_TAG") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_NONSTANDARD_TAG); + } else if (hb_list_char_compare_lit(part, "UCASE_ATTR") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_UCASE_ATTR); + } else if (hb_list_char_compare_lit(part, "UCASE_TAG") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_UCASE_TAG); + } else if (hb_list_char_compare_lit(part, "UNQUOTED_ATTR") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_UNQUOTED_ATTR); + } else if (hb_list_char_compare_lit(part, "SELF_CLOSING_TAG") == 0) { + nh_set_int32_add(suppressed_errors, HBE_PARSE_SELF_CLOSING_TAG); + } else { + HBE_THROW_F(HBE_CLI_INVALID_SUPPRESSABLE_ERROR, "Unrecognised suppressable error `%s`", hb_list_char_underlying(part)); + } + } + + finally: + if (list != NULL) { + hb_list_charlist_destroy_from_split(list); + list = NULL; + } +} + +void hbu_streamoptions_log(hbu_streamoptions_t opt) { + hbl_info_kv_boolean("Trim `class` attributes", opt->trim_class_attr); + hbl_info_kv_boolean("Decode entities", opt->decode_entities); + hbl_info_kv_boolean("Minify conditional comments", opt->min_conditional_comments); + hbl_info_kv_boolean("Remove attribute quotes", opt->remove_attr_quotes); + hbl_info_kv_boolean("Remove comments", opt->remove_comments); + hbl_info_kv_boolean("Remove optional tags", opt->remove_optional_tags); + hbl_info_kv_boolean("Remove tag whitespace", opt->remove_tag_whitespace); +} + +void hbu_streamoptions_parse_and_add_tag_set(hbe_err_t *hbe_err, char *set_name, nh_set_str_t set) { + if (strcmp(set_name, "content") == 0) { + hb_rule_contenttags_add_elems(set); + } else if (strcmp(set_name, "contentfirst") == 0) { + hb_rule_contentfirsttags_add_elems(set); + } else if (strcmp(set_name, "formatting") == 0) { + hb_rule_formattingtags_add_elems(set); + } else if (strcmp(set_name, "layout") == 0) { + hb_rule_layouttags_add_elems(set); + } else if (strcmp(set_name, "specific") == 0) { + hb_rule_specifictags_add_elems(set); + } else if (strcmp(set_name, "heading") == 0) { + hb_rule_headingtags_add_elems(set); + } else if (strcmp(set_name, "media") == 0) { + hb_rule_mediatags_add_elems(set); + } else if (strcmp(set_name, "sectioning") == 0) { + hb_rule_sectioningtags_add_elems(set); + } else if (strcmp(set_name, "void") == 0) { + hb_rule_voidtags_add_elems(set); + } else if (strcmp(set_name, "wss") == 0) { + hb_rule_wsstags_add_elems(set); + } else { + HBE_THROW_V(HBE_CLI_INVALID_TAG_SET, "Unrecognised tag set `%s`", set_name); + } +} + +int main(int argc, char **argv) { + hb_init(); + + hbe_err_t err = NULL; + hbe_err_t *hbe_err = &err; + + hbu_fstreamout_t output = NULL; + hb_list_char_t output_buffer = NULL; + + // Prepare config + char *input_path = NULL; + char *output_path = NULL; + int logging = 0; + int config_keep = 0; + int config_buffer = 0; + hbu_streamoptions_t config_stream = hbu_streamoptions_create(); + + int nondefault_ex_collapse_whitespace = 0; + int nondefault_ex_destroy_whole_whitespace = 0; + int nondefault_ex_trim_whitespace = 0; + + // Parse arguments + while (1) { + struct option long_options[] = { + {"keep", no_argument, &config_keep, 1}, + {"buffer", no_argument, &config_buffer, 1}, + {"verbose", no_argument, &logging, 1}, + {"input", required_argument, NULL, 'i'}, + {"output", required_argument, NULL, 'o'}, + {"suppress", required_argument, NULL, 's'}, + + {"MXcollapseWhitespace", optional_argument, NULL, 40}, + {"MXdestroyWholeWhitespace", optional_argument, NULL, 41}, + {"MXtrimWhitespace", optional_argument, NULL, 42}, + + {"MXtrimClassAttr", no_argument, &(config_stream->trim_class_attr), 0}, + {"MXdecEnt", no_argument, &(config_stream->decode_entities), 0}, + {"MXcondComments", no_argument, &(config_stream->min_conditional_comments), 0}, + {"MXattrQuotes", no_argument, &(config_stream->decode_entities), 0}, + {"MXcomments", no_argument, &(config_stream->remove_comments), 0}, + {"MXoptTags", no_argument, &(config_stream->remove_optional_tags), 0}, + {"MXtagWS", no_argument, &(config_stream->remove_tag_whitespace), 0}, + + {0, 0, 0, 0} + }; + + int option_index = 0; + int c = getopt_long(argc, argv, "kbvi:o:s:", long_options, &option_index); + + if (c == -1) { + if (optind != argc) { + HBE_THROW_F(HBE_CLI_TOO_MANY_OPTIONS, "Too many arguments provided"); + } + break; + } + + switch (c) { + case 'i': + input_path = optarg; + break; + + case 'o': + output_path = optarg; + break; + + case 's': + HBE_CATCH_F(hbu_streamoptions_parse_and_add_errors_to_suppress, config_stream->suppressed_errors, optarg); + break; + + case 40: + nondefault_ex_collapse_whitespace = 1; + config_stream->ex_collapse_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); + break; + + case 41: + nondefault_ex_destroy_whole_whitespace = 1; + config_stream->ex_destroy_whole_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); + break; + + case 42: + nondefault_ex_trim_whitespace = 1; + config_stream->ex_trim_whitespace = HBE_CATCH_F(hbu_streamoptions_parse_list_of_tags, optarg); + break; + } + } + + if (!nondefault_ex_collapse_whitespace) config_stream->ex_collapse_whitespace = hbu_streamoptions_default_ex_collapse_whitespace(); + if (!nondefault_ex_destroy_whole_whitespace) config_stream->ex_destroy_whole_whitespace = hbu_streamoptions_default_ex_destroy_whole_whitespace(); + if (!nondefault_ex_trim_whitespace) config_stream->ex_trim_whitespace = hbu_streamoptions_default_ex_trim_whitespace(); + + if (logging) { + hbl_info_kv_string("Input", input_path); + hbl_info_kv_string("Output", output_path); + hbl_info_kv_boolean("Buffer output until success", config_buffer); + hbl_info_kv_boolean("Keep output file on error", config_keep); + hbu_streamoptions_log(config_stream); + } + + hb_proc_t pipe = hb_proc_create_blank(input_path); + + hbu_fstreamin_t input = HBE_CATCH_F(hbu_fstreamin_create, input_path); + hb_proc_blank_set_input_fstreamin(pipe, input); + + if (config_buffer) { + output_buffer = hb_list_char_create(); + hb_proc_blank_set_output_buffer(pipe, output_buffer); + } else { + output = HBE_CATCH_F(hbu_fstreamout_create, output_path); + hb_proc_blank_set_output_fstreamout(pipe, output); + } + + HBE_CATCH_F(hbs_content, config_stream, pipe, NULL); + + if (config_buffer) { + output = HBE_CATCH_F(hbu_fstreamout_create, output_path); + HBE_CATCH_F(hbu_fstreamout_write_buffer, output, output_buffer); + } + + finally: + if (err != NULL) { + hbl_error(err); + if (output != NULL && !config_keep && !config_buffer) { + // Delete only after opening output stream (don't delete before existing file has not been touched) + // Don't need to set if $config_buffer, as it won't write anything anyway + if (unlink(output_path)) { + hbl_log(HBL_LOG_WARN, "Failed to delete file %s with error %d", output_path, errno); + } else { + hbl_log(HBL_LOG_INFO, "%s has been deleted", output_path); + } + } + exit(err->code); + } + + if (logging) { + hbl_log(HBL_LOG_INFO, "All done!"); + } + exit(0); +} diff --git a/src/hb-cli.h b/src/hb-cli.h new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/hb-cli.h @@ -0,0 +1 @@ + diff --git a/src/hb-config.c b/src/hb-config.c new file mode 100644 index 0000000..2a7d9cc --- /dev/null +++ b/src/hb-config.c @@ -0,0 +1,94 @@ +#pragma once + +#include +#include + +#include "hb-rule.h" +#include "hb-config.h" + +static struct hb_config_ex_s _ex_collapse_whitespace_default; +static struct hb_config_ex_s _ex_destroy_whole_whitespace_default; +static struct hb_config_ex_s _ex_trim_whitespace_default; + +// WARNING: Rules must be initialised before calling this function +void hb_config_init(void) +{ + nh_set_str ex_collapse_whitespace_set = nh_set_str_create(); + hb_rule_wsstags_add_elems(ex_collapse_whitespace_set); + _ex_collapse_whitespace_default = {HB_CONFIG_EX_MODE_DEFAULT, + ex_collapse_whitespace_set}; + + nh_set_str ex_destroy_whole_whitespace_set = nh_set_str_create(); + hb_rule_wsstags_add_elems(ex_destroy_whole_whitespace_set); + hb_rule_contenttags_add_elems(ex_destroy_whole_whitespace_set); + hb_rule_formattingtags_add_elems(ex_destroy_whole_whitespace_set); + _ex_destroy_whole_whitespace_default = { + HB_CONFIG_EX_MODE_DEFAULT, ex_destroy_whole_whitespace_set}; + + nh_set_str ex_trim_whitespace_set = nh_set_str_create(); + hb_rule_wsstags_add_elems(ex_trim_whitespace_set); + hb_rule_formattingtags_add_elems(ex_trim_whitespace_set); + _ex_trim_whitespace_default = {HB_CONFIG_EX_MODE_DEFAULT, + ex_trim_whitespace_set}; +} + +hb_config_t* hb_config_create(void) +{ + hb_config_t* config = malloc(sizeof(struct hb_config_s)); + config->ex_collapse_whitespace = _ex_collapse_whitespace_default; + config->ex_destroy_whole_whitespace = + _ex_destroy_whole_whitespace_default; + config->ex_trim_whitespace = _ex_trim_whitespace_default; + config->suppressed_errors = nh_set_int32_create(); + config->trim_class_attr = true; + config->decode_entities = true; + config->min_conditional_comments = true; + config->remove_attr_quotes = true; + config->remove_comments = true; + config->remove_optional_tags = true; + config->remove_tag_whitespace = true; + return config; +} + +void hb_config_ex_use_none(hb_config_ex_t* config_ex) +{ + *config_ex = {HB_CONFIG_EX_MODE_NONE, NULL}; +} + +void hb_config_ex_use_custom(hb_config_ex_t* config_ex, nh_set_str custom_set) +{ + *config_ex = {HB_CONFIG_EX_MODE_CUSTOM, custom_set}; +} + +void hb_config_ex_use_all(hb_config_ex_t* config_ex) +{ + *config_ex = {HB_CONFIG_EX_MODE_ALL}; +} + +void hb_config_destroy(hb_config_t* opt) +{ + nh_set_int32_destroy(opt->suppressed_errors); + free(opt); +} + +bool hb_config_supressed_error_check(hb_config_t opt, hb_error_t errcode) +{ + return nh_set_int32_has(&opt->suppressed_errors, errcode); +} + +bool hb_config_ex_check(hb_config_t* config, hb_proc_char_t* query) +{ + switch (config->mode) { + case HB_CONFIG_EX_MODE_ALL: + return true; + + case HB_CONFIG_EX_MODE_NONE: + return false; + + default: + return nh_set_str_has(config->set, query); + } + if (config->mode == HB_CONFIG_EX_MODE_ALL) { + return true; + } +} diff --git a/src/hb-config.h b/src/hb-config.h new file mode 100644 index 0000000..1aa21c9 --- /dev/null +++ b/src/hb-config.h @@ -0,0 +1,36 @@ +#pragma once + +typedef enum { + HB_CONFIG_EX_MODE_NONE, // i.e. minify all without exeption + HB_CONFIG_EX_MODE_DEFAULT, // entire struct will not be destroyed + HB_CONFIG_EX_MODE_CUSTOM, // set will be destroyed + HB_CONFIG_EX_MODE_ALL, // i.e. don't minify +} hb_config_ex_mode_t; + +typedef struct { + hb_config_ex_mode_t mode; + nh_set_str set; +} hb_config_ex_t; + +typedef struct { + hb_config_ex_t ex_collapse_whitespace; + hb_config_ex_t ex_destroy_whole_whitespace; + hb_config_ex_t ex_trim_whitespace; + nh_set_int32 suppressed_errors; + bool trim_class_attributes; + bool decode_entities; + bool remove_attr_quotes; + bool remove_comments; + bool remove_optional_tags; + bool remove_tag_whitespace; +} hb_config_t; + +// WARNING: Rules must be initialised before calling this function +void hb_config_init(void); +hb_config_t* hb_config_create(void); +void hb_config_ex_use_none(hb_config_ex_t* config_ex); +void hb_config_ex_use_custom(hb_config_ex_t* config_ex, nh_set_str custom_set); +void hb_config_ex_use_all(hb_config_ex_t* config_ex); +void hb_config_destroy(hb_config_t* opt); +bool hb_config_supressed_error_check(hb_config_t opt, hb_error_t errcode); +bool hb_config_ex_check(hb_config_ex_t* config, hb_proc_char_t* query); diff --git a/src/hb-data.h b/src/hb-data.h new file mode 100644 index 0000000..5b37586 --- /dev/null +++ b/src/hb-data.h @@ -0,0 +1,8 @@ +#include + +#include "nicehash/list.h" +#include "nicehash/list-ucp.h" +#include "nicehash/map-str.h" + +NH_MAP_STR(int32, int32_t); +NH_MAP_STR(set_str, nh_set_str*); diff --git a/src/hb-error.h b/src/hb-error.h new file mode 100644 index 0000000..eea13e3 --- /dev/null +++ b/src/hb-error.h @@ -0,0 +1,33 @@ +#pragma once + +typedef enum { + HBE_NO_ERROR = 0, + + HBE_INTERR_UNKNOWN_ENTITY_TYPE = 2, + HBE_INTERR_UNKNOWN_CONTENT_NEXT_STATE, + + HBE_CLI_TOO_MANY_OPTIONS = 17, + HBE_CLI_INVALID_TAG_SET, + HBE_CLI_INVALID_TAG, + HBE_CLI_INVALID_SUPPRESSABLE_ERROR, + + HBE_IO_FOPEN_FAIL = 33, + HBE_IO_FCLOSE_FAIL, + HBE_IO_FREAD_FAIL, + HBE_IO_FWRITE_FAIL, + + HBE_PARSE_MALFORMED_ENTITY = 65, + HBE_PARSE_BARE_AMPERSAND, + HBE_PARSE_INVALID_ENTITY, + HBE_PARSE_NONSTANDARD_TAG, + HBE_PARSE_UCASE_TAG, + HBE_PARSE_UCASE_ATTR, + HBE_PARSE_UNQUOTED_ATTR, + HBE_PARSE_ILLEGAL_CHILD, + HBE_PARSE_UNCLOSED_TAG, + HBE_PARSE_SELF_CLOSING_TAG, + HBE_PARSE_NO_SPACE_BEFORE_ATTR, + + HBE_PARSE_UNEXPECTED_END, + HBE_PARSE_EXPECTED_NOT_FOUND, +} hb_error_t; diff --git a/src/hb-file-in.c b/src/hb-file-in.c new file mode 100644 index 0000000..cfa365d --- /dev/null +++ b/src/hb-file-in.c @@ -0,0 +1,24 @@ +#include +#include "../char/char.c" +#include "../execution/error.c" +#include "./__base__.c" + +HBU_FSTREAM_BUILD_INFRA(in, "r", "read", "reading", stdin) + +hb_eod_char_t hbu_fstreamin_read(hbe_err_t* hbe_err, hbu_fstreamin_t fstreamin) +{ + hb_proc_char_t c; + + if (fread(&c, SIZEOF_CHAR, 1, fstreamin->fd) != SIZEOF_CHAR) { + if (ferror(fstreamin->fd)) { + HBE_THROW(HBE_IO_FREAD_FAIL, + "Failed to read input file %s", + fstreamin->name); + } + + // Must be EOF + return HB_EOD; + } + + return c; +} diff --git a/src/hb-file-out.c b/src/hb-file-out.c new file mode 100644 index 0000000..2a38029 --- /dev/null +++ b/src/hb-file-out.c @@ -0,0 +1,32 @@ +#include +#include "../execution/error.c" +#include "../list/char.c" +#include "./__base__.c" + +HBU_FSTREAM_BUILD_INFRA(out, "w", "write", "writing", stdout) + +static void _hbu_fstreamout_fwrite(hbe_err_t* hbe_err, + hbu_fstreamout_t fstreamout, + hb_proc_char_t* source, size_t length) +{ + if (fwrite(source, SIZEOF_CHAR, length, fstreamout->fd) + != SIZEOF_CHAR * length) { + HBE_THROW_V(HBE_IO_FWRITE_FAIL, + "Failed to write to output file %s", + fstreamout->name); + } +} + +void hbu_fstreamout_write_buffer(hbe_err_t* hbe_err, + hbu_fstreamout_t fstreamout, + hb_list_char_t buffer) +{ + HBE_CATCH_V(_hbu_fstreamout_fwrite, fstreamout, + hb_list_char_underlying(buffer), buffer->length); +} + +void hbu_fstreamout_write(hbe_err_t* hbe_err, hbu_fstreamout_t fstreamout, + hb_proc_char_t c) +{ + HBE_CATCH_V(_hbu_fstreamout_fwrite, fstreamout, &c, 1); +} diff --git a/src/hb-file.h b/src/hb-file.h new file mode 100644 index 0000000..d7bc8bf --- /dev/null +++ b/src/hb-file.h @@ -0,0 +1,51 @@ +#pragma once + +#include + +typedef enum { + HB_FILE_ENC_UTF_8, + HB_FILE_ENC_UTF_16, +} hb_file_enc_t; + +#define HB_FILE(type, mode, noun, verb, std) \ + typedef struct { \ + char const* name; \ + hb_file_enc_t encoding; \ + FILE* fd; \ + } hb_file_##type##_t; \ + \ + hb_file_##type##_t* hb_file_##type##_create(char* path) \ + { \ + hb_file_##type##_t* fstream = \ + malloc(sizeof(hb_file_##type##_t)); \ + \ + if (path == NULL) { \ + fstream->name = #std; \ + fstream->fd = std; \ + } else { \ + fstream->name = path; \ + \ + FILE* fd = fopen(path, mode); \ + \ + if (fd == NULL) { \ + return NULL; \ + } \ + \ + fstream->fd = fd; \ + } \ + \ + return fstream; \ + } \ + \ + void hb_file_##type##_destroy(hbe_err_t* hbe_err, \ + hb_file_##type##_t fstream) \ + { \ + if (fclose(fstream->fd) == EOF) { \ + HBE_THROW_V(HBE_IO_FCLOSE_FAIL, \ + "Failed to close " noun \ + " stream for file %s with error %d", \ + fstream->name, errno); \ + } \ + \ + free(fstream); \ + } diff --git a/src/hb-proc-accept.c b/src/hb-proc-accept.c new file mode 100644 index 0000000..1406c82 --- /dev/null +++ b/src/hb-proc-accept.c @@ -0,0 +1,144 @@ +/** + * Accepts the next character. + * Will cause an error if already at end. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return next character + * @throws on read/write error or HBE_PARSE_UNEXPECTED_END + */ +hb_proc_char_t hb_proc_accept(hbe_err_t *hbe_err, hb_proc_t pipe) { + hb_eod_char_t c = HBE_CATCH(_hb_proc_read_from_buffer_or_input, pipe); + + HBE_CATCH(_hb_proc_assert_not_eoi, c); + + _hb_proc_update_pos(pipe, c); + + HBE_CATCH(_hb_proc_write_to_output, pipe, c); + + return c; +} + +/** + * Accepts the next count characters. + * Requires at least count characters remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param count amount of characters + * @throws on read/write error or HBE_PARSE_UNEXPECTED_END + */ +void hb_proc_accept_count(hbe_err_t *hbe_err, hb_proc_t pipe, size_t count) { + for (size_t i = 0; i < count; i++) { + HBE_CATCH_V(hb_proc_accept, pipe); + } +} + +/** + * Accepts the following character if it is c. + * Won't match or cause an error if there are no characters remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param c character to match + * @return 0 if nothing was accepted, 1 otherwise + * @throws on read/write error + */ +int hb_proc_accept_if(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_char_t c) { + hb_eod_char_t n = HBE_CATCH(hb_proc_peek_eoi, pipe); + + if (n == HB_EOD || n != c) { + return 0; + } + + HBE_CATCH(hb_proc_accept, pipe); + + return 1; +} + +/** + * Accepts the following characters if they match match. + * Won't match or cause an error if there are not enough characters remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match characters to match + * @return 0 if nothing was accepted, 1 otherwise + * @throws on read/write error + */ +int hb_proc_accept_if_matches(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + size_t matchedlen = HBE_CATCH(hb_proc_matches, pipe, match); + + int matched = matchedlen > 0; + + if (matched) { + HBE_CATCH(hb_proc_accept_count, pipe, matchedlen); + } + + return matched; +} + +/** + * Accepts the following characters if they are either "\r", "\r\n", or "\n". + * Won't cause an error if insufficient amount of characters left. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return amount of characters matched + * @throws on read/write error + */ +size_t hb_proc_accept_if_matches_line_terminator(hbe_err_t *hbe_err, hb_proc_t pipe) { + size_t matchedlen = HBE_CATCH(hb_proc_matches_line_terminator, pipe); + + if (matchedlen) { + HBE_CATCH(hb_proc_accept_count, pipe, matchedlen); + } + + return matchedlen; +} + +/** + * Accepts the following character if it satisfies the predicate pred. + * Won't do anything if already at the end. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param pred predicate + * @return 0 if nothing was accepted, 1 otherwise + * @throws on read/write error + */ +int hb_proc_accept_if_predicate(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_predicate_t pred) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi, pipe); + + if (c == HB_EOD || !(*pred)(c)) { + return 0; + } + + HBE_CATCH(hb_proc_accept, pipe); + + return 1; +} + +/** + * Accepts every following character until one dissatisfies the predicate pred, + * or the end is reached. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param pred predicate + * @return amount of characters accepted + * @throws on read/write error + */ +size_t hb_proc_accept_while_predicate(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_predicate_t pred) { + size_t count = 0; + + while (1) { + int matched = HBE_CATCH(hb_proc_accept_if_predicate, pipe, pred); + if (!matched) { + break; + } + count++; + } + + return count; +} diff --git a/src/hb-proc-core.c b/src/hb-proc-core.c new file mode 100644 index 0000000..b13af41 --- /dev/null +++ b/src/hb-proc-core.c @@ -0,0 +1,262 @@ +#pragma once + +#include +#include +#include "../../rule/char/ucalpha.c" +#include "../char/char.c" +#include "../execution/error.c" +#include "../list/char.c" +#include "../fstream/fstreamin.c" +#include "../fstream/fstreamout.c" + +// Use macro to prevent having to allocate (and therefore free/manage) memory +#define HB_PROC_FORMAT_WITH_POS(fn, a, format, ...) fn(a, format " at %s [line %d, column %d]", __VA_ARGS__, proc->name, proc->line, proc->column); + +/** + * Creates an error using a message with the current position appended. + * + * @param proc proc + * @param errcode error code + * @param reason message + * @return error + */ +hbe_err_t hb_proc_error(hb_proc_t* proc, hb_error_t errcode, const char *reason, ...) { + va_list args; + va_start(args, reason); + + char *msg = calloc(HB_PROC_MAX_ERR_MSG_LEN + 1, SIZEOF_CHAR); + vsnprintf(msg, HB_PROC_MAX_ERR_MSG_LEN, reason, args); + + va_end(args); + + hbe_err_t err = HBU_FN_FORMAT_WITH_POS(hbe_err_create, errcode, "%s", msg); + free(msg); + + return err; +} + +/** + * Reads from input. + * + * @param hbe_err pointer to hbe_err_t + * @param proc proc + * @throws on read error + */ +static hb_eod_char_t _hb_proc_read_from_input(hbe_err_t *hbe_err, hb_proc_t* proc) { + hb_eod_char_t c = HBE_CATCH((*proc->reader), proc->input); + if (c == HB_EOD) { + proc->EOI = 1; + } + return c; +} + +/** + * Ensures the buffer has loaded at least the next offset characters, or the remaining + * characters from input if there are less than offset characters left. + * + * @param hbe_err pointer to hbe_err_t + * @param proc proc + * @throws on read error + */ +static void _hb_proc_ensure_buffer(hbe_err_t *hbe_err, hb_proc_t* proc, size_t offset) { + if (proc->EOI) { + return; + } + + size_t current = proc->buffer->length; + + if (offset <= current) { + return; + } + + size_t gap = offset - current; + + for (size_t i = 0; i < gap; i++) { + hb_eod_char_t c = HBE_CATCH_V(_hb_proc_read_from_input, proc); + if (c == HB_EOD) { + // EOI flag already set by _hb_proc_read_from_input + return; + } + hb_list_char_append(proc->buffer, c); + } +} + +/** + * Gets the next character, whether it's by shifting the buffer or reading from input. + * + * @param hbe_err pointer to hbe_err_t + * @param proc proc + * @throws on read error + */ +static hb_eod_char_t _hb_proc_read_from_buffer_or_input(hbe_err_t *hbe_err, hb_proc_t* proc) { + if (proc->EOI) { + return HB_EOD; + } + + if (proc->buffer->length) { + return hb_list_char_shift(proc->buffer); + } + + return HBE_CATCH(_hb_proc_read_from_input, proc); +} + +static void _hb_proc_update_pos(hb_proc_t* proc, hb_proc_char_t c) { + switch (c) { + case '\r': + proc->CR = true; + proc->line++; + proc->column = 0; + break; + + case '\n': + if (!proc->CR) { + proc->line++; + proc->column = 0; + } else { + proc->CR = false; + } + break; + + default: + proc->column++; + proc->CR = false; + } +} + +/** + * Ensures that the provided character is not @{link HB_EOD}, and causes an error otherwise. + * + * @param c character to test for HB_EOD + * @throws HBE_PARSE_UNEXPECTED_END if c is HB_EOD + */ +static void _hb_proc_assert_not_eoi(hbe_err_t *hbe_err, hb_eod_char_t c) { + if (c == HB_EOD) { + HBE_THROW_V(HBE_PARSE_UNEXPECTED_END, "Unexpected end of input"); + } +} + +/** + * Writes a character to the redirect, if enabled, otherwise output, of a proc, + * unless the output is masked. + * + * @param hbe_err pointer to hbe_err_t + * @param proc proc + * @param c character to write + * @return a freshly-created proc + * @throws on write error + */ +static void _hb_proc_write_to_output(hbe_err_t *hbe_err, hb_proc_t* proc, hb_proc_char_t c) { + if (!proc->mask) { + hb_list_char_t redirect = proc->redirect; + if (redirect != NULL) { + hb_list_char_append(redirect, c); + } else { + HBE_CATCH_V((*proc->writer), proc->output, c); + } + } +} + +/* + * + * INSTANCE MANAGEMENT FUNCTIONS + * + */ + +/** + * Allocates memory for a proc, and creates one with provided arguments. + * + * @param input input + * @param reader reader + * @param name name + * @param output output + * @param writer writer + * @return a freshly-created proc + */ +hb_proc_t* hb_proc_create_blank(char *name) { + hb_proc_t* proc = calloc(1, sizeof(hb_proc_t)); + + proc->name = name; + + proc->input = NULL; + proc->reader = NULL; + proc->EOI = false; + + proc->line = 1; + proc->column = 0; + proc->CR = false; + + proc->output = NULL; + proc->writer = NULL; + proc->buffer = nh_list_ucp_create(); + proc->mask = false; + proc->redirect = NULL; + + return proc; +} + +/** + * Frees all memory associated with a proc. + * + * @param proc proc + */ +void hb_proc_destroy(hb_proc_t* proc) { + nh_list_ucp_destroy(proc->buffer); + free(proc); +} + +/** + * Enables or disables the output mask. + * When the output mask is enabled, all writes are simply discarded and not actually written to output. + * + * @param proc proc + * @param mask 1 to enable, 0 to disable + * @return previous state + */ +int hb_proc_toggle_output_mask(hb_proc_t* proc, int mask) { + int current = proc->mask; + proc->mask = mask; + return current; +} + +/** + * Enables or disables the output redirect. + * When the output redirect is enabled, all writes are written to a buffer instead of the output. + * + * @param proc proc + * @param redirect buffer to redirect writes to, or NULL to disable + */ +void hb_proc_set_redirect(hb_proc_t* proc, hb_list_char_t redirect) { + proc->redirect = redirect; +} + +void hb_proc_blank_set_input_fstreamin(hb_proc_t* proc, hbu_fstreamin_t fstreamin) { + proc->input = fstreamin; + proc->reader = (hb_proc_reader_cb_t) &hbu_fstreamin_read; +} + +// Wrapper function for hb_list_char_shift to make it compatible with hb_proc_reader_cb_t +static hb_eod_char_t hb_proc_read_from_list_char_input(hbe_err_t *hbe_err, hb_list_char_t input) { + (void) hbe_err; + return hb_list_char_shift(input); +} + +void hb_proc_blank_set_input_buffer(hb_proc_t* proc, hb_list_char_t buf) { + proc->input = buf; + proc->reader = (hb_proc_reader_cb_t) &hb_proc_read_from_list_char_input; +} + +static void hb_proc_blank_set_output_fstreamout(hb_proc_t* proc, hbu_fstreamout_t fstreamout) { + proc->output = fstreamout; + proc->writer = (hb_proc_writer_cb_t) &hbu_fstreamout_write; +} + +// Wrapper function for hb_list_char_append to make it compatible with hb_proc_writer_cb_t +void hb_proc_write_to_list_char_output(hbe_err_t *hbe_err, hb_list_char_t output, hb_proc_char_t c) { + (void) hbe_err; + hb_list_char_append(output, c); +} + +void hb_proc_blank_set_output_buffer(hb_proc_t* proc, hb_list_char_t buf) { + proc->output = buf; + proc->writer = (hb_proc_writer_cb_t) &hb_proc_write_to_list_char_output; +} diff --git a/src/hb-proc-matches.c b/src/hb-proc-matches.c new file mode 100644 index 0000000..5f02068 --- /dev/null +++ b/src/hb-proc-matches.c @@ -0,0 +1,75 @@ +/** + * Checks if the next sequence of characters is the null-terminated character array match. + * Won't cause an error if insufficient amount of characters left. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match characters to match + * @return amount of characters matched, which should be equal to strlen(match) + * @throws on read error + */ +size_t hb_proc_matches(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + size_t matchlen = strlen(match); + + for (size_t i = 0; i < matchlen; i++) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi_offset, pipe, i + 1); + if (c == HB_EOD || c != match[i]) { + return 0; + } + } + + return matchlen; +} + +/** + * Checks if the next sequence of characters matches the null-terminated character array match + * of lowercase characters case-insensitively. + * Won't cause an error if insufficient amount of characters left. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match characters to match case-insensitively + * @return amount of characters matched, which should be equal to strlen(match) + * @throws on read error + */ +size_t hb_proc_matches_i(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + size_t matchlen = strlen(match); + + for (size_t i = 0; i < matchlen; i++) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi_offset, pipe, i + 1); + if (!( + c != HB_EOD && + ( + c == match[i] || + (hb_rule_ucalpha_check(c) && (c + 32) == match[i]) + ) + )) { + return 0; + } + } + + return matchlen; +} + +/** + * Checks if the next sequence of characters is "\r", "\n", or "\r\n". + * Won't cause an error if insufficient amount of characters left. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return amount of characters matched + * @throws on read error + */ +size_t hb_proc_matches_line_terminator(hbe_err_t *hbe_err, hb_proc_t pipe) { + // Can't chain into HBE_CATCH(...) || HBE_CATCH(...) || ... + // as HBE_CATCH needs auxiliary statement + + // `\r\n` must be before `\r` + size_t crlf = HBE_CATCH(hb_proc_matches, pipe, "\r\n"); + if (crlf) return crlf; + + size_t cr = HBE_CATCH(hb_proc_matches, pipe, "\r"); + if (cr) return cr; + + return HBE_CATCH(hb_proc_matches, pipe, "\n"); +} diff --git a/src/hb-proc-peek.c b/src/hb-proc-peek.c new file mode 100644 index 0000000..c6ad813 --- /dev/null +++ b/src/hb-proc-peek.c @@ -0,0 +1,78 @@ +/** + * Gets the next character. + * If it's the end, {@link HB_EOD} is returned. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return character or {@link HB_EOD} + * @throws on read error + */ +hb_eod_char_t hb_proc_peek_eoi(hbe_err_t *hbe_err, hb_proc_t pipe) { + // OPTIMISATION: Read directly from buffer if available (no need to unshift later) + if (pipe->buffer->length) { + return hb_list_char_get(pipe->buffer, 0); + } + + hb_eod_char_t c = HBE_CATCH(_hb_proc_read_from_buffer_or_input, pipe); + + if (c != HB_EOD) { + hb_list_char_unshift(pipe->buffer, c); + } + + return c; +} + +/** + * Gets the next character. + * Will cause an error if it's the end and there is no next character. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return character + * @throws on read error or HBE_PARSE_UNEXPECTED_END + */ +hb_proc_char_t hb_proc_peek(hbe_err_t *hbe_err, hb_proc_t pipe) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi, pipe); + + HBE_CATCH(_hb_proc_assert_not_eoi, c); + + return c; +} + +/** + * Gets the nth character from current, where n is offset. + * When offset is 1, the next character is returned (equivalent to {@link hb_proc_peek_eoi_offset}). + * If offset is after the last character, {@link HB_EOD} is returned. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param offset position of character to get + * @return character or {@link HB_EOD} + * @throws on read error + */ +hb_eod_char_t hb_proc_peek_eoi_offset(hbe_err_t *hbe_err, hb_proc_t pipe, size_t offset) { + HBE_CATCH(_hb_proc_ensure_buffer, pipe, offset); + + hb_eod_char_t c = hb_list_char_get(pipe->buffer, offset - 1); + + return c; +} + +/** + * Gets the nth character from current, where n is offset. + * When offset is 1, the next character is returned (equivalent to {@link hb_proc_peek_offset}). + * An error will be caused if offset is after the last character. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param offset position of character to get + * @return character + * @throws on read error or HBE_PARSE_UNEXPECTED_END + */ +hb_proc_char_t hb_proc_peek_offset(hbe_err_t *hbe_err, hb_proc_t pipe, size_t offset) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi_offset, pipe, offset); + + HBE_CATCH(_hb_proc_assert_not_eoi, c); + + return c; +} diff --git a/src/hb-proc-require.c b/src/hb-proc-require.c new file mode 100644 index 0000000..d8ea713 --- /dev/null +++ b/src/hb-proc-require.c @@ -0,0 +1,112 @@ +/** + * Requires the next character to be c. + * The matched character is written to output. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param c character to match + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +void hb_proc_require(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_char_t c) { + hb_proc_char_t n = HBE_CATCH_V(hb_proc_accept, pipe); + + if (c != n) { + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected `%c` (0x%x), got `%c` (0x%x)", c, c, n, n); + } +} + +/** + * Requires the next character to be c. + * The matched character is skipped over and NOT written to output, and also returned. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param c character to match + * @return matched character + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +hb_proc_char_t hb_proc_require_skip(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_char_t c) { + hb_proc_char_t n = HBE_CATCH(hb_proc_skip, pipe); + + if (c != n) { + hb_proc_THROW(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected `%c` (0x%x), got `%c` (0x%x) at %s", c, c, n, n); + } + + return n; +} + +/** + * Requires the next character to satisfy the predicate pred. + * The matched character is written to output. + * If not matched, the error message will describe the expected output using name. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param pred predicate + * @param name what to output in the error message to describe the requirement + * @return required character + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +hb_proc_char_t hb_proc_require_predicate(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_predicate_t pred, const char *name) { + hb_proc_char_t n = HBE_CATCH(hb_proc_accept, pipe); + + if (!(*pred)(n)) { + hb_proc_THROW(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected %s, got `%c` (0x%x)", name, n, n); + } + + return n; +} + +/** + * Requires the next character to satisfy the predicate pred. + * The matched character is skipped over and NOT written to output. + * If not matched, the error message will describe the expected output using name. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param pred predicate + * @param name what to output in the error message to describe the requirement + * @return required character + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +hb_proc_char_t hb_proc_require_skip_predicate(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_predicate_t pred, const char *name) { + hb_proc_char_t n = HBE_CATCH(hb_proc_skip, pipe); + + if (!(*pred)(n)) { + hb_proc_THROW(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected %s, got `%c` (0x%x)", name, n, n); + } + + return n; +} + +/** + * Requires the next sequence of characters to be equal to match. + * Matched characters are written to output. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match sequence of characters to require + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +void hb_proc_require_match(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + int matches = HBE_CATCH_V(hb_proc_accept_if_matches, pipe, match); + if (!matches) { + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected `%s`", match); + } +} + +/** + * Requires the next sequence of characters to be equal to match. + * Matched characters are skipped over and NOT written to output. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match sequence of characters to require + * @throws on read/write error, HBE_PARSE_UNEXPECTED_END, or HBE_PARSE_EXPECTED_NOT_FOUND + */ +void hb_proc_require_skip_match(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + int matches = HBE_CATCH_V(hb_proc_skip_if_matches, pipe, match); + if (!matches) { + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected `%s`", match); + } +} diff --git a/src/hb-proc-skip.c b/src/hb-proc-skip.c new file mode 100644 index 0000000..6831bc0 --- /dev/null +++ b/src/hb-proc-skip.c @@ -0,0 +1,103 @@ +/** + * Skips over the next character. + * Requires that the file has at least one character remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @return skipped character + * @throws on read error or HBE_PARSE_UNEXPECTED_END + */ +hb_proc_char_t hb_proc_skip(hbe_err_t *hbe_err, hb_proc_t pipe) { + hb_eod_char_t c = HBE_CATCH(_hb_proc_read_from_buffer_or_input, pipe); + + HBE_CATCH(_hb_proc_assert_not_eoi, c); + + _hb_proc_update_pos(pipe, c); + + return c; +} + +/** + * Skips over the next amount characters. + * Requires that the file has at least amount characters remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param amount amount of characters to skip + * @throws on read error or HBE_PARSE_UNEXPECTED_END + */ +void hb_proc_skip_amount(hbe_err_t *hbe_err, hb_proc_t pipe, size_t amount) { + for (size_t i = 0; i < amount; i++) { + HBE_CATCH_V(hb_proc_skip, pipe); + } +} + +/** + * Skips over the following character if it is c. + * Won't cause an error if the end is reached. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param c character to skip if next + * @return 1 if skipped, 0 otherwise + * @throws on read error + */ +int hb_proc_skip_if(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_char_t c) { + hb_eod_char_t n = HBE_CATCH(hb_proc_peek_eoi, pipe); + + if (n == HB_EOD || n != c) { + return 0; + } + + HBE_CATCH(hb_proc_skip, pipe); + return 1; +} + +/** + * Skips over every following character until one dissatisfies the predicate pred, + * or the end is reached. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param pred predicate + * @return amount of characters skipped + * @throws on read error + */ +size_t hb_proc_skip_while_predicate(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_predicate_t pred) { + size_t count = 0; + + while (1) { + hb_eod_char_t c = HBE_CATCH(hb_proc_peek_eoi, pipe); + + if (c == HB_EOD || !(*pred)(c)) { + break; + } + + HBE_CATCH(hb_proc_skip, pipe); + count++; + } + + return count; +} + +/** + * Skips over the next sequence of characters if they are match. + * Requires that the file has at least the length of match characters remaining. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param match sequence of characters to match + * @return 0 if not matched, 1 otherwise + * @throws on read error or HBE_PARSE_UNEXPECTED_END + */ +int hb_proc_skip_if_matches(hbe_err_t *hbe_err, hb_proc_t pipe, const char *match) { + size_t matchedlen = HBE_CATCH(hb_proc_matches, pipe, match); + + int matched = matchedlen > 0; + + if (matched) { + HBE_CATCH(hb_proc_skip_amount, pipe, matchedlen); + } + + return matched; +} diff --git a/src/hb-proc-write.c b/src/hb-proc-write.c new file mode 100644 index 0000000..5f12f42 --- /dev/null +++ b/src/hb-proc-write.c @@ -0,0 +1,69 @@ +/** + * Writes a character. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param c character + * @throws on write error + */ +void hb_proc_write(hbe_err_t *hbe_err, hb_proc_t pipe, hb_proc_char_t c) { + HBE_CATCH_V(_hb_proc_write_to_output, pipe, c); +} + +/** + * Writes a buffer. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param buffer buffer + * @throws on write error + */ +void hb_proc_write_buffer(hbe_err_t *hbe_err, hb_proc_t pipe, hb_list_char_t buffer) { + for (size_t i = 0; i < buffer->length; i++) { + HBE_CATCH_V(_hb_proc_write_to_output, pipe, hb_list_char_get(buffer, i)); + } +} + +/** + * Writes a character from its Unicode code point in UTF-8 encoding, which may be multiple bytes. + * + * @param hbe_err pointer to hbe_err_t + * @param pipe pipe + * @param code_point Unicode code point + * @return amount of bytes written (0 if invalid code point) + * @throws on write error + */ +// Logic copied from https://gist.github.com/MightyPork/52eda3e5677b4b03524e40c9f0ab1da5 +size_t hb_proc_write_unicode(hbe_err_t *hbe_err, hb_proc_t pipe, uint32_t code_point) { + if (code_point <= 0x7F) { + // Plain ASCII + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) code_point); + return 1; + } + + if (code_point <= 0x07FF) { + // 2-byte unicode + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 6) & 0x1F) | 0xC0)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 0) & 0x3F) | 0x80)); + return 2; + } + + if (code_point <= 0xFFFF) { + // 3-byte unicode + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 12) & 0x0F) | 0xE0)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 6) & 0x3F) | 0x80)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 0) & 0x3F) | 0x80)); + return 3; + } + + if (code_point <= 0x10FFFF) { + // 4-byte unicode + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 18) & 0x07) | 0xF0)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 12) & 0x3F) | 0x80)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 6) & 0x3F) | 0x80)); + HBE_CATCH(hb_proc_write, pipe, (hb_proc_char_t) (((code_point >> 0) & 0x3F) | 0x80)); + return 4; + } + + return 0; +} diff --git a/src/hb-proc.h b/src/hb-proc.h new file mode 100644 index 0000000..3c98260 --- /dev/null +++ b/src/hb-proc.h @@ -0,0 +1,73 @@ +#pragma once + +#include + +#include "hb-data.h" +#include "hb-config.h" + +typedef int32_t hb_proc_char_t; + +#define HB_PROC_CHAR_EOD -1 // End Of Data +#define HB_PROC_CHAR_SIZE sizeof(hb_proc_char_t) + +typedef bool hb_proc_predicate_t(hb_proc_char_t); + +// Reader and writer callbacks. The last parameter is a pointer to an error +// message. If the last parameter is not NULL, it is assumed an error occurred. +// The error message WILL BE free'd by the callee automatically, so ensure the +// message was created using malloc or strdup, and is not free'd by the function +// or anything else afterwards. +typedef hb_proc_char_t hb_proc_reader_t(void*, char**); +typedef void hb_proc_writer_t(void*, hb_proc_char_t, char**); + +#define HB_PROC_MEMORY_CREATE(name) \ + hb_proc_list_memory_instance_add_right_and_return( \ + config->memory_instances, name##_create()); \ + hb_proc_list_memory_destructor_add_right( \ + config->memory_destructors, \ + (hb_proc_memory_destructor_t*) &name##_destroy); + +NH_LIST(hb_proc_list_memory_instance, void*, sizeof(void*), void*, NULL); +void* hb_proc_list_memory_instance_add_right_and_return( + hb_proc_list_memory_instance*, void*); + +typedef void hb_proc_memory_destructor_t(void*); +NH_LIST(hb_proc_list_memory_destructor, hb_proc_memory_destructor_t*, + sizeof(hb_proc_memory_destructor_t*), hb_proc_memory_destructor_t*, + NULL); + +#define HB_PROC_ERROR_MESSAGE_SIZE 1024 +typedef struct { + hb_error_t code; + char* message; +} hb_proc_result_t; + +typedef struct { + char* name; + jmp_buf start; + + hb_proc_list_memory_instance* memory_instances; + hb_proc_list_memory_destructor* memory_destructors; + + void* input; + hb_proc_reader_t* reader; + bool EOI; + + int line; + int column; + bool CR; + + void* output; + hb_proc_writer_t* writer; + nh_list_ucp* buffer; + bool mask; + nh_list_ucp* redirect; + + hb_config_t config; +} hb_proc_t; + +hb_proc_t* hb_proc_create_blank(char* name); +void hb_proc_result_destroy(hb_proc_result_t* result); + +hb_proc_result_t* hb_proc_start(hb_proc_t* proc); +void _hb_proc_error(hb_proc_t* proc, hb_error_t code, char const* format, ...); diff --git a/src/stream/attr/quoteattrval.c b/src/hb-unit-attribute-value-quoted.c similarity index 54% rename from src/stream/attr/quoteattrval.c rename to src/hb-unit-attribute-value-quoted.c index 24645ba..1631b9e 100644 --- a/src/stream/attr/quoteattrval.c +++ b/src/hb-unit-attribute-value-quoted.c @@ -1,83 +1,83 @@ #include "./attrval.c" #include "../entity/entity.c" -hbs_attr_val_type_t hbs_quoteattrval(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe, int collapse_and_trim_whitespace) { +hbs_attr_val_type_t hbs_quoteattrval(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe, int collapse_and_trim_whitespace) { hbs_attr_val_type_t rv = 0; int should_remove_attr_quotes = so->remove_attr_quotes; - hbu_list_char_t value = NULL; + hb_list_char_t value = NULL; if (should_remove_attr_quotes) { - value = hbu_list_char_create(); - hbu_pipe_set_output_redirect(pipe, value); + value = hb_list_char_create(); + hb_proc_set_redirect(pipe, value); } - hb_char_t quote_char = HBE_CATCH_F(hbu_pipe_require_skip_predicate, pipe, &hbr_attrvalquote_check, "attribute value quote"); + hb_proc_char_t quote_char = HBE_CATCH_F(hb_proc_require_skip_predicate, pipe, &hb_rule_attrvalquote_check, "attribute value quote"); if (!should_remove_attr_quotes) { // Not buffering, so directly output - HBE_CATCH_F(hbu_pipe_write, pipe, quote_char); + HBE_CATCH_F(hb_proc_write, pipe, quote_char); } int whitespace = 0; if (collapse_and_trim_whitespace) { - HBE_CATCH_F(hbu_pipe_skip_while_predicate, pipe, &hbr_whitespace_check); + HBE_CATCH_F(hb_proc_skip_while_predicate, pipe, &hb_rule_whitespace_check); } int not_empty = 0; int can_be_unquoted = 1; while (1) { - hb_char_t c = HBE_CATCH_F(hbu_pipe_peek, pipe); + hb_proc_char_t c = HBE_CATCH_F(hb_proc_peek, pipe); if (c == quote_char) { break; } not_empty = 1; - can_be_unquoted = can_be_unquoted && hbr_unquotedattrval_check(c); + can_be_unquoted = can_be_unquoted && hb_rule_unquotedattrval_check(c); - if (collapse_and_trim_whitespace && hbr_whitespace_check(c)) { + if (collapse_and_trim_whitespace && hb_rule_whitespace_check(c)) { whitespace = 1; - HBE_CATCH_F(hbu_pipe_skip, pipe); + HBE_CATCH_F(hb_proc_skip, pipe); } else { if (whitespace) { whitespace = 0; - HBE_CATCH_F(hbu_pipe_write, pipe, ' '); + HBE_CATCH_F(hb_proc_write, pipe, ' '); } if (c == '&') { // Call hbs_entity even if not decoding entities, as it will validate the entity HBE_CATCH_F(hbs_entity, so, pipe); } else { - HBE_CATCH_F(hbu_pipe_accept, pipe); + HBE_CATCH_F(hb_proc_accept, pipe); } } } can_be_unquoted = not_empty && can_be_unquoted; - HBE_CATCH_F(hbu_pipe_require_skip, pipe, quote_char); + HBE_CATCH_F(hb_proc_require_skip, pipe, quote_char); if (!should_remove_attr_quotes) { // Not buffering, so directly output - HBE_CATCH_F(hbu_pipe_write, pipe, quote_char); + HBE_CATCH_F(hb_proc_write, pipe, quote_char); HB_RETURN_F(HBS_ATTR_QUOTED); } else { - hbu_pipe_set_output_redirect(pipe, NULL); + hb_proc_set_redirect(pipe, NULL); if (!can_be_unquoted) { // Wrap in braces as macro will add auxiliary statement - HBE_CATCH_F(hbu_pipe_write, pipe, quote_char); + HBE_CATCH_F(hb_proc_write, pipe, quote_char); } - HBE_CATCH_F(hbu_pipe_write_buffer, pipe, value); + HBE_CATCH_F(hb_proc_write_buffer, pipe, value); if (!can_be_unquoted) { // Wrap in braces as macro will add auxiliary statement - HBE_CATCH_F(hbu_pipe_write, pipe, quote_char); + HBE_CATCH_F(hb_proc_write, pipe, quote_char); } HB_RETURN_F(can_be_unquoted ? HBS_ATTR_UNQUOTED : HBS_ATTR_QUOTED); } finally: if (value != NULL) { - hbu_list_char_destroy(value); + hb_list_char_destroy(value); value = NULL; } return rv; diff --git a/src/stream/attr/unquoteattrval.c b/src/hb-unit-attribute-value-unquoted.c similarity index 50% rename from src/stream/attr/unquoteattrval.c rename to src/hb-unit-attribute-value-unquoted.c index 74e780b..954f0b7 100644 --- a/src/stream/attr/unquoteattrval.c +++ b/src/hb-unit-attribute-value-unquoted.c @@ -1,15 +1,15 @@ #include "../entity/entity.c" -void hbs_unquoteattrval(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe) { - // Can't use hbu_pipe_require_predicate, as first char might be `&`, +void hbs_unquoteattrval(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe) { + // Can't use hb_proc_require_predicate, as first char might be `&`, // which needs to be processed by hbs_entity int at_least_one_char = 0; - hb_char_t c; + hb_proc_char_t c; while (1) { - c = HBE_CATCH_V(hbu_pipe_peek, pipe); + c = HBE_CATCH_V(hb_proc_peek, pipe); - if (!hbr_unquotedattrval_check(c)) { + if (!hb_rule_unquotedattrval_check(c)) { return; } @@ -18,11 +18,11 @@ void hbs_unquoteattrval(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t p if (c == '&') { HBE_CATCH_V(hbs_entity, so, pipe); } else { - HBE_CATCH_V(hbu_pipe_accept, pipe); + HBE_CATCH_V(hb_proc_accept, pipe); } } if (!at_least_one_char) { - HBU_PIPE_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected unquoted attribute value, got `%c` (0x%x)", c); + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected unquoted attribute value, got `%c` (0x%x)", c); } } diff --git a/src/stream/attr/attrval.c b/src/hb-unit-attribute-value.c similarity index 100% rename from src/stream/attr/attrval.c rename to src/hb-unit-attribute-value.c diff --git a/src/stream/attr/attr.c b/src/hb-unit-attribute.c similarity index 51% rename from src/stream/attr/attr.c rename to src/hb-unit-attribute.c index d7d6c71..9903db2 100644 --- a/src/stream/attr/attr.c +++ b/src/hb-unit-attribute.c @@ -2,39 +2,39 @@ #include "./quoteattrval.c" #include "./unquoteattrval.c" -hbs_attr_val_type_t hbs_attr(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe) { +hbs_attr_val_type_t hbs_attr(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe) { hbs_attr_val_type_t rv = 0; - hbu_list_char_t name = hbu_list_char_create(); + hb_list_char_t name = hb_list_char_create(); while (1) { // Char matched by $attrname required at least once - hb_char_t c = HBE_CATCH_F(hbu_pipe_require_predicate, pipe, &hbr_attrname_check, "attribute name"); + hb_proc_char_t c = HBE_CATCH_F(hb_proc_require_predicate, pipe, &hb_rule_attrname_check, "attribute name"); - if (hbr_ucalpha_check(c)) { + if (hb_rule_ucalpha_check(c)) { if (!hbu_streamoptions_supressed_error(so, HBE_PARSE_UCASE_ATTR)) { - HBU_PIPE_THROW_F(pipe, HBE_PARSE_UCASE_ATTR, "Uppercase letter in attribute name"); + hb_proc_THROW_F(pipe, HBE_PARSE_UCASE_ATTR, "Uppercase letter in attribute name"); } // Lowercase to normalise when checking against rules and closing tag - hbu_list_char_append(name, c + 32); + hb_list_char_append(name, c + 32); } else { - hbu_list_char_append(name, c); + hb_list_char_append(name, c); } - // Don't use hbu_pipe_accept_while_predicate as advanced checks might be needed - hb_char_t n = HBE_CATCH_F(hbu_pipe_peek, pipe); + // Don't use hb_proc_accept_while_predicate as advanced checks might be needed + hb_proc_char_t n = HBE_CATCH_F(hb_proc_peek, pipe); - if (!hbr_attrname_check(n)) { + if (!hb_rule_attrname_check(n)) { break; } } - int collapse_and_trim_whitespace = hbu_list_char_compare_lit(name, "class") == 0 && + int collapse_and_trim_whitespace = hb_list_char_compare_lit(name, "class") == 0 && so->trim_class_attr; - int has_value = HBE_CATCH_F(hbu_pipe_accept_if, pipe, '='); + int has_value = HBE_CATCH_F(hb_proc_accept_if, pipe, '='); if (has_value) { - hb_char_t next = HBE_CATCH_F(hbu_pipe_peek, pipe); - if (hbr_attrvalquote_check(next)) { + hb_proc_char_t next = HBE_CATCH_F(hb_proc_peek, pipe); + if (hb_rule_attrvalquote_check(next)) { // Quoted attribute value hbs_attr_val_type_t type = HBE_CATCH_F(hbs_quoteattrval, so, pipe, collapse_and_trim_whitespace); // Don't inline as HBE_CATCH_F adds auxiliary statements @@ -42,7 +42,7 @@ hbs_attr_val_type_t hbs_attr(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pip } if (!hbu_streamoptions_supressed_error(so, HBE_PARSE_UNQUOTED_ATTR)) { - HBU_PIPE_THROW_F(pipe, HBE_PARSE_UNQUOTED_ATTR, "Unquoted attribute value"); + hb_proc_THROW_F(pipe, HBE_PARSE_UNQUOTED_ATTR, "Unquoted attribute value"); } // Unquoted attribute value HBE_CATCH_F(hbs_unquoteattrval, so, pipe); @@ -50,7 +50,7 @@ hbs_attr_val_type_t hbs_attr(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pip } finally: - hbu_list_char_destroy(name); + hb_list_char_destroy(name); name = NULL; return rv; } diff --git a/src/hb-unit-bang.c b/src/hb-unit-bang.c new file mode 100644 index 0000000..c5313ab --- /dev/null +++ b/src/hb-unit-bang.c @@ -0,0 +1,14 @@ +void hbs_bang(hbe_err_t *hbe_err, hb_proc_t pipe) { + HBE_CATCH_V(hb_proc_require_match, pipe, "') { + break; + } + + HBE_CATCH_V(hb_proc_accept, pipe); + } + + HBE_CATCH_V(hb_proc_accept, pipe); +} diff --git a/src/hb-unit-comment.c b/src/hb-unit-comment.c new file mode 100644 index 0000000..248a424 --- /dev/null +++ b/src/hb-unit-comment.c @@ -0,0 +1,16 @@ +void hbs_comment(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe) { + hb_proc_toggle_output_mask(pipe, so->remove_comments); + + HBE_CATCH_V(hb_proc_require_match, pipe, ""); + if (end) { + break; + } + + HBE_CATCH_V(hb_proc_accept, pipe); + } + + hb_proc_toggle_output_mask(pipe, 0); +} diff --git a/src/stream/content/html.c b/src/hb-unit-content-html.c similarity index 79% rename from src/stream/content/html.c rename to src/hb-unit-content-html.c index 9bd89f4..42e526d 100644 --- a/src/stream/content/html.c +++ b/src/hb-unit-content-html.c @@ -1,5 +1,5 @@ // Declare first before tag.c, as tag.c depends on it -void hbs_content(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe, hb_char_t *parent); +void hbs_content(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe, hb_proc_char_t *parent); #include "../tag/tag.c" #include "../bang/bang.c" @@ -19,20 +19,20 @@ static int _hbs_content_state_is_comment_bang_or_opening_tag(int state) { state == HBS_CONTENT_STATE_OPENING_TAG; } -static int _hbs_content_get_next_state(hbe_err_t *hbe_err, hbu_pipe_t pipe, hb_eod_char_t c) { - int end_tag = HBE_CATCH(hbu_pipe_matches, pipe, "ex_trim_whitespace, parent); int should_buffer_whitespace = should_collapse_whitespace || should_destroy_whole_whitespace || should_trim_whitespace; - hbu_list_char_t whitespace = NULL; + hb_list_char_t whitespace = NULL; while (1) { - hb_eod_char_t c = HBE_CATCH_F(hbu_pipe_peek_eoi, pipe); + hb_eod_char_t c = HBE_CATCH_F(hb_proc_peek_eoi, pipe); int next_state = HBE_CATCH_F(_hbs_content_get_next_state, pipe, c); - if (next_state == HBS_CONTENT_STATE_TEXT && hbr_whitespace_check(c) && should_buffer_whitespace) { + if (next_state == HBS_CONTENT_STATE_TEXT && hb_rule_whitespace_check(c) && should_buffer_whitespace) { // Next character is whitespace and whitespace should be buffered if (whitespace == NULL) { - whitespace = hbu_list_char_create(); + whitespace = hb_list_char_create(); whitespace_buffer_started_at_beginning = is_first_char; whitespace_buffer_started_after_right_chevron = returned_from_comment_bang_or_tag; } - hbu_list_char_append(whitespace, c); - HBE_CATCH_F(hbu_pipe_skip, pipe); + hb_list_char_append(whitespace, c); + HBE_CATCH_F(hb_proc_skip, pipe); } else { if (whitespace != NULL) { @@ -101,17 +101,17 @@ void hbs_content(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe, hb // Do nothing } else if (should_collapse_whitespace) { - HBE_CATCH_F(hbu_pipe_write, pipe, ' '); + HBE_CATCH_F(hb_proc_write, pipe, ' '); } - hbu_list_char_destroy(whitespace); + hb_list_char_destroy(whitespace); whitespace = NULL; whitespace_buffer_started_at_beginning = 0; } switch (next_state) { case HBS_CONTENT_STATE_TEXT: - HBE_CATCH_F(hbu_pipe_accept, pipe); + HBE_CATCH_F(hb_proc_accept, pipe); break; case HBS_CONTENT_STATE_COMMENT: @@ -145,7 +145,7 @@ void hbs_content(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe, hb finally: if (whitespace != NULL) { - hbu_list_char_destroy(whitespace); + hb_list_char_destroy(whitespace); whitespace = NULL; } } diff --git a/src/hb-unit-content-script.c b/src/hb-unit-content-script.c new file mode 100644 index 0000000..70bb171 --- /dev/null +++ b/src/hb-unit-content-script.c @@ -0,0 +1,126 @@ +static void _hbs_script_slcomment(hbe_err_t *hbe_err, hb_proc_t pipe) { + HBE_CATCH_V(hb_proc_require_match, pipe, "//"); + + // Comment can end at closing + // NOTE: Closing tag must not contain whitespace + while (1) { + int line_term = HBE_CATCH_V(hb_proc_accept_if_matches_line_terminator, pipe); + if (line_term) { + break; + } + + int end_tag = HBE_CATCH_V(hb_proc_matches_i, pipe, ""); + if (end_tag) { + break; + } + + HBE_CATCH_V(hb_proc_accept, pipe); + } +} + +static void _hbs_script_mlcomment(hbe_err_t *hbe_err, hb_proc_t pipe) { + HBE_CATCH_V(hb_proc_require_match, pipe, "/*"); + + // Comment can end at closing + // NOTE: Closing tag must not contain whitespace + while (1) { + int end = HBE_CATCH_V(hb_proc_accept_if_matches, pipe, "*/"); + if (end) { + break; + } + + int end_tag = HBE_CATCH_V(hb_proc_matches_i, pipe, ""); + if (end_tag) { + break; + } + + HBE_CATCH_V(hb_proc_accept, pipe); + } +} + +static void _hbs_script_string(hbe_err_t *hbe_err, hb_proc_t pipe) { + hb_proc_char_t delim = HBE_CATCH_V(hb_proc_accept, pipe); + + if (delim != '"' && delim != '\'') { + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Expected JavaScript string delimiter"); + } + + int escaping = 0; + + while (1) { + hb_proc_char_t c = HBE_CATCH_V(hb_proc_accept, pipe); + + if (c == '\\') { + escaping ^= 1; + continue; + } + + if (c == delim && !escaping) { + break; + } + + int line_term = HBE_CATCH_V(hb_proc_accept_if_matches_line_terminator, pipe); + if (line_term) { + if (!escaping) { + hb_proc_THROW_V(pipe, HBE_PARSE_EXPECTED_NOT_FOUND, "Unterminated JavaScript string"); + } + } + + escaping = 0; + } +} + +static void _hbs_script_template(hbe_err_t *hbe_err, hb_proc_t pipe) { + HBE_CATCH_V(hb_proc_require_match, pipe, "`"); + + int escaping = 0; + + while (1) { + hb_proc_char_t c = HBE_CATCH_V(hb_proc_accept, pipe); + + if (c == '\\') { + escaping ^= 1; + continue; + } + + if (c == '`' && !escaping) { + break; + } + + escaping = 0; + } +} + +void hbs_script(hbe_err_t *hbe_err, hb_proc_t pipe) { + while (1) { + int end = HBE_CATCH_V(hb_proc_matches, pipe, "decode_entities) { - HBE_CATCH_F(hbu_pipe_write, pipe, hbr_entityrefs_get(entity_raw_u)); + HBE_CATCH_F(hb_proc_write, pipe, hb_rule_entity_references_get(entity_raw_u)); } break; @@ -146,7 +146,7 @@ void hbs_entity(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe) { code_point = strtoumax((char *) entity_raw_u, NULL, (type == HBS_ENTITY_TYPE_DECIMAL) ? 10 : 16); valid = errno == 0 && code_point <= 0x10FFFF; if (valid && so->decode_entities) { - valid = HBE_CATCH_F(hbu_pipe_write_unicode, pipe, code_point); + valid = HBE_CATCH_F(hb_proc_write_unicode, pipe, code_point); } break; @@ -164,7 +164,7 @@ void hbs_entity(hbe_err_t *hbe_err, hbu_streamoptions_t so, hbu_pipe_t pipe) { finally: if (entity_raw != NULL) { - hbu_list_char_destroy(entity_raw); + hb_list_char_destroy(entity_raw); entity_raw = NULL; } } diff --git a/src/hb-unit-tag-name.c b/src/hb-unit-tag-name.c new file mode 100644 index 0000000..83bedff --- /dev/null +++ b/src/hb-unit-tag-name.c @@ -0,0 +1,34 @@ +hb_list_char_t hbs_tagname(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe) { + hb_list_char_t name = hb_list_char_create(); + + while (1) { + hb_proc_char_t c = HBE_CATCH_F(hb_proc_peek, pipe); + + if (!hb_rule_tagname_check(c)) { + break; + } + + if (hb_rule_ucalpha_check(c)) { + if (!hbu_streamoptions_supressed_error(so, HBE_PARSE_UCASE_TAG)) { + hb_proc_THROW_F(pipe, HBE_PARSE_UCASE_TAG, "Uppercase character in tag"); + } + // Lowercase to normalise when checking against rules and closing tag + hb_list_char_append(name, c + 32); + } else { + hb_list_char_append(name, c); + } + + HBE_CATCH_F(hb_proc_accept, pipe); + } + + if (!hbu_streamoptions_supressed_error(so, HBE_PARSE_NONSTANDARD_TAG) && !hb_rule_tags_check(hb_list_char_underlying(name))) { + hb_proc_THROW_F(pipe, HBE_PARSE_NONSTANDARD_TAG, "Non-standard tag"); + } + + finally: + if (*hbe_err != NULL) { + hb_list_char_destroy(name); + name = NULL; + } + return name; +} diff --git a/src/hb-unit-tag.c b/src/hb-unit-tag.c new file mode 100644 index 0000000..1abe38f --- /dev/null +++ b/src/hb-unit-tag.c @@ -0,0 +1,102 @@ +// Declare first before content.c, as content.c depends on it +void hbs_tag(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe, hb_proc_char_t *parent); + +#include "./tagname.c" +#include "../attr/attr.c" +#include "../content/script.c" +#include "../content/style.c" +#include "../content/html.c" + +// $parent could be NULL +void hbs_tag(hbe_err_t *hbe_err, hbu_streamoptions_t so, hb_proc_t pipe, hb_proc_char_t *parent) { + hb_list_char_t opening_name = NULL; + + int self_closing = 0; + + HBE_CATCH_F(hb_proc_require, pipe, '<'); + opening_name = HBE_CATCH_F(hbs_tagname, so, pipe); + + int last_attr_type = -1; + + while (1) { + // At the beginning of this loop, the last parsed unit was either the tag name + // or an attribute (including its value, if it had one) + size_t ws_accepted; + if (so->remove_tag_whitespace) { + ws_accepted = HBE_CATCH_F(hb_proc_skip_while_predicate, pipe, &hb_rule_whitespace_check); + } else { + ws_accepted = HBE_CATCH_F(hb_proc_accept_while_predicate, pipe, &hb_rule_whitespace_check); + } + + int end_of_tag = HBE_CATCH_F(hb_proc_accept_if, pipe, '>'); + if (end_of_tag) { + break; + } + + self_closing = HBE_CATCH_F(hb_proc_accept_if_matches, pipe, "/>"); + if (self_closing) { + if (!hbu_streamoptions_supressed_error(so, HBE_PARSE_SELF_CLOSING_TAG)) { + hb_proc_THROW_F(pipe, HBE_PARSE_SELF_CLOSING_TAG, "Self-closing tag"); + } + break; + } + + // HBE_PARSE_NO_SPACE_BEFORE_ATTR is not suppressable as then there would be difficulty + // in determining what is the end of a tag/attribute name/attribute value + if (!ws_accepted) { + hb_proc_THROW_F(pipe, HBE_PARSE_NO_SPACE_BEFORE_ATTR, "No whitespace before attribute"); + } + + if (so->remove_tag_whitespace) { + if (last_attr_type != HBS_ATTR_QUOTED) { + HBE_CATCH_F(hb_proc_write, pipe, ' '); + } + } + + last_attr_type = HBE_CATCH_F(hbs_attr, so, pipe); + } + + hb_proc_char_t *tag_name = hb_list_char_underlying(opening_name); + + // Non-standard tag checking is done in hbs_tagname + if (parent != NULL && ( + !hb_rule_whitelistparents_allowed(tag_name, parent) || + !hb_rule_whitelistchildren_allowed(parent, tag_name) || + !hb_rule_blacklistparents_allowed(tag_name, parent) || + !hb_rule_blacklistchildren_allowed(parent, tag_name))) { + hb_proc_THROW_F(pipe, HBE_PARSE_ILLEGAL_CHILD, "Tag can't be a child there"); + } + + // Self-closing or void tag + if (self_closing || hb_rule_voidtags_check(tag_name)) { + goto finally; + } + + if (hb_list_char_compare_lit(opening_name, "script") == 0) { + // Script tag + HBE_CATCH_F(hbs_script, pipe); + } else if (hb_list_char_compare_lit(opening_name, "style") == 0) { + // Style tag + HBE_CATCH_F(hbs_style, pipe); + } else { + // Content + HBE_CATCH_F(hbs_content, so, pipe, tag_name); + } + + // Closing tag for non-void + HBE_CATCH_F(hb_proc_require, pipe, '<'); + HBE_CATCH_F(hb_proc_require, pipe, '/'); + hb_list_char_t closing_name = HBE_CATCH_F(hbs_tagname, so, pipe); + HBE_CATCH_F(hb_proc_require, pipe, '>'); + + if (!hb_list_char_equal(opening_name, closing_name)) { + hb_proc_THROW_F(pipe, HBE_PARSE_UNCLOSED_TAG, "Tag not closed (expected `%s` closing tag, got `%s`)", tag_name, hb_list_char_underlying(closing_name)); + } + + finally: + if (opening_name) { + hb_list_char_destroy(opening_name); + opening_name = NULL; + } + return; +} diff --git a/src/hb-unit.h b/src/hb-unit.h new file mode 100644 index 0000000..e69de29 diff --git a/src/hyperbuild.c b/src/hyperbuild.c new file mode 100644 index 0000000..d0d56a1 --- /dev/null +++ b/src/hyperbuild.c @@ -0,0 +1,6 @@ +void hb_init(void) { + // Set up rules + hb_rule_init(); + // Set up config + hb_config_init(); +} diff --git a/src/rule/__main__.c b/src/rule/__main__.c index 36761ce..b9bdccc 100644 --- a/src/rule/__main__.c +++ b/src/rule/__main__.c @@ -12,7 +12,7 @@ #include "./char/unquotedattrval.c" #include "./char/whitespace.c" -#include "./entity/entityrefs.c" +#include "./entity/entity_references.c" #include "./relation/blacklistchildren.c" #include "./relation/blacklistparents.c" @@ -33,48 +33,48 @@ #include "./tag/svgtags.c" #include "./tag/tags.c" -void hbr_init(void) { +void hb_rule_init(void) { // Core - hbr_c0_init(); - hbr_digit_init(); - hbr_hex_init(); - hbr_ucalpha_init(); - hbr_lcalpha_init(); - hbr_whitespace_init(); + hb_rule_c0_init(); + hb_rule_digit_init(); + hb_rule_hex_init(); + hb_rule_ucalpha_init(); + hb_rule_lcalpha_init(); + hb_rule_whitespace_init(); // Identifiers - hbr_tagname_init(); - hbr_attrname_init(); + hb_rule_tagname_init(); + hb_rule_attrname_init(); // Values - hbr_attrvalquote_init(); - hbr_unquotedattrval_init(); - hbr_entityrefs_init(); + hb_rule_attrvalquote_init(); + hb_rule_unquotedattrval_init(); + hb_rule_entity_references_init(); // Specification tag categories - hbr_headingtags_init(); - hbr_mediatags_init(); - hbr_sectioningtags_init(); + hb_rule_headingtags_init(); + hb_rule_mediatags_init(); + hb_rule_sectioningtags_init(); - hbr_voidtags_init(); - hbr_wsstags_init(); + hb_rule_voidtags_init(); + hb_rule_wsstags_init(); - hbr_htmltags_init(); - hbr_svgtags_init(); - hbr_tags_init(); + hb_rule_htmltags_init(); + hb_rule_svgtags_init(); + hb_rule_tags_init(); // Hyperbuild tag categories - hbr_contentfirsttags_init(); - hbr_contenttags_init(); - hbr_formattingtags_init(); - hbr_layouttags_init(); - hbr_specifictags_init(); + hb_rule_contentfirsttags_init(); + hb_rule_contenttags_init(); + hb_rule_formattingtags_init(); + hb_rule_layouttags_init(); + hb_rule_specifictags_init(); // Relations - hbr_whitelistparents_init(); - hbr_blacklistparents_init(); - hbr_whitelistchildren_init(); - hbr_blacklistchildren_init(); + hb_rule_whitelistparents_init(); + hb_rule_blacklistparents_init(); + hb_rule_whitelistchildren_init(); + hb_rule_blacklistchildren_init(); } #endif // _HDR_HYPERBUILD_RULE_INIT diff --git a/src/rule/char/attrname.c b/src/rule/char/attrname.c index 1a8ed4f..493f6ec 100644 --- a/src/rule/char/attrname.c +++ b/src/rule/char/attrname.c @@ -1,19 +1,19 @@ #include "./c0.c" -static nh_set_int32_t hbr_attrname_blacklist; +static nh_set_int32_t hb_rule_attrname_blacklist; -void hbr_attrname_init(void) { - hbr_attrname_blacklist = nh_set_int32_create(); - hbr_c0_add_elems(hbr_attrname_blacklist); - nh_set_int32_add(hbr_attrname_blacklist, ' '); - nh_set_int32_add(hbr_attrname_blacklist, '"'); - nh_set_int32_add(hbr_attrname_blacklist, '\''); - nh_set_int32_add(hbr_attrname_blacklist, '>'); - nh_set_int32_add(hbr_attrname_blacklist, '/'); - nh_set_int32_add(hbr_attrname_blacklist, '='); +void hb_rule_attrname_init(void) { + hb_rule_attrname_blacklist = nh_set_int32_create(); + hb_rule_c0_add_elems(hb_rule_attrname_blacklist); + nh_set_int32_add(hb_rule_attrname_blacklist, ' '); + nh_set_int32_add(hb_rule_attrname_blacklist, '"'); + nh_set_int32_add(hb_rule_attrname_blacklist, '\''); + nh_set_int32_add(hb_rule_attrname_blacklist, '>'); + nh_set_int32_add(hb_rule_attrname_blacklist, '/'); + nh_set_int32_add(hb_rule_attrname_blacklist, '='); // NOTE: Unicode noncharacters not tested (https://html.spec.whatwg.org/multipage/syntax.html#syntax-attribute-name) } -int hbr_attrname_check(hb_char_t c) { - return !nh_set_int32_has(hbr_attrname_blacklist, c); +int hb_rule_attrname_check(hb_proc_char_t c) { + return !nh_set_int32_has(hb_rule_attrname_blacklist, c); } diff --git a/src/rule/char/attrvalquote.c b/src/rule/char/attrvalquote.c index 4446f57..5027bca 100644 --- a/src/rule/char/attrvalquote.c +++ b/src/rule/char/attrvalquote.c @@ -1,13 +1,13 @@ #include "./c0.c" -static nh_set_int32_t hbr_attrvalquote_set; +static nh_set_int32_t hb_rule_attrvalquote_set; -void hbr_attrvalquote_init(void) { - hbr_attrvalquote_set = nh_set_int32_create(); - nh_set_int32_add(hbr_attrvalquote_set, '\''); - nh_set_int32_add(hbr_attrvalquote_set, '"'); +void hb_rule_attrvalquote_init(void) { + hb_rule_attrvalquote_set = nh_set_int32_create(); + nh_set_int32_add(hb_rule_attrvalquote_set, '\''); + nh_set_int32_add(hb_rule_attrvalquote_set, '"'); } -int hbr_attrvalquote_check(hb_char_t c) { - return nh_set_int32_has(hbr_attrvalquote_set, c); +int hb_rule_attrvalquote_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_attrvalquote_set, c); } diff --git a/src/rule/char/c0.c b/src/rule/char/c0.c index 4df70c8..89b93bd 100644 --- a/src/rule/char/c0.c +++ b/src/rule/char/c0.c @@ -1,16 +1,16 @@ -static nh_set_int32_t hbr_c0_set; +static nh_set_int32_t hb_rule_c0_set; -void hbr_c0_add_elems(nh_set_int32_t set) { +void hb_rule_c0_add_elems(nh_set_int32_t set) { for (char c = 0x0; c <= 0x1F; c++) { nh_set_int32_add(set, c); } } -void hbr_c0_init(void) { - hbr_c0_set = nh_set_int32_create(); - hbr_c0_add_elems(hbr_c0_set); +void hb_rule_c0_init(void) { + hb_rule_c0_set = nh_set_int32_create(); + hb_rule_c0_add_elems(hb_rule_c0_set); } -int hbr_c0_check(hb_char_t c) { - return nh_set_int32_has(hbr_c0_set, c); +int hb_rule_c0_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_c0_set, c); } diff --git a/src/rule/char/digit.c b/src/rule/char/digit.c index 9cf5165..1b3b37a 100644 --- a/src/rule/char/digit.c +++ b/src/rule/char/digit.c @@ -1,16 +1,16 @@ -static nh_set_int32_t hbr_digit_set; +static nh_set_int32_t hb_rule_digit_set; -void hbr_digit_add_elems(nh_set_int32_t set) { +void hb_rule_digit_add_elems(nh_set_int32_t set) { for (char c = 0x30; c <= 0x39; c++) { nh_set_int32_add(set, c); } } -void hbr_digit_init(void) { - hbr_digit_set = nh_set_int32_create(); - hbr_digit_add_elems(hbr_digit_set); +void hb_rule_digit_init(void) { + hb_rule_digit_set = nh_set_int32_create(); + hb_rule_digit_add_elems(hb_rule_digit_set); } -int hbr_digit_check(hb_char_t c) { - return nh_set_int32_has(hbr_digit_set, c); +int hb_rule_digit_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_digit_set, c); } diff --git a/src/rule/char/hex.c b/src/rule/char/hex.c index 29e6388..a07046c 100644 --- a/src/rule/char/hex.c +++ b/src/rule/char/hex.c @@ -1,6 +1,6 @@ -static nh_set_int32_t hbr_hex_set; +static nh_set_int32_t hb_rule_hex_set; -void hbr_hex_add_elems(nh_set_int32_t set) { +void hb_rule_hex_add_elems(nh_set_int32_t set) { for (char c = 0x30; c <= 0x39; c++) { // 0-9 nh_set_int32_add(set, c); } @@ -12,11 +12,11 @@ void hbr_hex_add_elems(nh_set_int32_t set) { } } -void hbr_hex_init(void) { - hbr_hex_set = nh_set_int32_create(); - hbr_hex_add_elems(hbr_hex_set); +void hb_rule_hex_init(void) { + hb_rule_hex_set = nh_set_int32_create(); + hb_rule_hex_add_elems(hb_rule_hex_set); } -int hbr_hex_check(hb_char_t c) { - return nh_set_int32_has(hbr_hex_set, c); +int hb_rule_hex_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_hex_set, c); } diff --git a/src/rule/char/lcalpha.c b/src/rule/char/lcalpha.c index d6b1593..b7800d7 100644 --- a/src/rule/char/lcalpha.c +++ b/src/rule/char/lcalpha.c @@ -1,16 +1,16 @@ -static nh_set_int32_t hbr_lcalpha_set; +static nh_set_int32_t hb_rule_lcalpha_set; -void hbr_lcalpha_add_elems(nh_set_int32_t set) { +void hb_rule_lcalpha_add_elems(nh_set_int32_t set) { for (char c = 0x61; c <= 0x7A; c++) { nh_set_int32_add(set, c); } } -void hbr_lcalpha_init(void) { - hbr_lcalpha_set = nh_set_int32_create(); - hbr_lcalpha_add_elems(hbr_lcalpha_set); +void hb_rule_lcalpha_init(void) { + hb_rule_lcalpha_set = nh_set_int32_create(); + hb_rule_lcalpha_add_elems(hb_rule_lcalpha_set); } -int hbr_lcalpha_check(hb_char_t c) { - return nh_set_int32_has(hbr_lcalpha_set, c); +int hb_rule_lcalpha_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_lcalpha_set, c); } diff --git a/src/rule/char/tagname.c b/src/rule/char/tagname.c index 86562cf..02b9885 100644 --- a/src/rule/char/tagname.c +++ b/src/rule/char/tagname.c @@ -2,17 +2,17 @@ #include "./ucalpha.c" #include "./digit.c" -static nh_set_int32_t hbr_tagname_set; +static nh_set_int32_t hb_rule_tagname_set; -void hbr_tagname_init(void) { - hbr_tagname_set = nh_set_int32_create(); - hbr_lcalpha_add_elems(hbr_tagname_set); - hbr_ucalpha_add_elems(hbr_tagname_set); - hbr_digit_add_elems(hbr_tagname_set); - nh_set_int32_add(hbr_tagname_set, ':'); - nh_set_int32_add(hbr_tagname_set, '-'); +void hb_rule_tagname_init(void) { + hb_rule_tagname_set = nh_set_int32_create(); + hb_rule_lcalpha_add_elems(hb_rule_tagname_set); + hb_rule_ucalpha_add_elems(hb_rule_tagname_set); + hb_rule_digit_add_elems(hb_rule_tagname_set); + nh_set_int32_add(hb_rule_tagname_set, ':'); + nh_set_int32_add(hb_rule_tagname_set, '-'); } -int hbr_tagname_check(hb_char_t c) { - return nh_set_int32_has(hbr_tagname_set, c); +int hb_rule_tagname_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_tagname_set, c); } diff --git a/src/rule/char/ucalpha.c b/src/rule/char/ucalpha.c index bbce304..48ca78a 100644 --- a/src/rule/char/ucalpha.c +++ b/src/rule/char/ucalpha.c @@ -1,16 +1,16 @@ -static nh_set_int32_t hbr_ucalpha_set; +static nh_set_int32_t hb_rule_ucalpha_set; -void hbr_ucalpha_add_elems(nh_set_int32_t set) { +void hb_rule_ucalpha_add_elems(nh_set_int32_t set) { for (char c = 0x41; c <= 0x5A; c++) { nh_set_int32_add(set, c); } } -void hbr_ucalpha_init(void) { - hbr_ucalpha_set = nh_set_int32_create(); - hbr_ucalpha_add_elems(hbr_ucalpha_set); +void hb_rule_ucalpha_init(void) { + hb_rule_ucalpha_set = nh_set_int32_create(); + hb_rule_ucalpha_add_elems(hb_rule_ucalpha_set); } -int hbr_ucalpha_check(hb_char_t c) { - return nh_set_int32_has(hbr_ucalpha_set, c); +int hb_rule_ucalpha_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_ucalpha_set, c); } diff --git a/src/rule/char/unquotedattrval.c b/src/rule/char/unquotedattrval.c index 30d2394..0b776f9 100644 --- a/src/rule/char/unquotedattrval.c +++ b/src/rule/char/unquotedattrval.c @@ -1,18 +1,18 @@ #include "./whitespace.c" -static nh_set_int32_t hbr_unquotedattrval_blacklist; +static nh_set_int32_t hb_rule_unquotedattrval_blacklist; -void hbr_unquotedattrval_init(void) { - hbr_unquotedattrval_blacklist = nh_set_int32_create(); - hbr_whitespace_add_elems(hbr_unquotedattrval_blacklist); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '"'); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '\''); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '`'); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '='); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '<'); - nh_set_int32_add(hbr_unquotedattrval_blacklist, '>'); +void hb_rule_unquotedattrval_init(void) { + hb_rule_unquotedattrval_blacklist = nh_set_int32_create(); + hb_rule_whitespace_add_elems(hb_rule_unquotedattrval_blacklist); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '"'); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '\''); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '`'); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '='); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '<'); + nh_set_int32_add(hb_rule_unquotedattrval_blacklist, '>'); } -int hbr_unquotedattrval_check(hb_char_t c) { - return !nh_set_int32_has(hbr_unquotedattrval_blacklist, c); +int hb_rule_unquotedattrval_check(hb_proc_char_t c) { + return !nh_set_int32_has(hb_rule_unquotedattrval_blacklist, c); } diff --git a/src/rule/char/whitespace.c b/src/rule/char/whitespace.c index 27f94e0..3a9375c 100644 --- a/src/rule/char/whitespace.c +++ b/src/rule/char/whitespace.c @@ -1,6 +1,6 @@ -static nh_set_int32_t hbr_whitespace_set; +static nh_set_int32_t hb_rule_whitespace_set; -void hbr_whitespace_add_elems(nh_set_int32_t set) { +void hb_rule_whitespace_add_elems(nh_set_int32_t set) { nh_set_int32_add(set, 0x09); // TAB nh_set_int32_add(set, 0x0A); // LF nh_set_int32_add(set, 0x0C); // FF @@ -8,11 +8,11 @@ void hbr_whitespace_add_elems(nh_set_int32_t set) { nh_set_int32_add(set, 0x20); // SPACE } -void hbr_whitespace_init(void) { - hbr_whitespace_set = nh_set_int32_create(); - hbr_whitespace_add_elems(hbr_whitespace_set); +void hb_rule_whitespace_init(void) { + hb_rule_whitespace_set = nh_set_int32_create(); + hb_rule_whitespace_add_elems(hb_rule_whitespace_set); } -int hbr_whitespace_check(hb_char_t c) { - return nh_set_int32_has(hbr_whitespace_set, c); +int hb_rule_whitespace_check(hb_proc_char_t c) { + return nh_set_int32_has(hb_rule_whitespace_set, c); } diff --git a/src/rule/entity/entityrefs.c b/src/rule/entity/entityrefs.c index 7f42c34..56bceb3 100644 --- a/src/rule/entity/entityrefs.c +++ b/src/rule/entity/entityrefs.c @@ -1,2046 +1,2076 @@ -// Sourced from https://dev.w3.org/html5/html-author/charref at 2018-07-02T10:00:00Z +#pragma once -static nh_map_str_int32_t hbr_entityrefs_map; +#include "hb-data.h" -void hbr_entityrefs_init(void) { - hbr_entityrefs_map = nh_map_str_int32_create(); - nh_map_str_int32_set(hbr_entityrefs_map, "AElig", 0xc6); - nh_map_str_int32_set(hbr_entityrefs_map, "AMP", 0x26); - nh_map_str_int32_set(hbr_entityrefs_map, "Aacute", 0xc1); - nh_map_str_int32_set(hbr_entityrefs_map, "Abreve", 0x102); - nh_map_str_int32_set(hbr_entityrefs_map, "Acirc", 0xc2); - nh_map_str_int32_set(hbr_entityrefs_map, "Acy", 0x410); - nh_map_str_int32_set(hbr_entityrefs_map, "Afr", 0x1d504); - nh_map_str_int32_set(hbr_entityrefs_map, "Agrave", 0xc0); - nh_map_str_int32_set(hbr_entityrefs_map, "Alpha", 0x391); - nh_map_str_int32_set(hbr_entityrefs_map, "Amacr", 0x100); - nh_map_str_int32_set(hbr_entityrefs_map, "And", 0x2a53); - nh_map_str_int32_set(hbr_entityrefs_map, "Aogon", 0x104); - nh_map_str_int32_set(hbr_entityrefs_map, "Aopf", 0x1d538); - nh_map_str_int32_set(hbr_entityrefs_map, "ApplyFunction", 0x2061); - nh_map_str_int32_set(hbr_entityrefs_map, "Aring", 0xc5); - nh_map_str_int32_set(hbr_entityrefs_map, "Ascr", 0x1d49c); - nh_map_str_int32_set(hbr_entityrefs_map, "Assign", 0x2254); - nh_map_str_int32_set(hbr_entityrefs_map, "Atilde", 0xc3); - nh_map_str_int32_set(hbr_entityrefs_map, "Auml", 0xc4); - nh_map_str_int32_set(hbr_entityrefs_map, "Backslash", 0x2216); - nh_map_str_int32_set(hbr_entityrefs_map, "Barv", 0x2ae7); - nh_map_str_int32_set(hbr_entityrefs_map, "Barwed", 0x2306); - nh_map_str_int32_set(hbr_entityrefs_map, "Bcy", 0x411); - nh_map_str_int32_set(hbr_entityrefs_map, "Because", 0x2235); - nh_map_str_int32_set(hbr_entityrefs_map, "Bernoullis", 0x212c); - nh_map_str_int32_set(hbr_entityrefs_map, "Beta", 0x392); - nh_map_str_int32_set(hbr_entityrefs_map, "Bfr", 0x1d505); - nh_map_str_int32_set(hbr_entityrefs_map, "Bopf", 0x1d539); - nh_map_str_int32_set(hbr_entityrefs_map, "Breve", 0x2d8); - nh_map_str_int32_set(hbr_entityrefs_map, "Bscr", 0x212c); - nh_map_str_int32_set(hbr_entityrefs_map, "Bumpeq", 0x224e); - nh_map_str_int32_set(hbr_entityrefs_map, "CHcy", 0x427); - nh_map_str_int32_set(hbr_entityrefs_map, "COPY", 0xa9); - nh_map_str_int32_set(hbr_entityrefs_map, "Cacute", 0x106); - nh_map_str_int32_set(hbr_entityrefs_map, "Cap", 0x22d2); - nh_map_str_int32_set(hbr_entityrefs_map, "CapitalDifferentialD", 0x2145); - nh_map_str_int32_set(hbr_entityrefs_map, "Cayleys", 0x212d); - nh_map_str_int32_set(hbr_entityrefs_map, "Ccaron", 0x10c); - nh_map_str_int32_set(hbr_entityrefs_map, "Ccedil", 0xc7); - nh_map_str_int32_set(hbr_entityrefs_map, "Ccirc", 0x108); - nh_map_str_int32_set(hbr_entityrefs_map, "Cconint", 0x2230); - nh_map_str_int32_set(hbr_entityrefs_map, "Cdot", 0x10a); - nh_map_str_int32_set(hbr_entityrefs_map, "Cedilla", 0xb8); - nh_map_str_int32_set(hbr_entityrefs_map, "CenterDot", 0xb7); - nh_map_str_int32_set(hbr_entityrefs_map, "Cfr", 0x212d); - nh_map_str_int32_set(hbr_entityrefs_map, "Chi", 0x3a7); - nh_map_str_int32_set(hbr_entityrefs_map, "CircleDot", 0x2299); - nh_map_str_int32_set(hbr_entityrefs_map, "CircleMinus", 0x2296); - nh_map_str_int32_set(hbr_entityrefs_map, "CirclePlus", 0x2295); - nh_map_str_int32_set(hbr_entityrefs_map, "CircleTimes", 0x2297); - nh_map_str_int32_set(hbr_entityrefs_map, "ClockwiseContourIntegral", 0x2232); - nh_map_str_int32_set(hbr_entityrefs_map, "CloseCurlyDoubleQuote", 0x201d); - nh_map_str_int32_set(hbr_entityrefs_map, "CloseCurlyQuote", 0x2019); - nh_map_str_int32_set(hbr_entityrefs_map, "Colon", 0x2237); - nh_map_str_int32_set(hbr_entityrefs_map, "Colone", 0x2a74); - nh_map_str_int32_set(hbr_entityrefs_map, "Congruent", 0x2261); - nh_map_str_int32_set(hbr_entityrefs_map, "Conint", 0x222f); - nh_map_str_int32_set(hbr_entityrefs_map, "ContourIntegral", 0x222e); - nh_map_str_int32_set(hbr_entityrefs_map, "Copf", 0x2102); - nh_map_str_int32_set(hbr_entityrefs_map, "Coproduct", 0x2210); - nh_map_str_int32_set(hbr_entityrefs_map, "CounterClockwiseContourIntegral", 0x2233); - nh_map_str_int32_set(hbr_entityrefs_map, "Cross", 0x2a2f); - nh_map_str_int32_set(hbr_entityrefs_map, "Cscr", 0x1d49e); - nh_map_str_int32_set(hbr_entityrefs_map, "Cup", 0x22d3); - nh_map_str_int32_set(hbr_entityrefs_map, "CupCap", 0x224d); - nh_map_str_int32_set(hbr_entityrefs_map, "DD", 0x2145); - nh_map_str_int32_set(hbr_entityrefs_map, "DDotrahd", 0x2911); - nh_map_str_int32_set(hbr_entityrefs_map, "DJcy", 0x402); - nh_map_str_int32_set(hbr_entityrefs_map, "DScy", 0x405); - nh_map_str_int32_set(hbr_entityrefs_map, "DZcy", 0x40f); - nh_map_str_int32_set(hbr_entityrefs_map, "Dagger", 0x2021); - nh_map_str_int32_set(hbr_entityrefs_map, "Darr", 0x21a1); - nh_map_str_int32_set(hbr_entityrefs_map, "Dashv", 0x2ae4); - nh_map_str_int32_set(hbr_entityrefs_map, "Dcaron", 0x10e); - nh_map_str_int32_set(hbr_entityrefs_map, "Dcy", 0x414); - nh_map_str_int32_set(hbr_entityrefs_map, "Del", 0x2207); - nh_map_str_int32_set(hbr_entityrefs_map, "Delta", 0x394); - nh_map_str_int32_set(hbr_entityrefs_map, "Dfr", 0x1d507); - nh_map_str_int32_set(hbr_entityrefs_map, "DiacriticalAcute", 0xb4); - nh_map_str_int32_set(hbr_entityrefs_map, "DiacriticalDot", 0x2d9); - nh_map_str_int32_set(hbr_entityrefs_map, "DiacriticalDoubleAcute", 0x2dd); - nh_map_str_int32_set(hbr_entityrefs_map, "DiacriticalGrave", 0x60); - nh_map_str_int32_set(hbr_entityrefs_map, "DiacriticalTilde", 0x2dc); - nh_map_str_int32_set(hbr_entityrefs_map, "Diamond", 0x22c4); - nh_map_str_int32_set(hbr_entityrefs_map, "DifferentialD", 0x2146); - nh_map_str_int32_set(hbr_entityrefs_map, "Dopf", 0x1d53b); - nh_map_str_int32_set(hbr_entityrefs_map, "Dot", 0xa8); - nh_map_str_int32_set(hbr_entityrefs_map, "DotDot", 0x20dc); - nh_map_str_int32_set(hbr_entityrefs_map, "DotEqual", 0x2250); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleContourIntegral", 0x222f); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleDot", 0xa8); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleDownArrow", 0x21d3); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLeftArrow", 0x21d0); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLeftRightArrow", 0x21d4); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLeftTee", 0x2ae4); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLongLeftArrow", 0x27f8); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLongLeftRightArrow", 0x27fa); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleLongRightArrow", 0x27f9); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleRightArrow", 0x21d2); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleRightTee", 0x22a8); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleUpArrow", 0x21d1); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleUpDownArrow", 0x21d5); - nh_map_str_int32_set(hbr_entityrefs_map, "DoubleVerticalBar", 0x2225); - nh_map_str_int32_set(hbr_entityrefs_map, "DownArrow", 0x2193); - nh_map_str_int32_set(hbr_entityrefs_map, "DownArrowBar", 0x2913); - nh_map_str_int32_set(hbr_entityrefs_map, "DownArrowUpArrow", 0x21f5); - nh_map_str_int32_set(hbr_entityrefs_map, "DownBreve", 0x311); - nh_map_str_int32_set(hbr_entityrefs_map, "DownLeftRightVector", 0x2950); - nh_map_str_int32_set(hbr_entityrefs_map, "DownLeftTeeVector", 0x295e); - nh_map_str_int32_set(hbr_entityrefs_map, "DownLeftVector", 0x21bd); - nh_map_str_int32_set(hbr_entityrefs_map, "DownLeftVectorBar", 0x2956); - nh_map_str_int32_set(hbr_entityrefs_map, "DownRightTeeVector", 0x295f); - nh_map_str_int32_set(hbr_entityrefs_map, "DownRightVector", 0x21c1); - nh_map_str_int32_set(hbr_entityrefs_map, "DownRightVectorBar", 0x2957); - nh_map_str_int32_set(hbr_entityrefs_map, "DownTee", 0x22a4); - nh_map_str_int32_set(hbr_entityrefs_map, "DownTeeArrow", 0x21a7); - nh_map_str_int32_set(hbr_entityrefs_map, "Downarrow", 0x21d3); - nh_map_str_int32_set(hbr_entityrefs_map, "Dscr", 0x1d49f); - nh_map_str_int32_set(hbr_entityrefs_map, "Dstrok", 0x110); - nh_map_str_int32_set(hbr_entityrefs_map, "ENG", 0x14a); - nh_map_str_int32_set(hbr_entityrefs_map, "ETH", 0xd0); - nh_map_str_int32_set(hbr_entityrefs_map, "Eacute", 0xc9); - nh_map_str_int32_set(hbr_entityrefs_map, "Ecaron", 0x11a); - nh_map_str_int32_set(hbr_entityrefs_map, "Ecirc", 0xca); - nh_map_str_int32_set(hbr_entityrefs_map, "Ecy", 0x42d); - nh_map_str_int32_set(hbr_entityrefs_map, "Edot", 0x116); - nh_map_str_int32_set(hbr_entityrefs_map, "Efr", 0x1d508); - nh_map_str_int32_set(hbr_entityrefs_map, "Egrave", 0xc8); - nh_map_str_int32_set(hbr_entityrefs_map, "Element", 0x2208); - nh_map_str_int32_set(hbr_entityrefs_map, "Emacr", 0x112); - nh_map_str_int32_set(hbr_entityrefs_map, "EmptySmallSquare", 0x25fb); - nh_map_str_int32_set(hbr_entityrefs_map, "EmptyVerySmallSquare", 0x25ab); - nh_map_str_int32_set(hbr_entityrefs_map, "Eogon", 0x118); - nh_map_str_int32_set(hbr_entityrefs_map, "Eopf", 0x1d53c); - nh_map_str_int32_set(hbr_entityrefs_map, "Epsilon", 0x395); - nh_map_str_int32_set(hbr_entityrefs_map, "Equal", 0x2a75); - nh_map_str_int32_set(hbr_entityrefs_map, "EqualTilde", 0x2242); - nh_map_str_int32_set(hbr_entityrefs_map, "Equilibrium", 0x21cc); - nh_map_str_int32_set(hbr_entityrefs_map, "Escr", 0x2130); - nh_map_str_int32_set(hbr_entityrefs_map, "Esim", 0x2a73); - nh_map_str_int32_set(hbr_entityrefs_map, "Eta", 0x397); - nh_map_str_int32_set(hbr_entityrefs_map, "Euml", 0xcb); - nh_map_str_int32_set(hbr_entityrefs_map, "Exists", 0x2203); - nh_map_str_int32_set(hbr_entityrefs_map, "ExponentialE", 0x2147); - nh_map_str_int32_set(hbr_entityrefs_map, "Fcy", 0x424); - nh_map_str_int32_set(hbr_entityrefs_map, "Ffr", 0x1d509); - nh_map_str_int32_set(hbr_entityrefs_map, "FilledSmallSquare", 0x25fc); - nh_map_str_int32_set(hbr_entityrefs_map, "FilledVerySmallSquare", 0x25aa); - nh_map_str_int32_set(hbr_entityrefs_map, "Fopf", 0x1d53d); - nh_map_str_int32_set(hbr_entityrefs_map, "ForAll", 0x2200); - nh_map_str_int32_set(hbr_entityrefs_map, "Fouriertrf", 0x2131); - nh_map_str_int32_set(hbr_entityrefs_map, "Fscr", 0x2131); - nh_map_str_int32_set(hbr_entityrefs_map, "GJcy", 0x403); - nh_map_str_int32_set(hbr_entityrefs_map, "GT", 0x3e); - nh_map_str_int32_set(hbr_entityrefs_map, "Gamma", 0x393); - nh_map_str_int32_set(hbr_entityrefs_map, "Gammad", 0x3dc); - nh_map_str_int32_set(hbr_entityrefs_map, "Gbreve", 0x11e); - nh_map_str_int32_set(hbr_entityrefs_map, "Gcedil", 0x122); - nh_map_str_int32_set(hbr_entityrefs_map, "Gcirc", 0x11c); - nh_map_str_int32_set(hbr_entityrefs_map, "Gcy", 0x413); - nh_map_str_int32_set(hbr_entityrefs_map, "Gdot", 0x120); - nh_map_str_int32_set(hbr_entityrefs_map, "Gfr", 0x1d50a); - nh_map_str_int32_set(hbr_entityrefs_map, "Gg", 0x22d9); - nh_map_str_int32_set(hbr_entityrefs_map, "Gopf", 0x1d53e); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterEqual", 0x2265); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterEqualLess", 0x22db); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterFullEqual", 0x2267); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterGreater", 0x2aa2); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterLess", 0x2277); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterSlantEqual", 0x2a7e); - nh_map_str_int32_set(hbr_entityrefs_map, "GreaterTilde", 0x2273); - nh_map_str_int32_set(hbr_entityrefs_map, "Gscr", 0x1d4a2); - nh_map_str_int32_set(hbr_entityrefs_map, "Gt", 0x226b); - nh_map_str_int32_set(hbr_entityrefs_map, "HARDcy", 0x42a); - nh_map_str_int32_set(hbr_entityrefs_map, "Hacek", 0x2c7); - nh_map_str_int32_set(hbr_entityrefs_map, "Hat", 0x5e); - nh_map_str_int32_set(hbr_entityrefs_map, "Hcirc", 0x124); - nh_map_str_int32_set(hbr_entityrefs_map, "Hfr", 0x210c); - nh_map_str_int32_set(hbr_entityrefs_map, "HilbertSpace", 0x210b); - nh_map_str_int32_set(hbr_entityrefs_map, "Hopf", 0x210d); - nh_map_str_int32_set(hbr_entityrefs_map, "HorizontalLine", 0x2500); - nh_map_str_int32_set(hbr_entityrefs_map, "Hscr", 0x210b); - nh_map_str_int32_set(hbr_entityrefs_map, "Hstrok", 0x126); - nh_map_str_int32_set(hbr_entityrefs_map, "HumpDownHump", 0x224e); - nh_map_str_int32_set(hbr_entityrefs_map, "HumpEqual", 0x224f); - nh_map_str_int32_set(hbr_entityrefs_map, "IEcy", 0x415); - nh_map_str_int32_set(hbr_entityrefs_map, "IJlig", 0x132); - nh_map_str_int32_set(hbr_entityrefs_map, "IOcy", 0x401); - nh_map_str_int32_set(hbr_entityrefs_map, "Iacute", 0xcd); - nh_map_str_int32_set(hbr_entityrefs_map, "Icirc", 0xce); - nh_map_str_int32_set(hbr_entityrefs_map, "Icy", 0x418); - nh_map_str_int32_set(hbr_entityrefs_map, "Idot", 0x130); - nh_map_str_int32_set(hbr_entityrefs_map, "Ifr", 0x2111); - nh_map_str_int32_set(hbr_entityrefs_map, "Igrave", 0xcc); - nh_map_str_int32_set(hbr_entityrefs_map, "Im", 0x2111); - nh_map_str_int32_set(hbr_entityrefs_map, "Imacr", 0x12a); - nh_map_str_int32_set(hbr_entityrefs_map, "ImaginaryI", 0x2148); - nh_map_str_int32_set(hbr_entityrefs_map, "Implies", 0x21d2); - nh_map_str_int32_set(hbr_entityrefs_map, "Int", 0x222c); - nh_map_str_int32_set(hbr_entityrefs_map, "Integral", 0x222b); - nh_map_str_int32_set(hbr_entityrefs_map, "Intersection", 0x22c2); - nh_map_str_int32_set(hbr_entityrefs_map, "InvisibleComma", 0x2063); - nh_map_str_int32_set(hbr_entityrefs_map, "InvisibleTimes", 0x2062); - nh_map_str_int32_set(hbr_entityrefs_map, "Iogon", 0x12e); - nh_map_str_int32_set(hbr_entityrefs_map, "Iopf", 0x1d540); - nh_map_str_int32_set(hbr_entityrefs_map, "Iota", 0x399); - nh_map_str_int32_set(hbr_entityrefs_map, "Iscr", 0x2110); - nh_map_str_int32_set(hbr_entityrefs_map, "Itilde", 0x128); - nh_map_str_int32_set(hbr_entityrefs_map, "Iukcy", 0x406); - nh_map_str_int32_set(hbr_entityrefs_map, "Iuml", 0xcf); - nh_map_str_int32_set(hbr_entityrefs_map, "Jcirc", 0x134); - nh_map_str_int32_set(hbr_entityrefs_map, "Jcy", 0x419); - nh_map_str_int32_set(hbr_entityrefs_map, "Jfr", 0x1d50d); - nh_map_str_int32_set(hbr_entityrefs_map, "Jopf", 0x1d541); - nh_map_str_int32_set(hbr_entityrefs_map, "Jscr", 0x1d4a5); - nh_map_str_int32_set(hbr_entityrefs_map, "Jsercy", 0x408); - nh_map_str_int32_set(hbr_entityrefs_map, "Jukcy", 0x404); - nh_map_str_int32_set(hbr_entityrefs_map, "KHcy", 0x425); - nh_map_str_int32_set(hbr_entityrefs_map, "KJcy", 0x40c); - nh_map_str_int32_set(hbr_entityrefs_map, "Kappa", 0x39a); - nh_map_str_int32_set(hbr_entityrefs_map, "Kcedil", 0x136); - nh_map_str_int32_set(hbr_entityrefs_map, "Kcy", 0x41a); - nh_map_str_int32_set(hbr_entityrefs_map, "Kfr", 0x1d50e); - nh_map_str_int32_set(hbr_entityrefs_map, "Kopf", 0x1d542); - nh_map_str_int32_set(hbr_entityrefs_map, "Kscr", 0x1d4a6); - nh_map_str_int32_set(hbr_entityrefs_map, "LJcy", 0x409); - nh_map_str_int32_set(hbr_entityrefs_map, "LT", 0x3c); - nh_map_str_int32_set(hbr_entityrefs_map, "Lacute", 0x139); - nh_map_str_int32_set(hbr_entityrefs_map, "Lambda", 0x39b); - nh_map_str_int32_set(hbr_entityrefs_map, "Lang", 0x27ea); - nh_map_str_int32_set(hbr_entityrefs_map, "Laplacetrf", 0x2112); - nh_map_str_int32_set(hbr_entityrefs_map, "Larr", 0x219e); - nh_map_str_int32_set(hbr_entityrefs_map, "Lcaron", 0x13d); - nh_map_str_int32_set(hbr_entityrefs_map, "Lcedil", 0x13b); - nh_map_str_int32_set(hbr_entityrefs_map, "Lcy", 0x41b); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftAngleBracket", 0x27e8); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftArrow", 0x2190); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftArrowBar", 0x21e4); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftArrowRightArrow", 0x21c6); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftCeiling", 0x2308); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftDoubleBracket", 0x27e6); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftDownTeeVector", 0x2961); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftDownVector", 0x21c3); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftDownVectorBar", 0x2959); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftFloor", 0x230a); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftRightArrow", 0x2194); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftRightVector", 0x294e); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTee", 0x22a3); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTeeArrow", 0x21a4); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTeeVector", 0x295a); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTriangle", 0x22b2); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTriangleBar", 0x29cf); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftTriangleEqual", 0x22b4); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftUpDownVector", 0x2951); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftUpTeeVector", 0x2960); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftUpVector", 0x21bf); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftUpVectorBar", 0x2958); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftVector", 0x21bc); - nh_map_str_int32_set(hbr_entityrefs_map, "LeftVectorBar", 0x2952); - nh_map_str_int32_set(hbr_entityrefs_map, "Leftarrow", 0x21d0); - nh_map_str_int32_set(hbr_entityrefs_map, "Leftrightarrow", 0x21d4); - nh_map_str_int32_set(hbr_entityrefs_map, "LessEqualGreater", 0x22da); - nh_map_str_int32_set(hbr_entityrefs_map, "LessFullEqual", 0x2266); - nh_map_str_int32_set(hbr_entityrefs_map, "LessGreater", 0x2276); - nh_map_str_int32_set(hbr_entityrefs_map, "LessLess", 0x2aa1); - nh_map_str_int32_set(hbr_entityrefs_map, "LessSlantEqual", 0x2a7d); - nh_map_str_int32_set(hbr_entityrefs_map, "LessTilde", 0x2272); - nh_map_str_int32_set(hbr_entityrefs_map, "Lfr", 0x1d50f); - nh_map_str_int32_set(hbr_entityrefs_map, "Ll", 0x22d8); - nh_map_str_int32_set(hbr_entityrefs_map, "Lleftarrow", 0x21da); - nh_map_str_int32_set(hbr_entityrefs_map, "Lmidot", 0x13f); - nh_map_str_int32_set(hbr_entityrefs_map, "LongLeftArrow", 0x27f5); - nh_map_str_int32_set(hbr_entityrefs_map, "LongLeftRightArrow", 0x27f7); - nh_map_str_int32_set(hbr_entityrefs_map, "LongRightArrow", 0x27f6); - nh_map_str_int32_set(hbr_entityrefs_map, "Longleftarrow", 0x27f8); - nh_map_str_int32_set(hbr_entityrefs_map, "Longleftrightarrow", 0x27fa); - nh_map_str_int32_set(hbr_entityrefs_map, "Longrightarrow", 0x27f9); - nh_map_str_int32_set(hbr_entityrefs_map, "Lopf", 0x1d543); - nh_map_str_int32_set(hbr_entityrefs_map, "LowerLeftArrow", 0x2199); - nh_map_str_int32_set(hbr_entityrefs_map, "LowerRightArrow", 0x2198); - nh_map_str_int32_set(hbr_entityrefs_map, "Lscr", 0x2112); - nh_map_str_int32_set(hbr_entityrefs_map, "Lsh", 0x21b0); - nh_map_str_int32_set(hbr_entityrefs_map, "Lstrok", 0x141); - nh_map_str_int32_set(hbr_entityrefs_map, "Lt", 0x226a); - nh_map_str_int32_set(hbr_entityrefs_map, "Map", 0x2905); - nh_map_str_int32_set(hbr_entityrefs_map, "Mcy", 0x41c); - nh_map_str_int32_set(hbr_entityrefs_map, "MediumSpace", 0x205f); - nh_map_str_int32_set(hbr_entityrefs_map, "Mellintrf", 0x2133); - nh_map_str_int32_set(hbr_entityrefs_map, "Mfr", 0x1d510); - nh_map_str_int32_set(hbr_entityrefs_map, "MinusPlus", 0x2213); - nh_map_str_int32_set(hbr_entityrefs_map, "Mopf", 0x1d544); - nh_map_str_int32_set(hbr_entityrefs_map, "Mscr", 0x2133); - nh_map_str_int32_set(hbr_entityrefs_map, "Mu", 0x39c); - nh_map_str_int32_set(hbr_entityrefs_map, "NJcy", 0x40a); - nh_map_str_int32_set(hbr_entityrefs_map, "Nacute", 0x143); - nh_map_str_int32_set(hbr_entityrefs_map, "Ncaron", 0x147); - nh_map_str_int32_set(hbr_entityrefs_map, "Ncedil", 0x145); - nh_map_str_int32_set(hbr_entityrefs_map, "Ncy", 0x41d); - nh_map_str_int32_set(hbr_entityrefs_map, "NegativeMediumSpace", 0x200b); - nh_map_str_int32_set(hbr_entityrefs_map, "NegativeThickSpace", 0x200b); - nh_map_str_int32_set(hbr_entityrefs_map, "NegativeThinSpace", 0x200b); - nh_map_str_int32_set(hbr_entityrefs_map, "NegativeVeryThinSpace", 0x200b); - nh_map_str_int32_set(hbr_entityrefs_map, "NestedGreaterGreater", 0x226b); - nh_map_str_int32_set(hbr_entityrefs_map, "NestedLessLess", 0x226a); - nh_map_str_int32_set(hbr_entityrefs_map, "NewLine", 0xa); - nh_map_str_int32_set(hbr_entityrefs_map, "Nfr", 0x1d511); - nh_map_str_int32_set(hbr_entityrefs_map, "NoBreak", 0x2060); - nh_map_str_int32_set(hbr_entityrefs_map, "NonBreakingSpace", 0xa0); - nh_map_str_int32_set(hbr_entityrefs_map, "Nopf", 0x2115); - nh_map_str_int32_set(hbr_entityrefs_map, "Not", 0x2aec); - nh_map_str_int32_set(hbr_entityrefs_map, "NotCongruent", 0x2262); - nh_map_str_int32_set(hbr_entityrefs_map, "NotCupCap", 0x226d); - nh_map_str_int32_set(hbr_entityrefs_map, "NotDoubleVerticalBar", 0x2226); - nh_map_str_int32_set(hbr_entityrefs_map, "NotElement", 0x2209); - nh_map_str_int32_set(hbr_entityrefs_map, "NotEqual", 0x2260); - nh_map_str_int32_set(hbr_entityrefs_map, "NotExists", 0x2204); - nh_map_str_int32_set(hbr_entityrefs_map, "NotGreater", 0x226f); - nh_map_str_int32_set(hbr_entityrefs_map, "NotGreaterEqual", 0x2271); - nh_map_str_int32_set(hbr_entityrefs_map, "NotGreaterLess", 0x2279); - nh_map_str_int32_set(hbr_entityrefs_map, "NotGreaterTilde", 0x2275); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLeftTriangle", 0x22ea); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLeftTriangleEqual", 0x22ec); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLess", 0x226e); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLessEqual", 0x2270); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLessGreater", 0x2278); - nh_map_str_int32_set(hbr_entityrefs_map, "NotLessTilde", 0x2274); - nh_map_str_int32_set(hbr_entityrefs_map, "NotPrecedes", 0x2280); - nh_map_str_int32_set(hbr_entityrefs_map, "NotPrecedesSlantEqual", 0x22e0); - nh_map_str_int32_set(hbr_entityrefs_map, "NotReverseElement", 0x220c); - nh_map_str_int32_set(hbr_entityrefs_map, "NotRightTriangle", 0x22eb); - nh_map_str_int32_set(hbr_entityrefs_map, "NotRightTriangleEqual", 0x22ed); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSquareSubsetEqual", 0x22e2); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSquareSupersetEqual", 0x22e3); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSubsetEqual", 0x2288); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSucceeds", 0x2281); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSucceedsSlantEqual", 0x22e1); - nh_map_str_int32_set(hbr_entityrefs_map, "NotSupersetEqual", 0x2289); - nh_map_str_int32_set(hbr_entityrefs_map, "NotTilde", 0x2241); - nh_map_str_int32_set(hbr_entityrefs_map, "NotTildeEqual", 0x2244); - nh_map_str_int32_set(hbr_entityrefs_map, "NotTildeFullEqual", 0x2247); - nh_map_str_int32_set(hbr_entityrefs_map, "NotTildeTilde", 0x2249); - nh_map_str_int32_set(hbr_entityrefs_map, "NotVerticalBar", 0x2224); - nh_map_str_int32_set(hbr_entityrefs_map, "Nscr", 0x1d4a9); - nh_map_str_int32_set(hbr_entityrefs_map, "Ntilde", 0xd1); - nh_map_str_int32_set(hbr_entityrefs_map, "Nu", 0x39d); - nh_map_str_int32_set(hbr_entityrefs_map, "OElig", 0x152); - nh_map_str_int32_set(hbr_entityrefs_map, "Oacute", 0xd3); - nh_map_str_int32_set(hbr_entityrefs_map, "Ocirc", 0xd4); - nh_map_str_int32_set(hbr_entityrefs_map, "Ocy", 0x41e); - nh_map_str_int32_set(hbr_entityrefs_map, "Odblac", 0x150); - nh_map_str_int32_set(hbr_entityrefs_map, "Ofr", 0x1d512); - nh_map_str_int32_set(hbr_entityrefs_map, "Ograve", 0xd2); - nh_map_str_int32_set(hbr_entityrefs_map, "Omacr", 0x14c); - nh_map_str_int32_set(hbr_entityrefs_map, "Omega", 0x3a9); - nh_map_str_int32_set(hbr_entityrefs_map, "Omicron", 0x39f); - nh_map_str_int32_set(hbr_entityrefs_map, "Oopf", 0x1d546); - nh_map_str_int32_set(hbr_entityrefs_map, "OpenCurlyDoubleQuote", 0x201c); - nh_map_str_int32_set(hbr_entityrefs_map, "OpenCurlyQuote", 0x2018); - nh_map_str_int32_set(hbr_entityrefs_map, "Or", 0x2a54); - nh_map_str_int32_set(hbr_entityrefs_map, "Oscr", 0x1d4aa); - nh_map_str_int32_set(hbr_entityrefs_map, "Oslash", 0xd8); - nh_map_str_int32_set(hbr_entityrefs_map, "Otilde", 0xd5); - nh_map_str_int32_set(hbr_entityrefs_map, "Otimes", 0x2a37); - nh_map_str_int32_set(hbr_entityrefs_map, "Ouml", 0xd6); - nh_map_str_int32_set(hbr_entityrefs_map, "OverBar", 0xaf); - nh_map_str_int32_set(hbr_entityrefs_map, "OverBrace", 0x23de); - nh_map_str_int32_set(hbr_entityrefs_map, "OverBracket", 0x23b4); - nh_map_str_int32_set(hbr_entityrefs_map, "OverParenthesis", 0x23dc); - nh_map_str_int32_set(hbr_entityrefs_map, "PartialD", 0x2202); - nh_map_str_int32_set(hbr_entityrefs_map, "Pcy", 0x41f); - nh_map_str_int32_set(hbr_entityrefs_map, "Pfr", 0x1d513); - nh_map_str_int32_set(hbr_entityrefs_map, "Phi", 0x3a6); - nh_map_str_int32_set(hbr_entityrefs_map, "Pi", 0x3a0); - nh_map_str_int32_set(hbr_entityrefs_map, "PlusMinus", 0xb1); - nh_map_str_int32_set(hbr_entityrefs_map, "Poincareplane", 0x210c); - nh_map_str_int32_set(hbr_entityrefs_map, "Popf", 0x2119); - nh_map_str_int32_set(hbr_entityrefs_map, "Pr", 0x2abb); - nh_map_str_int32_set(hbr_entityrefs_map, "Precedes", 0x227a); - nh_map_str_int32_set(hbr_entityrefs_map, "PrecedesEqual", 0x2aaf); - nh_map_str_int32_set(hbr_entityrefs_map, "PrecedesSlantEqual", 0x227c); - nh_map_str_int32_set(hbr_entityrefs_map, "PrecedesTilde", 0x227e); - nh_map_str_int32_set(hbr_entityrefs_map, "Prime", 0x2033); - nh_map_str_int32_set(hbr_entityrefs_map, "Product", 0x220f); - nh_map_str_int32_set(hbr_entityrefs_map, "Proportion", 0x2237); - nh_map_str_int32_set(hbr_entityrefs_map, "Proportional", 0x221d); - nh_map_str_int32_set(hbr_entityrefs_map, "Pscr", 0x1d4ab); - nh_map_str_int32_set(hbr_entityrefs_map, "Psi", 0x3a8); - nh_map_str_int32_set(hbr_entityrefs_map, "QUOT", 0x22); - nh_map_str_int32_set(hbr_entityrefs_map, "Qfr", 0x1d514); - nh_map_str_int32_set(hbr_entityrefs_map, "Qopf", 0x211a); - nh_map_str_int32_set(hbr_entityrefs_map, "Qscr", 0x1d4ac); - nh_map_str_int32_set(hbr_entityrefs_map, "RBarr", 0x2910); - nh_map_str_int32_set(hbr_entityrefs_map, "REG", 0xae); - nh_map_str_int32_set(hbr_entityrefs_map, "Racute", 0x154); - nh_map_str_int32_set(hbr_entityrefs_map, "Rang", 0x27eb); - nh_map_str_int32_set(hbr_entityrefs_map, "Rarr", 0x21a0); - nh_map_str_int32_set(hbr_entityrefs_map, "Rarrtl", 0x2916); - nh_map_str_int32_set(hbr_entityrefs_map, "Rcaron", 0x158); - nh_map_str_int32_set(hbr_entityrefs_map, "Rcedil", 0x156); - nh_map_str_int32_set(hbr_entityrefs_map, "Rcy", 0x420); - nh_map_str_int32_set(hbr_entityrefs_map, "Re", 0x211c); - nh_map_str_int32_set(hbr_entityrefs_map, "ReverseElement", 0x220b); - nh_map_str_int32_set(hbr_entityrefs_map, "ReverseEquilibrium", 0x21cb); - nh_map_str_int32_set(hbr_entityrefs_map, "ReverseUpEquilibrium", 0x296f); - nh_map_str_int32_set(hbr_entityrefs_map, "Rfr", 0x211c); - nh_map_str_int32_set(hbr_entityrefs_map, "Rho", 0x3a1); - nh_map_str_int32_set(hbr_entityrefs_map, "RightAngleBracket", 0x27e9); - nh_map_str_int32_set(hbr_entityrefs_map, "RightArrow", 0x2192); - nh_map_str_int32_set(hbr_entityrefs_map, "RightArrowBar", 0x21e5); - nh_map_str_int32_set(hbr_entityrefs_map, "RightArrowLeftArrow", 0x21c4); - nh_map_str_int32_set(hbr_entityrefs_map, "RightCeiling", 0x2309); - nh_map_str_int32_set(hbr_entityrefs_map, "RightDoubleBracket", 0x27e7); - nh_map_str_int32_set(hbr_entityrefs_map, "RightDownTeeVector", 0x295d); - nh_map_str_int32_set(hbr_entityrefs_map, "RightDownVector", 0x21c2); - nh_map_str_int32_set(hbr_entityrefs_map, "RightDownVectorBar", 0x2955); - nh_map_str_int32_set(hbr_entityrefs_map, "RightFloor", 0x230b); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTee", 0x22a2); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTeeArrow", 0x21a6); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTeeVector", 0x295b); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTriangle", 0x22b3); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTriangleBar", 0x29d0); - nh_map_str_int32_set(hbr_entityrefs_map, "RightTriangleEqual", 0x22b5); - nh_map_str_int32_set(hbr_entityrefs_map, "RightUpDownVector", 0x294f); - nh_map_str_int32_set(hbr_entityrefs_map, "RightUpTeeVector", 0x295c); - nh_map_str_int32_set(hbr_entityrefs_map, "RightUpVector", 0x21be); - nh_map_str_int32_set(hbr_entityrefs_map, "RightUpVectorBar", 0x2954); - nh_map_str_int32_set(hbr_entityrefs_map, "RightVector", 0x21c0); - nh_map_str_int32_set(hbr_entityrefs_map, "RightVectorBar", 0x2953); - nh_map_str_int32_set(hbr_entityrefs_map, "Rightarrow", 0x21d2); - nh_map_str_int32_set(hbr_entityrefs_map, "Ropf", 0x211d); - nh_map_str_int32_set(hbr_entityrefs_map, "RoundImplies", 0x2970); - nh_map_str_int32_set(hbr_entityrefs_map, "Rrightarrow", 0x21db); - nh_map_str_int32_set(hbr_entityrefs_map, "Rscr", 0x211b); - nh_map_str_int32_set(hbr_entityrefs_map, "Rsh", 0x21b1); - nh_map_str_int32_set(hbr_entityrefs_map, "RuleDelayed", 0x29f4); - nh_map_str_int32_set(hbr_entityrefs_map, "SHCHcy", 0x429); - nh_map_str_int32_set(hbr_entityrefs_map, "SHcy", 0x428); - nh_map_str_int32_set(hbr_entityrefs_map, "SOFTcy", 0x42c); - nh_map_str_int32_set(hbr_entityrefs_map, "Sacute", 0x15a); - nh_map_str_int32_set(hbr_entityrefs_map, "Sc", 0x2abc); - nh_map_str_int32_set(hbr_entityrefs_map, "Scaron", 0x160); - nh_map_str_int32_set(hbr_entityrefs_map, "Scedil", 0x15e); - nh_map_str_int32_set(hbr_entityrefs_map, "Scirc", 0x15c); - nh_map_str_int32_set(hbr_entityrefs_map, "Scy", 0x421); - nh_map_str_int32_set(hbr_entityrefs_map, "Sfr", 0x1d516); - nh_map_str_int32_set(hbr_entityrefs_map, "ShortDownArrow", 0x2193); - nh_map_str_int32_set(hbr_entityrefs_map, "ShortLeftArrow", 0x2190); - nh_map_str_int32_set(hbr_entityrefs_map, "ShortRightArrow", 0x2192); - nh_map_str_int32_set(hbr_entityrefs_map, "ShortUpArrow", 0x2191); - nh_map_str_int32_set(hbr_entityrefs_map, "Sigma", 0x3a3); - nh_map_str_int32_set(hbr_entityrefs_map, "SmallCircle", 0x2218); - nh_map_str_int32_set(hbr_entityrefs_map, "Sopf", 0x1d54a); - nh_map_str_int32_set(hbr_entityrefs_map, "Sqrt", 0x221a); - nh_map_str_int32_set(hbr_entityrefs_map, "Square", 0x25a1); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareIntersection", 0x2293); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareSubset", 0x228f); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareSubsetEqual", 0x2291); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareSuperset", 0x2290); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareSupersetEqual", 0x2292); - nh_map_str_int32_set(hbr_entityrefs_map, "SquareUnion", 0x2294); - nh_map_str_int32_set(hbr_entityrefs_map, "Sscr", 0x1d4ae); - nh_map_str_int32_set(hbr_entityrefs_map, "Star", 0x22c6); - nh_map_str_int32_set(hbr_entityrefs_map, "Sub", 0x22d0); - nh_map_str_int32_set(hbr_entityrefs_map, "Subset", 0x22d0); - nh_map_str_int32_set(hbr_entityrefs_map, "SubsetEqual", 0x2286); - nh_map_str_int32_set(hbr_entityrefs_map, "Succeeds", 0x227b); - nh_map_str_int32_set(hbr_entityrefs_map, "SucceedsEqual", 0x2ab0); - nh_map_str_int32_set(hbr_entityrefs_map, "SucceedsSlantEqual", 0x227d); - nh_map_str_int32_set(hbr_entityrefs_map, "SucceedsTilde", 0x227f); - nh_map_str_int32_set(hbr_entityrefs_map, "SuchThat", 0x220b); - nh_map_str_int32_set(hbr_entityrefs_map, "Sum", 0x2211); - nh_map_str_int32_set(hbr_entityrefs_map, "Sup", 0x22d1); - nh_map_str_int32_set(hbr_entityrefs_map, "Superset", 0x2283); - nh_map_str_int32_set(hbr_entityrefs_map, "SupersetEqual", 0x2287); - nh_map_str_int32_set(hbr_entityrefs_map, "Supset", 0x22d1); - nh_map_str_int32_set(hbr_entityrefs_map, "THORN", 0xde); - nh_map_str_int32_set(hbr_entityrefs_map, "TRADE", 0x2122); - nh_map_str_int32_set(hbr_entityrefs_map, "TSHcy", 0x40b); - nh_map_str_int32_set(hbr_entityrefs_map, "TScy", 0x426); - nh_map_str_int32_set(hbr_entityrefs_map, "Tab", 0x9); - nh_map_str_int32_set(hbr_entityrefs_map, "Tau", 0x3a4); - nh_map_str_int32_set(hbr_entityrefs_map, "Tcaron", 0x164); - nh_map_str_int32_set(hbr_entityrefs_map, "Tcedil", 0x162); - nh_map_str_int32_set(hbr_entityrefs_map, "Tcy", 0x422); - nh_map_str_int32_set(hbr_entityrefs_map, "Tfr", 0x1d517); - nh_map_str_int32_set(hbr_entityrefs_map, "Therefore", 0x2234); - nh_map_str_int32_set(hbr_entityrefs_map, "Theta", 0x398); - nh_map_str_int32_set(hbr_entityrefs_map, "ThinSpace", 0x2009); - nh_map_str_int32_set(hbr_entityrefs_map, "Tilde", 0x223c); - nh_map_str_int32_set(hbr_entityrefs_map, "TildeEqual", 0x2243); - nh_map_str_int32_set(hbr_entityrefs_map, "TildeFullEqual", 0x2245); - nh_map_str_int32_set(hbr_entityrefs_map, "TildeTilde", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "Topf", 0x1d54b); - nh_map_str_int32_set(hbr_entityrefs_map, "TripleDot", 0x20db); - nh_map_str_int32_set(hbr_entityrefs_map, "Tscr", 0x1d4af); - nh_map_str_int32_set(hbr_entityrefs_map, "Tstrok", 0x166); - nh_map_str_int32_set(hbr_entityrefs_map, "Uacute", 0xda); - nh_map_str_int32_set(hbr_entityrefs_map, "Uarr", 0x219f); - nh_map_str_int32_set(hbr_entityrefs_map, "Uarrocir", 0x2949); - nh_map_str_int32_set(hbr_entityrefs_map, "Ubrcy", 0x40e); - nh_map_str_int32_set(hbr_entityrefs_map, "Ubreve", 0x16c); - nh_map_str_int32_set(hbr_entityrefs_map, "Ucirc", 0xdb); - nh_map_str_int32_set(hbr_entityrefs_map, "Ucy", 0x423); - nh_map_str_int32_set(hbr_entityrefs_map, "Udblac", 0x170); - nh_map_str_int32_set(hbr_entityrefs_map, "Ufr", 0x1d518); - nh_map_str_int32_set(hbr_entityrefs_map, "Ugrave", 0xd9); - nh_map_str_int32_set(hbr_entityrefs_map, "Umacr", 0x16a); - nh_map_str_int32_set(hbr_entityrefs_map, "UnderBar", 0x332); - nh_map_str_int32_set(hbr_entityrefs_map, "UnderBrace", 0x23df); - nh_map_str_int32_set(hbr_entityrefs_map, "UnderBracket", 0x23b5); - nh_map_str_int32_set(hbr_entityrefs_map, "UnderParenthesis", 0x23dd); - nh_map_str_int32_set(hbr_entityrefs_map, "Union", 0x22c3); - nh_map_str_int32_set(hbr_entityrefs_map, "UnionPlus", 0x228e); - nh_map_str_int32_set(hbr_entityrefs_map, "Uogon", 0x172); - nh_map_str_int32_set(hbr_entityrefs_map, "Uopf", 0x1d54c); - nh_map_str_int32_set(hbr_entityrefs_map, "UpArrow", 0x2191); - nh_map_str_int32_set(hbr_entityrefs_map, "UpArrowBar", 0x2912); - nh_map_str_int32_set(hbr_entityrefs_map, "UpArrowDownArrow", 0x21c5); - nh_map_str_int32_set(hbr_entityrefs_map, "UpDownArrow", 0x2195); - nh_map_str_int32_set(hbr_entityrefs_map, "UpEquilibrium", 0x296e); - nh_map_str_int32_set(hbr_entityrefs_map, "UpTee", 0x22a5); - nh_map_str_int32_set(hbr_entityrefs_map, "UpTeeArrow", 0x21a5); - nh_map_str_int32_set(hbr_entityrefs_map, "Uparrow", 0x21d1); - nh_map_str_int32_set(hbr_entityrefs_map, "Updownarrow", 0x21d5); - nh_map_str_int32_set(hbr_entityrefs_map, "UpperLeftArrow", 0x2196); - nh_map_str_int32_set(hbr_entityrefs_map, "UpperRightArrow", 0x2197); - nh_map_str_int32_set(hbr_entityrefs_map, "Upsi", 0x3d2); - nh_map_str_int32_set(hbr_entityrefs_map, "Upsilon", 0x3a5); - nh_map_str_int32_set(hbr_entityrefs_map, "Uring", 0x16e); - nh_map_str_int32_set(hbr_entityrefs_map, "Uscr", 0x1d4b0); - nh_map_str_int32_set(hbr_entityrefs_map, "Utilde", 0x168); - nh_map_str_int32_set(hbr_entityrefs_map, "Uuml", 0xdc); - nh_map_str_int32_set(hbr_entityrefs_map, "VDash", 0x22ab); - nh_map_str_int32_set(hbr_entityrefs_map, "Vbar", 0x2aeb); - nh_map_str_int32_set(hbr_entityrefs_map, "Vcy", 0x412); - nh_map_str_int32_set(hbr_entityrefs_map, "Vdash", 0x22a9); - nh_map_str_int32_set(hbr_entityrefs_map, "Vdashl", 0x2ae6); - nh_map_str_int32_set(hbr_entityrefs_map, "Vee", 0x22c1); - nh_map_str_int32_set(hbr_entityrefs_map, "Verbar", 0x2016); - nh_map_str_int32_set(hbr_entityrefs_map, "Vert", 0x2016); - nh_map_str_int32_set(hbr_entityrefs_map, "VerticalBar", 0x2223); - nh_map_str_int32_set(hbr_entityrefs_map, "VerticalLine", 0x7c); - nh_map_str_int32_set(hbr_entityrefs_map, "VerticalSeparator", 0x2758); - nh_map_str_int32_set(hbr_entityrefs_map, "VerticalTilde", 0x2240); - nh_map_str_int32_set(hbr_entityrefs_map, "VeryThinSpace", 0x200a); - nh_map_str_int32_set(hbr_entityrefs_map, "Vfr", 0x1d519); - nh_map_str_int32_set(hbr_entityrefs_map, "Vopf", 0x1d54d); - nh_map_str_int32_set(hbr_entityrefs_map, "Vscr", 0x1d4b1); - nh_map_str_int32_set(hbr_entityrefs_map, "Vvdash", 0x22aa); - nh_map_str_int32_set(hbr_entityrefs_map, "Wcirc", 0x174); - nh_map_str_int32_set(hbr_entityrefs_map, "Wedge", 0x22c0); - nh_map_str_int32_set(hbr_entityrefs_map, "Wfr", 0x1d51a); - nh_map_str_int32_set(hbr_entityrefs_map, "Wopf", 0x1d54e); - nh_map_str_int32_set(hbr_entityrefs_map, "Wscr", 0x1d4b2); - nh_map_str_int32_set(hbr_entityrefs_map, "Xfr", 0x1d51b); - nh_map_str_int32_set(hbr_entityrefs_map, "Xi", 0x39e); - nh_map_str_int32_set(hbr_entityrefs_map, "Xopf", 0x1d54f); - nh_map_str_int32_set(hbr_entityrefs_map, "Xscr", 0x1d4b3); - nh_map_str_int32_set(hbr_entityrefs_map, "YAcy", 0x42f); - nh_map_str_int32_set(hbr_entityrefs_map, "YIcy", 0x407); - nh_map_str_int32_set(hbr_entityrefs_map, "YUcy", 0x42e); - nh_map_str_int32_set(hbr_entityrefs_map, "Yacute", 0xdd); - nh_map_str_int32_set(hbr_entityrefs_map, "Ycirc", 0x176); - nh_map_str_int32_set(hbr_entityrefs_map, "Ycy", 0x42b); - nh_map_str_int32_set(hbr_entityrefs_map, "Yfr", 0x1d51c); - nh_map_str_int32_set(hbr_entityrefs_map, "Yopf", 0x1d550); - nh_map_str_int32_set(hbr_entityrefs_map, "Yscr", 0x1d4b4); - nh_map_str_int32_set(hbr_entityrefs_map, "Yuml", 0x178); - nh_map_str_int32_set(hbr_entityrefs_map, "ZHcy", 0x416); - nh_map_str_int32_set(hbr_entityrefs_map, "Zacute", 0x179); - nh_map_str_int32_set(hbr_entityrefs_map, "Zcaron", 0x17d); - nh_map_str_int32_set(hbr_entityrefs_map, "Zcy", 0x417); - nh_map_str_int32_set(hbr_entityrefs_map, "Zdot", 0x17b); - nh_map_str_int32_set(hbr_entityrefs_map, "ZeroWidthSpace", 0x200b); - nh_map_str_int32_set(hbr_entityrefs_map, "Zeta", 0x396); - nh_map_str_int32_set(hbr_entityrefs_map, "Zfr", 0x2128); - nh_map_str_int32_set(hbr_entityrefs_map, "Zopf", 0x2124); - nh_map_str_int32_set(hbr_entityrefs_map, "Zscr", 0x1d4b5); - nh_map_str_int32_set(hbr_entityrefs_map, "aacute", 0xe1); - nh_map_str_int32_set(hbr_entityrefs_map, "abreve", 0x103); - nh_map_str_int32_set(hbr_entityrefs_map, "ac", 0x223e); - nh_map_str_int32_set(hbr_entityrefs_map, "acd", 0x223f); - nh_map_str_int32_set(hbr_entityrefs_map, "acirc", 0xe2); - nh_map_str_int32_set(hbr_entityrefs_map, "acute", 0xb4); - nh_map_str_int32_set(hbr_entityrefs_map, "acy", 0x430); - nh_map_str_int32_set(hbr_entityrefs_map, "aelig", 0xe6); - nh_map_str_int32_set(hbr_entityrefs_map, "af", 0x2061); - nh_map_str_int32_set(hbr_entityrefs_map, "afr", 0x1d51e); - nh_map_str_int32_set(hbr_entityrefs_map, "agrave", 0xe0); - nh_map_str_int32_set(hbr_entityrefs_map, "alefsym", 0x2135); - nh_map_str_int32_set(hbr_entityrefs_map, "aleph", 0x2135); - nh_map_str_int32_set(hbr_entityrefs_map, "alpha", 0x3b1); - nh_map_str_int32_set(hbr_entityrefs_map, "amacr", 0x101); - nh_map_str_int32_set(hbr_entityrefs_map, "amalg", 0x2a3f); - nh_map_str_int32_set(hbr_entityrefs_map, "amp", 0x26); - nh_map_str_int32_set(hbr_entityrefs_map, "and", 0x2227); - nh_map_str_int32_set(hbr_entityrefs_map, "andand", 0x2a55); - nh_map_str_int32_set(hbr_entityrefs_map, "andd", 0x2a5c); - nh_map_str_int32_set(hbr_entityrefs_map, "andslope", 0x2a58); - nh_map_str_int32_set(hbr_entityrefs_map, "andv", 0x2a5a); - nh_map_str_int32_set(hbr_entityrefs_map, "ang", 0x2220); - nh_map_str_int32_set(hbr_entityrefs_map, "ange", 0x29a4); - nh_map_str_int32_set(hbr_entityrefs_map, "angle", 0x2220); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsd", 0x2221); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdaa", 0x29a8); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdab", 0x29a9); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdac", 0x29aa); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdad", 0x29ab); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdae", 0x29ac); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdaf", 0x29ad); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdag", 0x29ae); - nh_map_str_int32_set(hbr_entityrefs_map, "angmsdah", 0x29af); - nh_map_str_int32_set(hbr_entityrefs_map, "angrt", 0x221f); - nh_map_str_int32_set(hbr_entityrefs_map, "angrtvb", 0x22be); - nh_map_str_int32_set(hbr_entityrefs_map, "angrtvbd", 0x299d); - nh_map_str_int32_set(hbr_entityrefs_map, "angsph", 0x2222); - nh_map_str_int32_set(hbr_entityrefs_map, "angst", 0x212b); - nh_map_str_int32_set(hbr_entityrefs_map, "angzarr", 0x237c); - nh_map_str_int32_set(hbr_entityrefs_map, "aogon", 0x105); - nh_map_str_int32_set(hbr_entityrefs_map, "aopf", 0x1d552); - nh_map_str_int32_set(hbr_entityrefs_map, "ap", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "apE", 0x2a70); - nh_map_str_int32_set(hbr_entityrefs_map, "apacir", 0x2a6f); - nh_map_str_int32_set(hbr_entityrefs_map, "ape", 0x224a); - nh_map_str_int32_set(hbr_entityrefs_map, "apid", 0x224b); - nh_map_str_int32_set(hbr_entityrefs_map, "apos", 0x27); - nh_map_str_int32_set(hbr_entityrefs_map, "approx", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "approxeq", 0x224a); - nh_map_str_int32_set(hbr_entityrefs_map, "aring", 0xe5); - nh_map_str_int32_set(hbr_entityrefs_map, "ascr", 0x1d4b6); - nh_map_str_int32_set(hbr_entityrefs_map, "ast", 0x2a); - nh_map_str_int32_set(hbr_entityrefs_map, "asymp", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "asympeq", 0x224d); - nh_map_str_int32_set(hbr_entityrefs_map, "atilde", 0xe3); - nh_map_str_int32_set(hbr_entityrefs_map, "auml", 0xe4); - nh_map_str_int32_set(hbr_entityrefs_map, "awconint", 0x2233); - nh_map_str_int32_set(hbr_entityrefs_map, "awint", 0x2a11); - nh_map_str_int32_set(hbr_entityrefs_map, "bNot", 0x2aed); - nh_map_str_int32_set(hbr_entityrefs_map, "backcong", 0x224c); - nh_map_str_int32_set(hbr_entityrefs_map, "backepsilon", 0x3f6); - nh_map_str_int32_set(hbr_entityrefs_map, "backprime", 0x2035); - nh_map_str_int32_set(hbr_entityrefs_map, "backsim", 0x223d); - nh_map_str_int32_set(hbr_entityrefs_map, "backsimeq", 0x22cd); - nh_map_str_int32_set(hbr_entityrefs_map, "barvee", 0x22bd); - nh_map_str_int32_set(hbr_entityrefs_map, "barwed", 0x2305); - nh_map_str_int32_set(hbr_entityrefs_map, "barwedge", 0x2305); - nh_map_str_int32_set(hbr_entityrefs_map, "bbrk", 0x23b5); - nh_map_str_int32_set(hbr_entityrefs_map, "bbrktbrk", 0x23b6); - nh_map_str_int32_set(hbr_entityrefs_map, "bcong", 0x224c); - nh_map_str_int32_set(hbr_entityrefs_map, "bcy", 0x431); - nh_map_str_int32_set(hbr_entityrefs_map, "bdquo", 0x201e); - nh_map_str_int32_set(hbr_entityrefs_map, "becaus", 0x2235); - nh_map_str_int32_set(hbr_entityrefs_map, "because", 0x2235); - nh_map_str_int32_set(hbr_entityrefs_map, "bemptyv", 0x29b0); - nh_map_str_int32_set(hbr_entityrefs_map, "bepsi", 0x3f6); - nh_map_str_int32_set(hbr_entityrefs_map, "bernou", 0x212c); - nh_map_str_int32_set(hbr_entityrefs_map, "beta", 0x3b2); - nh_map_str_int32_set(hbr_entityrefs_map, "beth", 0x2136); - nh_map_str_int32_set(hbr_entityrefs_map, "between", 0x226c); - nh_map_str_int32_set(hbr_entityrefs_map, "bfr", 0x1d51f); - nh_map_str_int32_set(hbr_entityrefs_map, "bigcap", 0x22c2); - nh_map_str_int32_set(hbr_entityrefs_map, "bigcirc", 0x25ef); - nh_map_str_int32_set(hbr_entityrefs_map, "bigcup", 0x22c3); - nh_map_str_int32_set(hbr_entityrefs_map, "bigodot", 0x2a00); - nh_map_str_int32_set(hbr_entityrefs_map, "bigoplus", 0x2a01); - nh_map_str_int32_set(hbr_entityrefs_map, "bigotimes", 0x2a02); - nh_map_str_int32_set(hbr_entityrefs_map, "bigsqcup", 0x2a06); - nh_map_str_int32_set(hbr_entityrefs_map, "bigstar", 0x2605); - nh_map_str_int32_set(hbr_entityrefs_map, "bigtriangledown", 0x25bd); - nh_map_str_int32_set(hbr_entityrefs_map, "bigtriangleup", 0x25b3); - nh_map_str_int32_set(hbr_entityrefs_map, "biguplus", 0x2a04); - nh_map_str_int32_set(hbr_entityrefs_map, "bigvee", 0x22c1); - nh_map_str_int32_set(hbr_entityrefs_map, "bigwedge", 0x22c0); - nh_map_str_int32_set(hbr_entityrefs_map, "bkarow", 0x290d); - nh_map_str_int32_set(hbr_entityrefs_map, "blacklozenge", 0x29eb); - nh_map_str_int32_set(hbr_entityrefs_map, "blacksquare", 0x25aa); - nh_map_str_int32_set(hbr_entityrefs_map, "blacktriangle", 0x25b4); - nh_map_str_int32_set(hbr_entityrefs_map, "blacktriangledown", 0x25be); - nh_map_str_int32_set(hbr_entityrefs_map, "blacktriangleleft", 0x25c2); - nh_map_str_int32_set(hbr_entityrefs_map, "blacktriangleright", 0x25b8); - nh_map_str_int32_set(hbr_entityrefs_map, "blank", 0x2423); - nh_map_str_int32_set(hbr_entityrefs_map, "blk12", 0x2592); - nh_map_str_int32_set(hbr_entityrefs_map, "blk14", 0x2591); - nh_map_str_int32_set(hbr_entityrefs_map, "blk34", 0x2593); - nh_map_str_int32_set(hbr_entityrefs_map, "block", 0x2588); - nh_map_str_int32_set(hbr_entityrefs_map, "bnot", 0x2310); - nh_map_str_int32_set(hbr_entityrefs_map, "bopf", 0x1d553); - nh_map_str_int32_set(hbr_entityrefs_map, "bot", 0x22a5); - nh_map_str_int32_set(hbr_entityrefs_map, "bottom", 0x22a5); - nh_map_str_int32_set(hbr_entityrefs_map, "bowtie", 0x22c8); - nh_map_str_int32_set(hbr_entityrefs_map, "boxDL", 0x2557); - nh_map_str_int32_set(hbr_entityrefs_map, "boxDR", 0x2554); - nh_map_str_int32_set(hbr_entityrefs_map, "boxDl", 0x2556); - nh_map_str_int32_set(hbr_entityrefs_map, "boxDr", 0x2553); - nh_map_str_int32_set(hbr_entityrefs_map, "boxH", 0x2550); - nh_map_str_int32_set(hbr_entityrefs_map, "boxHD", 0x2566); - nh_map_str_int32_set(hbr_entityrefs_map, "boxHU", 0x2569); - nh_map_str_int32_set(hbr_entityrefs_map, "boxHd", 0x2564); - nh_map_str_int32_set(hbr_entityrefs_map, "boxHu", 0x2567); - nh_map_str_int32_set(hbr_entityrefs_map, "boxUL", 0x255d); - nh_map_str_int32_set(hbr_entityrefs_map, "boxUR", 0x255a); - nh_map_str_int32_set(hbr_entityrefs_map, "boxUl", 0x255c); - nh_map_str_int32_set(hbr_entityrefs_map, "boxUr", 0x2559); - nh_map_str_int32_set(hbr_entityrefs_map, "boxV", 0x2551); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVH", 0x256c); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVL", 0x2563); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVR", 0x2560); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVh", 0x256b); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVl", 0x2562); - nh_map_str_int32_set(hbr_entityrefs_map, "boxVr", 0x255f); - nh_map_str_int32_set(hbr_entityrefs_map, "boxbox", 0x29c9); - nh_map_str_int32_set(hbr_entityrefs_map, "boxdL", 0x2555); - nh_map_str_int32_set(hbr_entityrefs_map, "boxdR", 0x2552); - nh_map_str_int32_set(hbr_entityrefs_map, "boxdl", 0x2510); - nh_map_str_int32_set(hbr_entityrefs_map, "boxdr", 0x250c); - nh_map_str_int32_set(hbr_entityrefs_map, "boxh", 0x2500); - nh_map_str_int32_set(hbr_entityrefs_map, "boxhD", 0x2565); - nh_map_str_int32_set(hbr_entityrefs_map, "boxhU", 0x2568); - nh_map_str_int32_set(hbr_entityrefs_map, "boxhd", 0x252c); - nh_map_str_int32_set(hbr_entityrefs_map, "boxhu", 0x2534); - nh_map_str_int32_set(hbr_entityrefs_map, "boxminus", 0x229f); - nh_map_str_int32_set(hbr_entityrefs_map, "boxplus", 0x229e); - nh_map_str_int32_set(hbr_entityrefs_map, "boxtimes", 0x22a0); - nh_map_str_int32_set(hbr_entityrefs_map, "boxuL", 0x255b); - nh_map_str_int32_set(hbr_entityrefs_map, "boxuR", 0x2558); - nh_map_str_int32_set(hbr_entityrefs_map, "boxul", 0x2518); - nh_map_str_int32_set(hbr_entityrefs_map, "boxur", 0x2514); - nh_map_str_int32_set(hbr_entityrefs_map, "boxv", 0x2502); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvH", 0x256a); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvL", 0x2561); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvR", 0x255e); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvh", 0x253c); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvl", 0x2524); - nh_map_str_int32_set(hbr_entityrefs_map, "boxvr", 0x251c); - nh_map_str_int32_set(hbr_entityrefs_map, "bprime", 0x2035); - nh_map_str_int32_set(hbr_entityrefs_map, "breve", 0x2d8); - nh_map_str_int32_set(hbr_entityrefs_map, "brvbar", 0xa6); - nh_map_str_int32_set(hbr_entityrefs_map, "bscr", 0x1d4b7); - nh_map_str_int32_set(hbr_entityrefs_map, "bsemi", 0x204f); - nh_map_str_int32_set(hbr_entityrefs_map, "bsim", 0x223d); - nh_map_str_int32_set(hbr_entityrefs_map, "bsime", 0x22cd); - nh_map_str_int32_set(hbr_entityrefs_map, "bsol", 0x5c); - nh_map_str_int32_set(hbr_entityrefs_map, "bsolb", 0x29c5); - nh_map_str_int32_set(hbr_entityrefs_map, "bull", 0x2022); - nh_map_str_int32_set(hbr_entityrefs_map, "bullet", 0x2022); - nh_map_str_int32_set(hbr_entityrefs_map, "bump", 0x224e); - nh_map_str_int32_set(hbr_entityrefs_map, "bumpE", 0x2aae); - nh_map_str_int32_set(hbr_entityrefs_map, "bumpe", 0x224f); - nh_map_str_int32_set(hbr_entityrefs_map, "bumpeq", 0x224f); - nh_map_str_int32_set(hbr_entityrefs_map, "cacute", 0x107); - nh_map_str_int32_set(hbr_entityrefs_map, "cap", 0x2229); - nh_map_str_int32_set(hbr_entityrefs_map, "capand", 0x2a44); - nh_map_str_int32_set(hbr_entityrefs_map, "capbrcup", 0x2a49); - nh_map_str_int32_set(hbr_entityrefs_map, "capcap", 0x2a4b); - nh_map_str_int32_set(hbr_entityrefs_map, "capcup", 0x2a47); - nh_map_str_int32_set(hbr_entityrefs_map, "capdot", 0x2a40); - nh_map_str_int32_set(hbr_entityrefs_map, "caret", 0x2041); - nh_map_str_int32_set(hbr_entityrefs_map, "caron", 0x2c7); - nh_map_str_int32_set(hbr_entityrefs_map, "ccaps", 0x2a4d); - nh_map_str_int32_set(hbr_entityrefs_map, "ccaron", 0x10d); - nh_map_str_int32_set(hbr_entityrefs_map, "ccedil", 0xe7); - nh_map_str_int32_set(hbr_entityrefs_map, "ccirc", 0x109); - nh_map_str_int32_set(hbr_entityrefs_map, "ccups", 0x2a4c); - nh_map_str_int32_set(hbr_entityrefs_map, "ccupssm", 0x2a50); - nh_map_str_int32_set(hbr_entityrefs_map, "cdot", 0x10b); - nh_map_str_int32_set(hbr_entityrefs_map, "cedil", 0xb8); - nh_map_str_int32_set(hbr_entityrefs_map, "cemptyv", 0x29b2); - nh_map_str_int32_set(hbr_entityrefs_map, "cent", 0xa2); - nh_map_str_int32_set(hbr_entityrefs_map, "centerdot", 0xb7); - nh_map_str_int32_set(hbr_entityrefs_map, "cfr", 0x1d520); - nh_map_str_int32_set(hbr_entityrefs_map, "chcy", 0x447); - nh_map_str_int32_set(hbr_entityrefs_map, "check", 0x2713); - nh_map_str_int32_set(hbr_entityrefs_map, "checkmark", 0x2713); - nh_map_str_int32_set(hbr_entityrefs_map, "chi", 0x3c7); - nh_map_str_int32_set(hbr_entityrefs_map, "cir", 0x25cb); - nh_map_str_int32_set(hbr_entityrefs_map, "cirE", 0x29c3); - nh_map_str_int32_set(hbr_entityrefs_map, "circ", 0x2c6); - nh_map_str_int32_set(hbr_entityrefs_map, "circeq", 0x2257); - nh_map_str_int32_set(hbr_entityrefs_map, "circlearrowleft", 0x21ba); - nh_map_str_int32_set(hbr_entityrefs_map, "circlearrowright", 0x21bb); - nh_map_str_int32_set(hbr_entityrefs_map, "circledR", 0xae); - nh_map_str_int32_set(hbr_entityrefs_map, "circledS", 0x24c8); - nh_map_str_int32_set(hbr_entityrefs_map, "circledast", 0x229b); - nh_map_str_int32_set(hbr_entityrefs_map, "circledcirc", 0x229a); - nh_map_str_int32_set(hbr_entityrefs_map, "circleddash", 0x229d); - nh_map_str_int32_set(hbr_entityrefs_map, "cire", 0x2257); - nh_map_str_int32_set(hbr_entityrefs_map, "cirfnint", 0x2a10); - nh_map_str_int32_set(hbr_entityrefs_map, "cirmid", 0x2aef); - nh_map_str_int32_set(hbr_entityrefs_map, "cirscir", 0x29c2); - nh_map_str_int32_set(hbr_entityrefs_map, "clubs", 0x2663); - nh_map_str_int32_set(hbr_entityrefs_map, "clubsuit", 0x2663); - nh_map_str_int32_set(hbr_entityrefs_map, "colon", 0x3a); - nh_map_str_int32_set(hbr_entityrefs_map, "colone", 0x2254); - nh_map_str_int32_set(hbr_entityrefs_map, "coloneq", 0x2254); - nh_map_str_int32_set(hbr_entityrefs_map, "comma", 0x2c); - nh_map_str_int32_set(hbr_entityrefs_map, "commat", 0x40); - nh_map_str_int32_set(hbr_entityrefs_map, "comp", 0x2201); - nh_map_str_int32_set(hbr_entityrefs_map, "compfn", 0x2218); - nh_map_str_int32_set(hbr_entityrefs_map, "complement", 0x2201); - nh_map_str_int32_set(hbr_entityrefs_map, "complexes", 0x2102); - nh_map_str_int32_set(hbr_entityrefs_map, "cong", 0x2245); - nh_map_str_int32_set(hbr_entityrefs_map, "congdot", 0x2a6d); - nh_map_str_int32_set(hbr_entityrefs_map, "conint", 0x222e); - nh_map_str_int32_set(hbr_entityrefs_map, "copf", 0x1d554); - nh_map_str_int32_set(hbr_entityrefs_map, "coprod", 0x2210); - nh_map_str_int32_set(hbr_entityrefs_map, "copy", 0xa9); - nh_map_str_int32_set(hbr_entityrefs_map, "copysr", 0x2117); - nh_map_str_int32_set(hbr_entityrefs_map, "crarr", 0x21b5); - nh_map_str_int32_set(hbr_entityrefs_map, "cross", 0x2717); - nh_map_str_int32_set(hbr_entityrefs_map, "cscr", 0x1d4b8); - nh_map_str_int32_set(hbr_entityrefs_map, "csub", 0x2acf); - nh_map_str_int32_set(hbr_entityrefs_map, "csube", 0x2ad1); - nh_map_str_int32_set(hbr_entityrefs_map, "csup", 0x2ad0); - nh_map_str_int32_set(hbr_entityrefs_map, "csupe", 0x2ad2); - nh_map_str_int32_set(hbr_entityrefs_map, "ctdot", 0x22ef); - nh_map_str_int32_set(hbr_entityrefs_map, "cudarrl", 0x2938); - nh_map_str_int32_set(hbr_entityrefs_map, "cudarrr", 0x2935); - nh_map_str_int32_set(hbr_entityrefs_map, "cuepr", 0x22de); - nh_map_str_int32_set(hbr_entityrefs_map, "cuesc", 0x22df); - nh_map_str_int32_set(hbr_entityrefs_map, "cularr", 0x21b6); - nh_map_str_int32_set(hbr_entityrefs_map, "cularrp", 0x293d); - nh_map_str_int32_set(hbr_entityrefs_map, "cup", 0x222a); - nh_map_str_int32_set(hbr_entityrefs_map, "cupbrcap", 0x2a48); - nh_map_str_int32_set(hbr_entityrefs_map, "cupcap", 0x2a46); - nh_map_str_int32_set(hbr_entityrefs_map, "cupcup", 0x2a4a); - nh_map_str_int32_set(hbr_entityrefs_map, "cupdot", 0x228d); - nh_map_str_int32_set(hbr_entityrefs_map, "cupor", 0x2a45); - nh_map_str_int32_set(hbr_entityrefs_map, "curarr", 0x21b7); - nh_map_str_int32_set(hbr_entityrefs_map, "curarrm", 0x293c); - nh_map_str_int32_set(hbr_entityrefs_map, "curlyeqprec", 0x22de); - nh_map_str_int32_set(hbr_entityrefs_map, "curlyeqsucc", 0x22df); - nh_map_str_int32_set(hbr_entityrefs_map, "curlyvee", 0x22ce); - nh_map_str_int32_set(hbr_entityrefs_map, "curlywedge", 0x22cf); - nh_map_str_int32_set(hbr_entityrefs_map, "curren", 0xa4); - nh_map_str_int32_set(hbr_entityrefs_map, "curvearrowleft", 0x21b6); - nh_map_str_int32_set(hbr_entityrefs_map, "curvearrowright", 0x21b7); - nh_map_str_int32_set(hbr_entityrefs_map, "cuvee", 0x22ce); - nh_map_str_int32_set(hbr_entityrefs_map, "cuwed", 0x22cf); - nh_map_str_int32_set(hbr_entityrefs_map, "cwconint", 0x2232); - nh_map_str_int32_set(hbr_entityrefs_map, "cwint", 0x2231); - nh_map_str_int32_set(hbr_entityrefs_map, "cylcty", 0x232d); - nh_map_str_int32_set(hbr_entityrefs_map, "dArr", 0x21d3); - nh_map_str_int32_set(hbr_entityrefs_map, "dHar", 0x2965); - nh_map_str_int32_set(hbr_entityrefs_map, "dagger", 0x2020); - nh_map_str_int32_set(hbr_entityrefs_map, "daleth", 0x2138); - nh_map_str_int32_set(hbr_entityrefs_map, "darr", 0x2193); - nh_map_str_int32_set(hbr_entityrefs_map, "dash", 0x2010); - nh_map_str_int32_set(hbr_entityrefs_map, "dashv", 0x22a3); - nh_map_str_int32_set(hbr_entityrefs_map, "dbkarow", 0x290f); - nh_map_str_int32_set(hbr_entityrefs_map, "dblac", 0x2dd); - nh_map_str_int32_set(hbr_entityrefs_map, "dcaron", 0x10f); - nh_map_str_int32_set(hbr_entityrefs_map, "dcy", 0x434); - nh_map_str_int32_set(hbr_entityrefs_map, "dd", 0x2146); - nh_map_str_int32_set(hbr_entityrefs_map, "ddagger", 0x2021); - nh_map_str_int32_set(hbr_entityrefs_map, "ddarr", 0x21ca); - nh_map_str_int32_set(hbr_entityrefs_map, "ddotseq", 0x2a77); - nh_map_str_int32_set(hbr_entityrefs_map, "deg", 0xb0); - nh_map_str_int32_set(hbr_entityrefs_map, "delta", 0x3b4); - nh_map_str_int32_set(hbr_entityrefs_map, "demptyv", 0x29b1); - nh_map_str_int32_set(hbr_entityrefs_map, "dfisht", 0x297f); - nh_map_str_int32_set(hbr_entityrefs_map, "dfr", 0x1d521); - nh_map_str_int32_set(hbr_entityrefs_map, "dharl", 0x21c3); - nh_map_str_int32_set(hbr_entityrefs_map, "dharr", 0x21c2); - nh_map_str_int32_set(hbr_entityrefs_map, "diam", 0x22c4); - nh_map_str_int32_set(hbr_entityrefs_map, "diamond", 0x22c4); - nh_map_str_int32_set(hbr_entityrefs_map, "diamondsuit", 0x2666); - nh_map_str_int32_set(hbr_entityrefs_map, "diams", 0x2666); - nh_map_str_int32_set(hbr_entityrefs_map, "die", 0xa8); - nh_map_str_int32_set(hbr_entityrefs_map, "digamma", 0x3dd); - nh_map_str_int32_set(hbr_entityrefs_map, "disin", 0x22f2); - nh_map_str_int32_set(hbr_entityrefs_map, "div", 0xf7); - nh_map_str_int32_set(hbr_entityrefs_map, "divide", 0xf7); - nh_map_str_int32_set(hbr_entityrefs_map, "divideontimes", 0x22c7); - nh_map_str_int32_set(hbr_entityrefs_map, "divonx", 0x22c7); - nh_map_str_int32_set(hbr_entityrefs_map, "djcy", 0x452); - nh_map_str_int32_set(hbr_entityrefs_map, "dlcorn", 0x231e); - nh_map_str_int32_set(hbr_entityrefs_map, "dlcrop", 0x230d); - nh_map_str_int32_set(hbr_entityrefs_map, "dollar", 0x24); - nh_map_str_int32_set(hbr_entityrefs_map, "dopf", 0x1d555); - nh_map_str_int32_set(hbr_entityrefs_map, "dot", 0x2d9); - nh_map_str_int32_set(hbr_entityrefs_map, "doteq", 0x2250); - nh_map_str_int32_set(hbr_entityrefs_map, "doteqdot", 0x2251); - nh_map_str_int32_set(hbr_entityrefs_map, "dotminus", 0x2238); - nh_map_str_int32_set(hbr_entityrefs_map, "dotplus", 0x2214); - nh_map_str_int32_set(hbr_entityrefs_map, "dotsquare", 0x22a1); - nh_map_str_int32_set(hbr_entityrefs_map, "doublebarwedge", 0x2306); - nh_map_str_int32_set(hbr_entityrefs_map, "downarrow", 0x2193); - nh_map_str_int32_set(hbr_entityrefs_map, "downdownarrows", 0x21ca); - nh_map_str_int32_set(hbr_entityrefs_map, "downharpoonleft", 0x21c3); - nh_map_str_int32_set(hbr_entityrefs_map, "downharpoonright", 0x21c2); - nh_map_str_int32_set(hbr_entityrefs_map, "drbkarow", 0x2910); - nh_map_str_int32_set(hbr_entityrefs_map, "drcorn", 0x231f); - nh_map_str_int32_set(hbr_entityrefs_map, "drcrop", 0x230c); - nh_map_str_int32_set(hbr_entityrefs_map, "dscr", 0x1d4b9); - nh_map_str_int32_set(hbr_entityrefs_map, "dscy", 0x455); - nh_map_str_int32_set(hbr_entityrefs_map, "dsol", 0x29f6); - nh_map_str_int32_set(hbr_entityrefs_map, "dstrok", 0x111); - nh_map_str_int32_set(hbr_entityrefs_map, "dtdot", 0x22f1); - nh_map_str_int32_set(hbr_entityrefs_map, "dtri", 0x25bf); - nh_map_str_int32_set(hbr_entityrefs_map, "dtrif", 0x25be); - nh_map_str_int32_set(hbr_entityrefs_map, "duarr", 0x21f5); - nh_map_str_int32_set(hbr_entityrefs_map, "duhar", 0x296f); - nh_map_str_int32_set(hbr_entityrefs_map, "dwangle", 0x29a6); - nh_map_str_int32_set(hbr_entityrefs_map, "dzcy", 0x45f); - nh_map_str_int32_set(hbr_entityrefs_map, "dzigrarr", 0x27ff); - nh_map_str_int32_set(hbr_entityrefs_map, "eDDot", 0x2a77); - nh_map_str_int32_set(hbr_entityrefs_map, "eDot", 0x2251); - nh_map_str_int32_set(hbr_entityrefs_map, "eacute", 0xe9); - nh_map_str_int32_set(hbr_entityrefs_map, "easter", 0x2a6e); - nh_map_str_int32_set(hbr_entityrefs_map, "ecaron", 0x11b); - nh_map_str_int32_set(hbr_entityrefs_map, "ecir", 0x2256); - nh_map_str_int32_set(hbr_entityrefs_map, "ecirc", 0xea); - nh_map_str_int32_set(hbr_entityrefs_map, "ecolon", 0x2255); - nh_map_str_int32_set(hbr_entityrefs_map, "ecy", 0x44d); - nh_map_str_int32_set(hbr_entityrefs_map, "edot", 0x117); - nh_map_str_int32_set(hbr_entityrefs_map, "ee", 0x2147); - nh_map_str_int32_set(hbr_entityrefs_map, "efDot", 0x2252); - nh_map_str_int32_set(hbr_entityrefs_map, "efr", 0x1d522); - nh_map_str_int32_set(hbr_entityrefs_map, "eg", 0x2a9a); - nh_map_str_int32_set(hbr_entityrefs_map, "egrave", 0xe8); - nh_map_str_int32_set(hbr_entityrefs_map, "egs", 0x2a96); - nh_map_str_int32_set(hbr_entityrefs_map, "egsdot", 0x2a98); - nh_map_str_int32_set(hbr_entityrefs_map, "el", 0x2a99); - nh_map_str_int32_set(hbr_entityrefs_map, "elinters", 0x23e7); - nh_map_str_int32_set(hbr_entityrefs_map, "ell", 0x2113); - nh_map_str_int32_set(hbr_entityrefs_map, "els", 0x2a95); - nh_map_str_int32_set(hbr_entityrefs_map, "elsdot", 0x2a97); - nh_map_str_int32_set(hbr_entityrefs_map, "emacr", 0x113); - nh_map_str_int32_set(hbr_entityrefs_map, "empty", 0x2205); - nh_map_str_int32_set(hbr_entityrefs_map, "emptyset", 0x2205); - nh_map_str_int32_set(hbr_entityrefs_map, "emptyv", 0x2205); - nh_map_str_int32_set(hbr_entityrefs_map, "emsp", 0x2003); - nh_map_str_int32_set(hbr_entityrefs_map, "emsp13", 0x2004); - nh_map_str_int32_set(hbr_entityrefs_map, "emsp14", 0x2005); - nh_map_str_int32_set(hbr_entityrefs_map, "eng", 0x14b); - nh_map_str_int32_set(hbr_entityrefs_map, "ensp", 0x2002); - nh_map_str_int32_set(hbr_entityrefs_map, "eogon", 0x119); - nh_map_str_int32_set(hbr_entityrefs_map, "eopf", 0x1d556); - nh_map_str_int32_set(hbr_entityrefs_map, "epar", 0x22d5); - nh_map_str_int32_set(hbr_entityrefs_map, "eparsl", 0x29e3); - nh_map_str_int32_set(hbr_entityrefs_map, "eplus", 0x2a71); - nh_map_str_int32_set(hbr_entityrefs_map, "epsi", 0x3f5); - nh_map_str_int32_set(hbr_entityrefs_map, "epsilon", 0x3b5); - nh_map_str_int32_set(hbr_entityrefs_map, "epsiv", 0x3b5); - nh_map_str_int32_set(hbr_entityrefs_map, "eqcirc", 0x2256); - nh_map_str_int32_set(hbr_entityrefs_map, "eqcolon", 0x2255); - nh_map_str_int32_set(hbr_entityrefs_map, "eqsim", 0x2242); - nh_map_str_int32_set(hbr_entityrefs_map, "eqslantgtr", 0x2a96); - nh_map_str_int32_set(hbr_entityrefs_map, "eqslantless", 0x2a95); - nh_map_str_int32_set(hbr_entityrefs_map, "equals", 0x3d); - nh_map_str_int32_set(hbr_entityrefs_map, "equest", 0x225f); - nh_map_str_int32_set(hbr_entityrefs_map, "equiv", 0x2261); - nh_map_str_int32_set(hbr_entityrefs_map, "equivDD", 0x2a78); - nh_map_str_int32_set(hbr_entityrefs_map, "eqvparsl", 0x29e5); - nh_map_str_int32_set(hbr_entityrefs_map, "erDot", 0x2253); - nh_map_str_int32_set(hbr_entityrefs_map, "erarr", 0x2971); - nh_map_str_int32_set(hbr_entityrefs_map, "escr", 0x212f); - nh_map_str_int32_set(hbr_entityrefs_map, "esdot", 0x2250); - nh_map_str_int32_set(hbr_entityrefs_map, "esim", 0x2242); - nh_map_str_int32_set(hbr_entityrefs_map, "eta", 0x3b7); - nh_map_str_int32_set(hbr_entityrefs_map, "eth", 0xf0); - nh_map_str_int32_set(hbr_entityrefs_map, "euml", 0xeb); - nh_map_str_int32_set(hbr_entityrefs_map, "euro", 0x20ac); - nh_map_str_int32_set(hbr_entityrefs_map, "excl", 0x21); - nh_map_str_int32_set(hbr_entityrefs_map, "exist", 0x2203); - nh_map_str_int32_set(hbr_entityrefs_map, "expectation", 0x2130); - nh_map_str_int32_set(hbr_entityrefs_map, "exponentiale", 0x2147); - nh_map_str_int32_set(hbr_entityrefs_map, "fallingdotseq", 0x2252); - nh_map_str_int32_set(hbr_entityrefs_map, "fcy", 0x444); - nh_map_str_int32_set(hbr_entityrefs_map, "female", 0x2640); - nh_map_str_int32_set(hbr_entityrefs_map, "ffilig", 0xfb03); - nh_map_str_int32_set(hbr_entityrefs_map, "fflig", 0xfb00); - nh_map_str_int32_set(hbr_entityrefs_map, "ffllig", 0xfb04); - nh_map_str_int32_set(hbr_entityrefs_map, "ffr", 0x1d523); - nh_map_str_int32_set(hbr_entityrefs_map, "filig", 0xfb01); - nh_map_str_int32_set(hbr_entityrefs_map, "flat", 0x266d); - nh_map_str_int32_set(hbr_entityrefs_map, "fllig", 0xfb02); - nh_map_str_int32_set(hbr_entityrefs_map, "fltns", 0x25b1); - nh_map_str_int32_set(hbr_entityrefs_map, "fnof", 0x192); - nh_map_str_int32_set(hbr_entityrefs_map, "fopf", 0x1d557); - nh_map_str_int32_set(hbr_entityrefs_map, "forall", 0x2200); - nh_map_str_int32_set(hbr_entityrefs_map, "fork", 0x22d4); - nh_map_str_int32_set(hbr_entityrefs_map, "forkv", 0x2ad9); - nh_map_str_int32_set(hbr_entityrefs_map, "fpartint", 0x2a0d); - nh_map_str_int32_set(hbr_entityrefs_map, "frac12", 0xbd); - nh_map_str_int32_set(hbr_entityrefs_map, "frac13", 0x2153); - nh_map_str_int32_set(hbr_entityrefs_map, "frac14", 0xbc); - nh_map_str_int32_set(hbr_entityrefs_map, "frac15", 0x2155); - nh_map_str_int32_set(hbr_entityrefs_map, "frac16", 0x2159); - nh_map_str_int32_set(hbr_entityrefs_map, "frac18", 0x215b); - nh_map_str_int32_set(hbr_entityrefs_map, "frac23", 0x2154); - nh_map_str_int32_set(hbr_entityrefs_map, "frac25", 0x2156); - nh_map_str_int32_set(hbr_entityrefs_map, "frac34", 0xbe); - nh_map_str_int32_set(hbr_entityrefs_map, "frac35", 0x2157); - nh_map_str_int32_set(hbr_entityrefs_map, "frac38", 0x215c); - nh_map_str_int32_set(hbr_entityrefs_map, "frac45", 0x2158); - nh_map_str_int32_set(hbr_entityrefs_map, "frac56", 0x215a); - nh_map_str_int32_set(hbr_entityrefs_map, "frac58", 0x215d); - nh_map_str_int32_set(hbr_entityrefs_map, "frac78", 0x215e); - nh_map_str_int32_set(hbr_entityrefs_map, "frasl", 0x2044); - nh_map_str_int32_set(hbr_entityrefs_map, "frown", 0x2322); - nh_map_str_int32_set(hbr_entityrefs_map, "fscr", 0x1d4bb); - nh_map_str_int32_set(hbr_entityrefs_map, "gE", 0x2267); - nh_map_str_int32_set(hbr_entityrefs_map, "gEl", 0x2a8c); - nh_map_str_int32_set(hbr_entityrefs_map, "gacute", 0x1f5); - nh_map_str_int32_set(hbr_entityrefs_map, "gamma", 0x3b3); - nh_map_str_int32_set(hbr_entityrefs_map, "gammad", 0x3dd); - nh_map_str_int32_set(hbr_entityrefs_map, "gap", 0x2a86); - nh_map_str_int32_set(hbr_entityrefs_map, "gbreve", 0x11f); - nh_map_str_int32_set(hbr_entityrefs_map, "gcirc", 0x11d); - nh_map_str_int32_set(hbr_entityrefs_map, "gcy", 0x433); - nh_map_str_int32_set(hbr_entityrefs_map, "gdot", 0x121); - nh_map_str_int32_set(hbr_entityrefs_map, "ge", 0x2265); - nh_map_str_int32_set(hbr_entityrefs_map, "gel", 0x22db); - nh_map_str_int32_set(hbr_entityrefs_map, "geq", 0x2265); - nh_map_str_int32_set(hbr_entityrefs_map, "geqq", 0x2267); - nh_map_str_int32_set(hbr_entityrefs_map, "geqslant", 0x2a7e); - nh_map_str_int32_set(hbr_entityrefs_map, "ges", 0x2a7e); - nh_map_str_int32_set(hbr_entityrefs_map, "gescc", 0x2aa9); - nh_map_str_int32_set(hbr_entityrefs_map, "gesdot", 0x2a80); - nh_map_str_int32_set(hbr_entityrefs_map, "gesdoto", 0x2a82); - nh_map_str_int32_set(hbr_entityrefs_map, "gesdotol", 0x2a84); - nh_map_str_int32_set(hbr_entityrefs_map, "gesles", 0x2a94); - nh_map_str_int32_set(hbr_entityrefs_map, "gfr", 0x1d524); - nh_map_str_int32_set(hbr_entityrefs_map, "gg", 0x226b); - nh_map_str_int32_set(hbr_entityrefs_map, "ggg", 0x22d9); - nh_map_str_int32_set(hbr_entityrefs_map, "gimel", 0x2137); - nh_map_str_int32_set(hbr_entityrefs_map, "gjcy", 0x453); - nh_map_str_int32_set(hbr_entityrefs_map, "gl", 0x2277); - nh_map_str_int32_set(hbr_entityrefs_map, "glE", 0x2a92); - nh_map_str_int32_set(hbr_entityrefs_map, "gla", 0x2aa5); - nh_map_str_int32_set(hbr_entityrefs_map, "glj", 0x2aa4); - nh_map_str_int32_set(hbr_entityrefs_map, "gnE", 0x2269); - nh_map_str_int32_set(hbr_entityrefs_map, "gnap", 0x2a8a); - nh_map_str_int32_set(hbr_entityrefs_map, "gnapprox", 0x2a8a); - nh_map_str_int32_set(hbr_entityrefs_map, "gne", 0x2a88); - nh_map_str_int32_set(hbr_entityrefs_map, "gneq", 0x2a88); - nh_map_str_int32_set(hbr_entityrefs_map, "gneqq", 0x2269); - nh_map_str_int32_set(hbr_entityrefs_map, "gnsim", 0x22e7); - nh_map_str_int32_set(hbr_entityrefs_map, "gopf", 0x1d558); - nh_map_str_int32_set(hbr_entityrefs_map, "grave", 0x60); - nh_map_str_int32_set(hbr_entityrefs_map, "gscr", 0x210a); - nh_map_str_int32_set(hbr_entityrefs_map, "gsim", 0x2273); - nh_map_str_int32_set(hbr_entityrefs_map, "gsime", 0x2a8e); - nh_map_str_int32_set(hbr_entityrefs_map, "gsiml", 0x2a90); - nh_map_str_int32_set(hbr_entityrefs_map, "gt", 0x3e); - nh_map_str_int32_set(hbr_entityrefs_map, "gtcc", 0x2aa7); - nh_map_str_int32_set(hbr_entityrefs_map, "gtcir", 0x2a7a); - nh_map_str_int32_set(hbr_entityrefs_map, "gtdot", 0x22d7); - nh_map_str_int32_set(hbr_entityrefs_map, "gtlPar", 0x2995); - nh_map_str_int32_set(hbr_entityrefs_map, "gtquest", 0x2a7c); - nh_map_str_int32_set(hbr_entityrefs_map, "gtrapprox", 0x2a86); - nh_map_str_int32_set(hbr_entityrefs_map, "gtrarr", 0x2978); - nh_map_str_int32_set(hbr_entityrefs_map, "gtrdot", 0x22d7); - nh_map_str_int32_set(hbr_entityrefs_map, "gtreqless", 0x22db); - nh_map_str_int32_set(hbr_entityrefs_map, "gtreqqless", 0x2a8c); - nh_map_str_int32_set(hbr_entityrefs_map, "gtrless", 0x2277); - nh_map_str_int32_set(hbr_entityrefs_map, "gtrsim", 0x2273); - nh_map_str_int32_set(hbr_entityrefs_map, "hArr", 0x21d4); - nh_map_str_int32_set(hbr_entityrefs_map, "hairsp", 0x200a); - nh_map_str_int32_set(hbr_entityrefs_map, "half", 0xbd); - nh_map_str_int32_set(hbr_entityrefs_map, "hamilt", 0x210b); - nh_map_str_int32_set(hbr_entityrefs_map, "hardcy", 0x44a); - nh_map_str_int32_set(hbr_entityrefs_map, "harr", 0x2194); - nh_map_str_int32_set(hbr_entityrefs_map, "harrcir", 0x2948); - nh_map_str_int32_set(hbr_entityrefs_map, "harrw", 0x21ad); - nh_map_str_int32_set(hbr_entityrefs_map, "hbar", 0x210f); - nh_map_str_int32_set(hbr_entityrefs_map, "hcirc", 0x125); - nh_map_str_int32_set(hbr_entityrefs_map, "hearts", 0x2665); - nh_map_str_int32_set(hbr_entityrefs_map, "heartsuit", 0x2665); - nh_map_str_int32_set(hbr_entityrefs_map, "hellip", 0x2026); - nh_map_str_int32_set(hbr_entityrefs_map, "hercon", 0x22b9); - nh_map_str_int32_set(hbr_entityrefs_map, "hfr", 0x1d525); - nh_map_str_int32_set(hbr_entityrefs_map, "hksearow", 0x2925); - nh_map_str_int32_set(hbr_entityrefs_map, "hkswarow", 0x2926); - nh_map_str_int32_set(hbr_entityrefs_map, "hoarr", 0x21ff); - nh_map_str_int32_set(hbr_entityrefs_map, "homtht", 0x223b); - nh_map_str_int32_set(hbr_entityrefs_map, "hookleftarrow", 0x21a9); - nh_map_str_int32_set(hbr_entityrefs_map, "hookrightarrow", 0x21aa); - nh_map_str_int32_set(hbr_entityrefs_map, "hopf", 0x1d559); - nh_map_str_int32_set(hbr_entityrefs_map, "horbar", 0x2015); - nh_map_str_int32_set(hbr_entityrefs_map, "hscr", 0x1d4bd); - nh_map_str_int32_set(hbr_entityrefs_map, "hslash", 0x210f); - nh_map_str_int32_set(hbr_entityrefs_map, "hstrok", 0x127); - nh_map_str_int32_set(hbr_entityrefs_map, "hybull", 0x2043); - nh_map_str_int32_set(hbr_entityrefs_map, "hyphen", 0x2010); - nh_map_str_int32_set(hbr_entityrefs_map, "iacute", 0xed); - nh_map_str_int32_set(hbr_entityrefs_map, "ic", 0x2063); - nh_map_str_int32_set(hbr_entityrefs_map, "icirc", 0xee); - nh_map_str_int32_set(hbr_entityrefs_map, "icy", 0x438); - nh_map_str_int32_set(hbr_entityrefs_map, "iecy", 0x435); - nh_map_str_int32_set(hbr_entityrefs_map, "iexcl", 0xa1); - nh_map_str_int32_set(hbr_entityrefs_map, "iff", 0x21d4); - nh_map_str_int32_set(hbr_entityrefs_map, "ifr", 0x1d526); - nh_map_str_int32_set(hbr_entityrefs_map, "igrave", 0xec); - nh_map_str_int32_set(hbr_entityrefs_map, "ii", 0x2148); - nh_map_str_int32_set(hbr_entityrefs_map, "iiiint", 0x2a0c); - nh_map_str_int32_set(hbr_entityrefs_map, "iiint", 0x222d); - nh_map_str_int32_set(hbr_entityrefs_map, "iinfin", 0x29dc); - nh_map_str_int32_set(hbr_entityrefs_map, "iiota", 0x2129); - nh_map_str_int32_set(hbr_entityrefs_map, "ijlig", 0x133); - nh_map_str_int32_set(hbr_entityrefs_map, "imacr", 0x12b); - nh_map_str_int32_set(hbr_entityrefs_map, "image", 0x2111); - nh_map_str_int32_set(hbr_entityrefs_map, "imagline", 0x2110); - nh_map_str_int32_set(hbr_entityrefs_map, "imagpart", 0x2111); - nh_map_str_int32_set(hbr_entityrefs_map, "imath", 0x131); - nh_map_str_int32_set(hbr_entityrefs_map, "imof", 0x22b7); - nh_map_str_int32_set(hbr_entityrefs_map, "imped", 0x1b5); - nh_map_str_int32_set(hbr_entityrefs_map, "in", 0x2208); - nh_map_str_int32_set(hbr_entityrefs_map, "incare", 0x2105); - nh_map_str_int32_set(hbr_entityrefs_map, "infin", 0x221e); - nh_map_str_int32_set(hbr_entityrefs_map, "infintie", 0x29dd); - nh_map_str_int32_set(hbr_entityrefs_map, "inodot", 0x131); - nh_map_str_int32_set(hbr_entityrefs_map, "int", 0x222b); - nh_map_str_int32_set(hbr_entityrefs_map, "intcal", 0x22ba); - nh_map_str_int32_set(hbr_entityrefs_map, "integers", 0x2124); - nh_map_str_int32_set(hbr_entityrefs_map, "intercal", 0x22ba); - nh_map_str_int32_set(hbr_entityrefs_map, "intlarhk", 0x2a17); - nh_map_str_int32_set(hbr_entityrefs_map, "intprod", 0x2a3c); - nh_map_str_int32_set(hbr_entityrefs_map, "iocy", 0x451); - nh_map_str_int32_set(hbr_entityrefs_map, "iogon", 0x12f); - nh_map_str_int32_set(hbr_entityrefs_map, "iopf", 0x1d55a); - nh_map_str_int32_set(hbr_entityrefs_map, "iota", 0x3b9); - nh_map_str_int32_set(hbr_entityrefs_map, "iprod", 0x2a3c); - nh_map_str_int32_set(hbr_entityrefs_map, "iquest", 0xbf); - nh_map_str_int32_set(hbr_entityrefs_map, "iscr", 0x1d4be); - nh_map_str_int32_set(hbr_entityrefs_map, "isin", 0x2208); - nh_map_str_int32_set(hbr_entityrefs_map, "isinE", 0x22f9); - nh_map_str_int32_set(hbr_entityrefs_map, "isindot", 0x22f5); - nh_map_str_int32_set(hbr_entityrefs_map, "isins", 0x22f4); - nh_map_str_int32_set(hbr_entityrefs_map, "isinsv", 0x22f3); - nh_map_str_int32_set(hbr_entityrefs_map, "isinv", 0x2208); - nh_map_str_int32_set(hbr_entityrefs_map, "it", 0x2062); - nh_map_str_int32_set(hbr_entityrefs_map, "itilde", 0x129); - nh_map_str_int32_set(hbr_entityrefs_map, "iukcy", 0x456); - nh_map_str_int32_set(hbr_entityrefs_map, "iuml", 0xef); - nh_map_str_int32_set(hbr_entityrefs_map, "jcirc", 0x135); - nh_map_str_int32_set(hbr_entityrefs_map, "jcy", 0x439); - nh_map_str_int32_set(hbr_entityrefs_map, "jfr", 0x1d527); - nh_map_str_int32_set(hbr_entityrefs_map, "jmath", 0x237); - nh_map_str_int32_set(hbr_entityrefs_map, "jopf", 0x1d55b); - nh_map_str_int32_set(hbr_entityrefs_map, "jscr", 0x1d4bf); - nh_map_str_int32_set(hbr_entityrefs_map, "jsercy", 0x458); - nh_map_str_int32_set(hbr_entityrefs_map, "jukcy", 0x454); - nh_map_str_int32_set(hbr_entityrefs_map, "kappa", 0x3ba); - nh_map_str_int32_set(hbr_entityrefs_map, "kappav", 0x3f0); - nh_map_str_int32_set(hbr_entityrefs_map, "kcedil", 0x137); - nh_map_str_int32_set(hbr_entityrefs_map, "kcy", 0x43a); - nh_map_str_int32_set(hbr_entityrefs_map, "kfr", 0x1d528); - nh_map_str_int32_set(hbr_entityrefs_map, "kgreen", 0x138); - nh_map_str_int32_set(hbr_entityrefs_map, "khcy", 0x445); - nh_map_str_int32_set(hbr_entityrefs_map, "kjcy", 0x45c); - nh_map_str_int32_set(hbr_entityrefs_map, "kopf", 0x1d55c); - nh_map_str_int32_set(hbr_entityrefs_map, "kscr", 0x1d4c0); - nh_map_str_int32_set(hbr_entityrefs_map, "lAarr", 0x21da); - nh_map_str_int32_set(hbr_entityrefs_map, "lArr", 0x21d0); - nh_map_str_int32_set(hbr_entityrefs_map, "lAtail", 0x291b); - nh_map_str_int32_set(hbr_entityrefs_map, "lBarr", 0x290e); - nh_map_str_int32_set(hbr_entityrefs_map, "lE", 0x2266); - nh_map_str_int32_set(hbr_entityrefs_map, "lEg", 0x2a8b); - nh_map_str_int32_set(hbr_entityrefs_map, "lHar", 0x2962); - nh_map_str_int32_set(hbr_entityrefs_map, "lacute", 0x13a); - nh_map_str_int32_set(hbr_entityrefs_map, "laemptyv", 0x29b4); - nh_map_str_int32_set(hbr_entityrefs_map, "lagran", 0x2112); - nh_map_str_int32_set(hbr_entityrefs_map, "lambda", 0x3bb); - nh_map_str_int32_set(hbr_entityrefs_map, "lang", 0x27e8); - nh_map_str_int32_set(hbr_entityrefs_map, "langd", 0x2991); - nh_map_str_int32_set(hbr_entityrefs_map, "langle", 0x27e8); - nh_map_str_int32_set(hbr_entityrefs_map, "lap", 0x2a85); - nh_map_str_int32_set(hbr_entityrefs_map, "laquo", 0xab); - nh_map_str_int32_set(hbr_entityrefs_map, "larr", 0x2190); - nh_map_str_int32_set(hbr_entityrefs_map, "larrb", 0x21e4); - nh_map_str_int32_set(hbr_entityrefs_map, "larrbfs", 0x291f); - nh_map_str_int32_set(hbr_entityrefs_map, "larrfs", 0x291d); - nh_map_str_int32_set(hbr_entityrefs_map, "larrhk", 0x21a9); - nh_map_str_int32_set(hbr_entityrefs_map, "larrlp", 0x21ab); - nh_map_str_int32_set(hbr_entityrefs_map, "larrpl", 0x2939); - nh_map_str_int32_set(hbr_entityrefs_map, "larrsim", 0x2973); - nh_map_str_int32_set(hbr_entityrefs_map, "larrtl", 0x21a2); - nh_map_str_int32_set(hbr_entityrefs_map, "lat", 0x2aab); - nh_map_str_int32_set(hbr_entityrefs_map, "latail", 0x2919); - nh_map_str_int32_set(hbr_entityrefs_map, "late", 0x2aad); - nh_map_str_int32_set(hbr_entityrefs_map, "lbarr", 0x290c); - nh_map_str_int32_set(hbr_entityrefs_map, "lbbrk", 0x2772); - nh_map_str_int32_set(hbr_entityrefs_map, "lbrace", 0x7b); - nh_map_str_int32_set(hbr_entityrefs_map, "lbrack", 0x5b); - nh_map_str_int32_set(hbr_entityrefs_map, "lbrke", 0x298b); - nh_map_str_int32_set(hbr_entityrefs_map, "lbrksld", 0x298f); - nh_map_str_int32_set(hbr_entityrefs_map, "lbrkslu", 0x298d); - nh_map_str_int32_set(hbr_entityrefs_map, "lcaron", 0x13e); - nh_map_str_int32_set(hbr_entityrefs_map, "lcedil", 0x13c); - nh_map_str_int32_set(hbr_entityrefs_map, "lceil", 0x2308); - nh_map_str_int32_set(hbr_entityrefs_map, "lcub", 0x7b); - nh_map_str_int32_set(hbr_entityrefs_map, "lcy", 0x43b); - nh_map_str_int32_set(hbr_entityrefs_map, "ldca", 0x2936); - nh_map_str_int32_set(hbr_entityrefs_map, "ldquo", 0x201c); - nh_map_str_int32_set(hbr_entityrefs_map, "ldquor", 0x201e); - nh_map_str_int32_set(hbr_entityrefs_map, "ldrdhar", 0x2967); - nh_map_str_int32_set(hbr_entityrefs_map, "ldrushar", 0x294b); - nh_map_str_int32_set(hbr_entityrefs_map, "ldsh", 0x21b2); - nh_map_str_int32_set(hbr_entityrefs_map, "le", 0x2264); - nh_map_str_int32_set(hbr_entityrefs_map, "leftarrow", 0x2190); - nh_map_str_int32_set(hbr_entityrefs_map, "leftarrowtail", 0x21a2); - nh_map_str_int32_set(hbr_entityrefs_map, "leftharpoondown", 0x21bd); - nh_map_str_int32_set(hbr_entityrefs_map, "leftharpoonup", 0x21bc); - nh_map_str_int32_set(hbr_entityrefs_map, "leftleftarrows", 0x21c7); - nh_map_str_int32_set(hbr_entityrefs_map, "leftrightarrow", 0x2194); - nh_map_str_int32_set(hbr_entityrefs_map, "leftrightarrows", 0x21c6); - nh_map_str_int32_set(hbr_entityrefs_map, "leftrightharpoons", 0x21cb); - nh_map_str_int32_set(hbr_entityrefs_map, "leftrightsquigarrow", 0x21ad); - nh_map_str_int32_set(hbr_entityrefs_map, "leftthreetimes", 0x22cb); - nh_map_str_int32_set(hbr_entityrefs_map, "leg", 0x22da); - nh_map_str_int32_set(hbr_entityrefs_map, "leq", 0x2264); - nh_map_str_int32_set(hbr_entityrefs_map, "leqq", 0x2266); - nh_map_str_int32_set(hbr_entityrefs_map, "leqslant", 0x2a7d); - nh_map_str_int32_set(hbr_entityrefs_map, "les", 0x2a7d); - nh_map_str_int32_set(hbr_entityrefs_map, "lescc", 0x2aa8); - nh_map_str_int32_set(hbr_entityrefs_map, "lesdot", 0x2a7f); - nh_map_str_int32_set(hbr_entityrefs_map, "lesdoto", 0x2a81); - nh_map_str_int32_set(hbr_entityrefs_map, "lesdotor", 0x2a83); - nh_map_str_int32_set(hbr_entityrefs_map, "lesges", 0x2a93); - nh_map_str_int32_set(hbr_entityrefs_map, "lessapprox", 0x2a85); - nh_map_str_int32_set(hbr_entityrefs_map, "lessdot", 0x22d6); - nh_map_str_int32_set(hbr_entityrefs_map, "lesseqgtr", 0x22da); - nh_map_str_int32_set(hbr_entityrefs_map, "lesseqqgtr", 0x2a8b); - nh_map_str_int32_set(hbr_entityrefs_map, "lessgtr", 0x2276); - nh_map_str_int32_set(hbr_entityrefs_map, "lesssim", 0x2272); - nh_map_str_int32_set(hbr_entityrefs_map, "lfisht", 0x297c); - nh_map_str_int32_set(hbr_entityrefs_map, "lfloor", 0x230a); - nh_map_str_int32_set(hbr_entityrefs_map, "lfr", 0x1d529); - nh_map_str_int32_set(hbr_entityrefs_map, "lg", 0x2276); - nh_map_str_int32_set(hbr_entityrefs_map, "lgE", 0x2a91); - nh_map_str_int32_set(hbr_entityrefs_map, "lhard", 0x21bd); - nh_map_str_int32_set(hbr_entityrefs_map, "lharu", 0x21bc); - nh_map_str_int32_set(hbr_entityrefs_map, "lharul", 0x296a); - nh_map_str_int32_set(hbr_entityrefs_map, "lhblk", 0x2584); - nh_map_str_int32_set(hbr_entityrefs_map, "ljcy", 0x459); - nh_map_str_int32_set(hbr_entityrefs_map, "ll", 0x226a); - nh_map_str_int32_set(hbr_entityrefs_map, "llarr", 0x21c7); - nh_map_str_int32_set(hbr_entityrefs_map, "llcorner", 0x231e); - nh_map_str_int32_set(hbr_entityrefs_map, "llhard", 0x296b); - nh_map_str_int32_set(hbr_entityrefs_map, "lltri", 0x25fa); - nh_map_str_int32_set(hbr_entityrefs_map, "lmidot", 0x140); - nh_map_str_int32_set(hbr_entityrefs_map, "lmoust", 0x23b0); - nh_map_str_int32_set(hbr_entityrefs_map, "lmoustache", 0x23b0); - nh_map_str_int32_set(hbr_entityrefs_map, "lnE", 0x2268); - nh_map_str_int32_set(hbr_entityrefs_map, "lnap", 0x2a89); - nh_map_str_int32_set(hbr_entityrefs_map, "lnapprox", 0x2a89); - nh_map_str_int32_set(hbr_entityrefs_map, "lne", 0x2a87); - nh_map_str_int32_set(hbr_entityrefs_map, "lneq", 0x2a87); - nh_map_str_int32_set(hbr_entityrefs_map, "lneqq", 0x2268); - nh_map_str_int32_set(hbr_entityrefs_map, "lnsim", 0x22e6); - nh_map_str_int32_set(hbr_entityrefs_map, "loang", 0x27ec); - nh_map_str_int32_set(hbr_entityrefs_map, "loarr", 0x21fd); - nh_map_str_int32_set(hbr_entityrefs_map, "lobrk", 0x27e6); - nh_map_str_int32_set(hbr_entityrefs_map, "longleftarrow", 0x27f5); - nh_map_str_int32_set(hbr_entityrefs_map, "longleftrightarrow", 0x27f7); - nh_map_str_int32_set(hbr_entityrefs_map, "longmapsto", 0x27fc); - nh_map_str_int32_set(hbr_entityrefs_map, "longrightarrow", 0x27f6); - nh_map_str_int32_set(hbr_entityrefs_map, "looparrowleft", 0x21ab); - nh_map_str_int32_set(hbr_entityrefs_map, "looparrowright", 0x21ac); - nh_map_str_int32_set(hbr_entityrefs_map, "lopar", 0x2985); - nh_map_str_int32_set(hbr_entityrefs_map, "lopf", 0x1d55d); - nh_map_str_int32_set(hbr_entityrefs_map, "loplus", 0x2a2d); - nh_map_str_int32_set(hbr_entityrefs_map, "lotimes", 0x2a34); - nh_map_str_int32_set(hbr_entityrefs_map, "lowast", 0x2217); - nh_map_str_int32_set(hbr_entityrefs_map, "lowbar", 0x5f); - nh_map_str_int32_set(hbr_entityrefs_map, "loz", 0x25ca); - nh_map_str_int32_set(hbr_entityrefs_map, "lozenge", 0x25ca); - nh_map_str_int32_set(hbr_entityrefs_map, "lozf", 0x29eb); - nh_map_str_int32_set(hbr_entityrefs_map, "lpar", 0x28); - nh_map_str_int32_set(hbr_entityrefs_map, "lparlt", 0x2993); - nh_map_str_int32_set(hbr_entityrefs_map, "lrarr", 0x21c6); - nh_map_str_int32_set(hbr_entityrefs_map, "lrcorner", 0x231f); - nh_map_str_int32_set(hbr_entityrefs_map, "lrhar", 0x21cb); - nh_map_str_int32_set(hbr_entityrefs_map, "lrhard", 0x296d); - nh_map_str_int32_set(hbr_entityrefs_map, "lrm", 0x200e); - nh_map_str_int32_set(hbr_entityrefs_map, "lrtri", 0x22bf); - nh_map_str_int32_set(hbr_entityrefs_map, "lsaquo", 0x2039); - nh_map_str_int32_set(hbr_entityrefs_map, "lscr", 0x1d4c1); - nh_map_str_int32_set(hbr_entityrefs_map, "lsh", 0x21b0); - nh_map_str_int32_set(hbr_entityrefs_map, "lsim", 0x2272); - nh_map_str_int32_set(hbr_entityrefs_map, "lsime", 0x2a8d); - nh_map_str_int32_set(hbr_entityrefs_map, "lsimg", 0x2a8f); - nh_map_str_int32_set(hbr_entityrefs_map, "lsqb", 0x5b); - nh_map_str_int32_set(hbr_entityrefs_map, "lsquo", 0x2018); - nh_map_str_int32_set(hbr_entityrefs_map, "lsquor", 0x201a); - nh_map_str_int32_set(hbr_entityrefs_map, "lstrok", 0x142); - nh_map_str_int32_set(hbr_entityrefs_map, "lt", 0x3c); - nh_map_str_int32_set(hbr_entityrefs_map, "ltcc", 0x2aa6); - nh_map_str_int32_set(hbr_entityrefs_map, "ltcir", 0x2a79); - nh_map_str_int32_set(hbr_entityrefs_map, "ltdot", 0x22d6); - nh_map_str_int32_set(hbr_entityrefs_map, "lthree", 0x22cb); - nh_map_str_int32_set(hbr_entityrefs_map, "ltimes", 0x22c9); - nh_map_str_int32_set(hbr_entityrefs_map, "ltlarr", 0x2976); - nh_map_str_int32_set(hbr_entityrefs_map, "ltquest", 0x2a7b); - nh_map_str_int32_set(hbr_entityrefs_map, "ltrPar", 0x2996); - nh_map_str_int32_set(hbr_entityrefs_map, "ltri", 0x25c3); - nh_map_str_int32_set(hbr_entityrefs_map, "ltrie", 0x22b4); - nh_map_str_int32_set(hbr_entityrefs_map, "ltrif", 0x25c2); - nh_map_str_int32_set(hbr_entityrefs_map, "lurdshar", 0x294a); - nh_map_str_int32_set(hbr_entityrefs_map, "luruhar", 0x2966); - nh_map_str_int32_set(hbr_entityrefs_map, "mDDot", 0x223a); - nh_map_str_int32_set(hbr_entityrefs_map, "macr", 0xaf); - nh_map_str_int32_set(hbr_entityrefs_map, "male", 0x2642); - nh_map_str_int32_set(hbr_entityrefs_map, "malt", 0x2720); - nh_map_str_int32_set(hbr_entityrefs_map, "maltese", 0x2720); - nh_map_str_int32_set(hbr_entityrefs_map, "map", 0x21a6); - nh_map_str_int32_set(hbr_entityrefs_map, "mapsto", 0x21a6); - nh_map_str_int32_set(hbr_entityrefs_map, "mapstodown", 0x21a7); - nh_map_str_int32_set(hbr_entityrefs_map, "mapstoleft", 0x21a4); - nh_map_str_int32_set(hbr_entityrefs_map, "mapstoup", 0x21a5); - nh_map_str_int32_set(hbr_entityrefs_map, "marker", 0x25ae); - nh_map_str_int32_set(hbr_entityrefs_map, "mcomma", 0x2a29); - nh_map_str_int32_set(hbr_entityrefs_map, "mcy", 0x43c); - nh_map_str_int32_set(hbr_entityrefs_map, "mdash", 0x2014); - nh_map_str_int32_set(hbr_entityrefs_map, "measuredangle", 0x2221); - nh_map_str_int32_set(hbr_entityrefs_map, "mfr", 0x1d52a); - nh_map_str_int32_set(hbr_entityrefs_map, "mho", 0x2127); - nh_map_str_int32_set(hbr_entityrefs_map, "micro", 0xb5); - nh_map_str_int32_set(hbr_entityrefs_map, "mid", 0x2223); - nh_map_str_int32_set(hbr_entityrefs_map, "midast", 0x2a); - nh_map_str_int32_set(hbr_entityrefs_map, "midcir", 0x2af0); - nh_map_str_int32_set(hbr_entityrefs_map, "middot", 0xb7); - nh_map_str_int32_set(hbr_entityrefs_map, "minus", 0x2212); - nh_map_str_int32_set(hbr_entityrefs_map, "minusb", 0x229f); - nh_map_str_int32_set(hbr_entityrefs_map, "minusd", 0x2238); - nh_map_str_int32_set(hbr_entityrefs_map, "minusdu", 0x2a2a); - nh_map_str_int32_set(hbr_entityrefs_map, "mlcp", 0x2adb); - nh_map_str_int32_set(hbr_entityrefs_map, "mldr", 0x2026); - nh_map_str_int32_set(hbr_entityrefs_map, "mnplus", 0x2213); - nh_map_str_int32_set(hbr_entityrefs_map, "models", 0x22a7); - nh_map_str_int32_set(hbr_entityrefs_map, "mopf", 0x1d55e); - nh_map_str_int32_set(hbr_entityrefs_map, "mp", 0x2213); - nh_map_str_int32_set(hbr_entityrefs_map, "mscr", 0x1d4c2); - nh_map_str_int32_set(hbr_entityrefs_map, "mstpos", 0x223e); - nh_map_str_int32_set(hbr_entityrefs_map, "mu", 0x3bc); - nh_map_str_int32_set(hbr_entityrefs_map, "multimap", 0x22b8); - nh_map_str_int32_set(hbr_entityrefs_map, "mumap", 0x22b8); - nh_map_str_int32_set(hbr_entityrefs_map, "nLeftarrow", 0x21cd); - nh_map_str_int32_set(hbr_entityrefs_map, "nLeftrightarrow", 0x21ce); - nh_map_str_int32_set(hbr_entityrefs_map, "nRightarrow", 0x21cf); - nh_map_str_int32_set(hbr_entityrefs_map, "nVDash", 0x22af); - nh_map_str_int32_set(hbr_entityrefs_map, "nVdash", 0x22ae); - nh_map_str_int32_set(hbr_entityrefs_map, "nabla", 0x2207); - nh_map_str_int32_set(hbr_entityrefs_map, "nacute", 0x144); - nh_map_str_int32_set(hbr_entityrefs_map, "nap", 0x2249); - nh_map_str_int32_set(hbr_entityrefs_map, "napos", 0x149); - nh_map_str_int32_set(hbr_entityrefs_map, "napprox", 0x2249); - nh_map_str_int32_set(hbr_entityrefs_map, "natur", 0x266e); - nh_map_str_int32_set(hbr_entityrefs_map, "natural", 0x266e); - nh_map_str_int32_set(hbr_entityrefs_map, "naturals", 0x2115); - nh_map_str_int32_set(hbr_entityrefs_map, "nbsp", 0xa0); - nh_map_str_int32_set(hbr_entityrefs_map, "ncap", 0x2a43); - nh_map_str_int32_set(hbr_entityrefs_map, "ncaron", 0x148); - nh_map_str_int32_set(hbr_entityrefs_map, "ncedil", 0x146); - nh_map_str_int32_set(hbr_entityrefs_map, "ncong", 0x2247); - nh_map_str_int32_set(hbr_entityrefs_map, "ncup", 0x2a42); - nh_map_str_int32_set(hbr_entityrefs_map, "ncy", 0x43d); - nh_map_str_int32_set(hbr_entityrefs_map, "ndash", 0x2013); - nh_map_str_int32_set(hbr_entityrefs_map, "ne", 0x2260); - nh_map_str_int32_set(hbr_entityrefs_map, "neArr", 0x21d7); - nh_map_str_int32_set(hbr_entityrefs_map, "nearhk", 0x2924); - nh_map_str_int32_set(hbr_entityrefs_map, "nearr", 0x2197); - nh_map_str_int32_set(hbr_entityrefs_map, "nearrow", 0x2197); - nh_map_str_int32_set(hbr_entityrefs_map, "nequiv", 0x2262); - nh_map_str_int32_set(hbr_entityrefs_map, "nesear", 0x2928); - nh_map_str_int32_set(hbr_entityrefs_map, "nexist", 0x2204); - nh_map_str_int32_set(hbr_entityrefs_map, "nexists", 0x2204); - nh_map_str_int32_set(hbr_entityrefs_map, "nfr", 0x1d52b); - nh_map_str_int32_set(hbr_entityrefs_map, "nge", 0x2271); - nh_map_str_int32_set(hbr_entityrefs_map, "ngeq", 0x2271); - nh_map_str_int32_set(hbr_entityrefs_map, "ngsim", 0x2275); - nh_map_str_int32_set(hbr_entityrefs_map, "ngt", 0x226f); - nh_map_str_int32_set(hbr_entityrefs_map, "ngtr", 0x226f); - nh_map_str_int32_set(hbr_entityrefs_map, "nhArr", 0x21ce); - nh_map_str_int32_set(hbr_entityrefs_map, "nharr", 0x21ae); - nh_map_str_int32_set(hbr_entityrefs_map, "nhpar", 0x2af2); - nh_map_str_int32_set(hbr_entityrefs_map, "ni", 0x220b); - nh_map_str_int32_set(hbr_entityrefs_map, "nis", 0x22fc); - nh_map_str_int32_set(hbr_entityrefs_map, "nisd", 0x22fa); - nh_map_str_int32_set(hbr_entityrefs_map, "niv", 0x220b); - nh_map_str_int32_set(hbr_entityrefs_map, "njcy", 0x45a); - nh_map_str_int32_set(hbr_entityrefs_map, "nlArr", 0x21cd); - nh_map_str_int32_set(hbr_entityrefs_map, "nlarr", 0x219a); - nh_map_str_int32_set(hbr_entityrefs_map, "nldr", 0x2025); - nh_map_str_int32_set(hbr_entityrefs_map, "nle", 0x2270); - nh_map_str_int32_set(hbr_entityrefs_map, "nleftarrow", 0x219a); - nh_map_str_int32_set(hbr_entityrefs_map, "nleftrightarrow", 0x21ae); - nh_map_str_int32_set(hbr_entityrefs_map, "nleq", 0x2270); - nh_map_str_int32_set(hbr_entityrefs_map, "nless", 0x226e); - nh_map_str_int32_set(hbr_entityrefs_map, "nlsim", 0x2274); - nh_map_str_int32_set(hbr_entityrefs_map, "nlt", 0x226e); - nh_map_str_int32_set(hbr_entityrefs_map, "nltri", 0x22ea); - nh_map_str_int32_set(hbr_entityrefs_map, "nltrie", 0x22ec); - nh_map_str_int32_set(hbr_entityrefs_map, "nmid", 0x2224); - nh_map_str_int32_set(hbr_entityrefs_map, "nopf", 0x1d55f); - nh_map_str_int32_set(hbr_entityrefs_map, "not", 0xac); - nh_map_str_int32_set(hbr_entityrefs_map, "notin", 0x2209); - nh_map_str_int32_set(hbr_entityrefs_map, "notinva", 0x2209); - nh_map_str_int32_set(hbr_entityrefs_map, "notinvb", 0x22f7); - nh_map_str_int32_set(hbr_entityrefs_map, "notinvc", 0x22f6); - nh_map_str_int32_set(hbr_entityrefs_map, "notni", 0x220c); - nh_map_str_int32_set(hbr_entityrefs_map, "notniva", 0x220c); - nh_map_str_int32_set(hbr_entityrefs_map, "notnivb", 0x22fe); - nh_map_str_int32_set(hbr_entityrefs_map, "notnivc", 0x22fd); - nh_map_str_int32_set(hbr_entityrefs_map, "npar", 0x2226); - nh_map_str_int32_set(hbr_entityrefs_map, "nparallel", 0x2226); - nh_map_str_int32_set(hbr_entityrefs_map, "npolint", 0x2a14); - nh_map_str_int32_set(hbr_entityrefs_map, "npr", 0x2280); - nh_map_str_int32_set(hbr_entityrefs_map, "nprcue", 0x22e0); - nh_map_str_int32_set(hbr_entityrefs_map, "nprec", 0x2280); - nh_map_str_int32_set(hbr_entityrefs_map, "nrArr", 0x21cf); - nh_map_str_int32_set(hbr_entityrefs_map, "nrarr", 0x219b); - nh_map_str_int32_set(hbr_entityrefs_map, "nrightarrow", 0x219b); - nh_map_str_int32_set(hbr_entityrefs_map, "nrtri", 0x22eb); - nh_map_str_int32_set(hbr_entityrefs_map, "nrtrie", 0x22ed); - nh_map_str_int32_set(hbr_entityrefs_map, "nsc", 0x2281); - nh_map_str_int32_set(hbr_entityrefs_map, "nsccue", 0x22e1); - nh_map_str_int32_set(hbr_entityrefs_map, "nscr", 0x1d4c3); - nh_map_str_int32_set(hbr_entityrefs_map, "nshortmid", 0x2224); - nh_map_str_int32_set(hbr_entityrefs_map, "nshortparallel", 0x2226); - nh_map_str_int32_set(hbr_entityrefs_map, "nsim", 0x2241); - nh_map_str_int32_set(hbr_entityrefs_map, "nsime", 0x2244); - nh_map_str_int32_set(hbr_entityrefs_map, "nsimeq", 0x2244); - nh_map_str_int32_set(hbr_entityrefs_map, "nsmid", 0x2224); - nh_map_str_int32_set(hbr_entityrefs_map, "nspar", 0x2226); - nh_map_str_int32_set(hbr_entityrefs_map, "nsqsube", 0x22e2); - nh_map_str_int32_set(hbr_entityrefs_map, "nsqsupe", 0x22e3); - nh_map_str_int32_set(hbr_entityrefs_map, "nsub", 0x2284); - nh_map_str_int32_set(hbr_entityrefs_map, "nsube", 0x2288); - nh_map_str_int32_set(hbr_entityrefs_map, "nsubseteq", 0x2288); - nh_map_str_int32_set(hbr_entityrefs_map, "nsucc", 0x2281); - nh_map_str_int32_set(hbr_entityrefs_map, "nsup", 0x2285); - nh_map_str_int32_set(hbr_entityrefs_map, "nsupe", 0x2289); - nh_map_str_int32_set(hbr_entityrefs_map, "nsupseteq", 0x2289); - nh_map_str_int32_set(hbr_entityrefs_map, "ntgl", 0x2279); - nh_map_str_int32_set(hbr_entityrefs_map, "ntilde", 0xf1); - nh_map_str_int32_set(hbr_entityrefs_map, "ntlg", 0x2278); - nh_map_str_int32_set(hbr_entityrefs_map, "ntriangleleft", 0x22ea); - nh_map_str_int32_set(hbr_entityrefs_map, "ntrianglelefteq", 0x22ec); - nh_map_str_int32_set(hbr_entityrefs_map, "ntriangleright", 0x22eb); - nh_map_str_int32_set(hbr_entityrefs_map, "ntrianglerighteq", 0x22ed); - nh_map_str_int32_set(hbr_entityrefs_map, "nu", 0x3bd); - nh_map_str_int32_set(hbr_entityrefs_map, "num", 0x23); - nh_map_str_int32_set(hbr_entityrefs_map, "numero", 0x2116); - nh_map_str_int32_set(hbr_entityrefs_map, "numsp", 0x2007); - nh_map_str_int32_set(hbr_entityrefs_map, "nvDash", 0x22ad); - nh_map_str_int32_set(hbr_entityrefs_map, "nvHarr", 0x2904); - nh_map_str_int32_set(hbr_entityrefs_map, "nvdash", 0x22ac); - nh_map_str_int32_set(hbr_entityrefs_map, "nvinfin", 0x29de); - nh_map_str_int32_set(hbr_entityrefs_map, "nvlArr", 0x2902); - nh_map_str_int32_set(hbr_entityrefs_map, "nvrArr", 0x2903); - nh_map_str_int32_set(hbr_entityrefs_map, "nwArr", 0x21d6); - nh_map_str_int32_set(hbr_entityrefs_map, "nwarhk", 0x2923); - nh_map_str_int32_set(hbr_entityrefs_map, "nwarr", 0x2196); - nh_map_str_int32_set(hbr_entityrefs_map, "nwarrow", 0x2196); - nh_map_str_int32_set(hbr_entityrefs_map, "nwnear", 0x2927); - nh_map_str_int32_set(hbr_entityrefs_map, "oS", 0x24c8); - nh_map_str_int32_set(hbr_entityrefs_map, "oacute", 0xf3); - nh_map_str_int32_set(hbr_entityrefs_map, "oast", 0x229b); - nh_map_str_int32_set(hbr_entityrefs_map, "ocir", 0x229a); - nh_map_str_int32_set(hbr_entityrefs_map, "ocirc", 0xf4); - nh_map_str_int32_set(hbr_entityrefs_map, "ocy", 0x43e); - nh_map_str_int32_set(hbr_entityrefs_map, "odash", 0x229d); - nh_map_str_int32_set(hbr_entityrefs_map, "odblac", 0x151); - nh_map_str_int32_set(hbr_entityrefs_map, "odiv", 0x2a38); - nh_map_str_int32_set(hbr_entityrefs_map, "odot", 0x2299); - nh_map_str_int32_set(hbr_entityrefs_map, "odsold", 0x29bc); - nh_map_str_int32_set(hbr_entityrefs_map, "oelig", 0x153); - nh_map_str_int32_set(hbr_entityrefs_map, "ofcir", 0x29bf); - nh_map_str_int32_set(hbr_entityrefs_map, "ofr", 0x1d52c); - nh_map_str_int32_set(hbr_entityrefs_map, "ogon", 0x2db); - nh_map_str_int32_set(hbr_entityrefs_map, "ograve", 0xf2); - nh_map_str_int32_set(hbr_entityrefs_map, "ogt", 0x29c1); - nh_map_str_int32_set(hbr_entityrefs_map, "ohbar", 0x29b5); - nh_map_str_int32_set(hbr_entityrefs_map, "ohm", 0x2126); - nh_map_str_int32_set(hbr_entityrefs_map, "oint", 0x222e); - nh_map_str_int32_set(hbr_entityrefs_map, "olarr", 0x21ba); - nh_map_str_int32_set(hbr_entityrefs_map, "olcir", 0x29be); - nh_map_str_int32_set(hbr_entityrefs_map, "olcross", 0x29bb); - nh_map_str_int32_set(hbr_entityrefs_map, "oline", 0x203e); - nh_map_str_int32_set(hbr_entityrefs_map, "olt", 0x29c0); - nh_map_str_int32_set(hbr_entityrefs_map, "omacr", 0x14d); - nh_map_str_int32_set(hbr_entityrefs_map, "omega", 0x3c9); - nh_map_str_int32_set(hbr_entityrefs_map, "omicron", 0x3bf); - nh_map_str_int32_set(hbr_entityrefs_map, "omid", 0x29b6); - nh_map_str_int32_set(hbr_entityrefs_map, "ominus", 0x2296); - nh_map_str_int32_set(hbr_entityrefs_map, "oopf", 0x1d560); - nh_map_str_int32_set(hbr_entityrefs_map, "opar", 0x29b7); - nh_map_str_int32_set(hbr_entityrefs_map, "operp", 0x29b9); - nh_map_str_int32_set(hbr_entityrefs_map, "oplus", 0x2295); - nh_map_str_int32_set(hbr_entityrefs_map, "or", 0x2228); - nh_map_str_int32_set(hbr_entityrefs_map, "orarr", 0x21bb); - nh_map_str_int32_set(hbr_entityrefs_map, "ord", 0x2a5d); - nh_map_str_int32_set(hbr_entityrefs_map, "order", 0x2134); - nh_map_str_int32_set(hbr_entityrefs_map, "orderof", 0x2134); - nh_map_str_int32_set(hbr_entityrefs_map, "ordf", 0xaa); - nh_map_str_int32_set(hbr_entityrefs_map, "ordm", 0xba); - nh_map_str_int32_set(hbr_entityrefs_map, "origof", 0x22b6); - nh_map_str_int32_set(hbr_entityrefs_map, "oror", 0x2a56); - nh_map_str_int32_set(hbr_entityrefs_map, "orslope", 0x2a57); - nh_map_str_int32_set(hbr_entityrefs_map, "orv", 0x2a5b); - nh_map_str_int32_set(hbr_entityrefs_map, "oscr", 0x2134); - nh_map_str_int32_set(hbr_entityrefs_map, "oslash", 0xf8); - nh_map_str_int32_set(hbr_entityrefs_map, "osol", 0x2298); - nh_map_str_int32_set(hbr_entityrefs_map, "otilde", 0xf5); - nh_map_str_int32_set(hbr_entityrefs_map, "otimes", 0x2297); - nh_map_str_int32_set(hbr_entityrefs_map, "otimesas", 0x2a36); - nh_map_str_int32_set(hbr_entityrefs_map, "ouml", 0xf6); - nh_map_str_int32_set(hbr_entityrefs_map, "ovbar", 0x233d); - nh_map_str_int32_set(hbr_entityrefs_map, "par", 0x2225); - nh_map_str_int32_set(hbr_entityrefs_map, "para", 0xb6); - nh_map_str_int32_set(hbr_entityrefs_map, "parallel", 0x2225); - nh_map_str_int32_set(hbr_entityrefs_map, "parsim", 0x2af3); - nh_map_str_int32_set(hbr_entityrefs_map, "parsl", 0x2afd); - nh_map_str_int32_set(hbr_entityrefs_map, "part", 0x2202); - nh_map_str_int32_set(hbr_entityrefs_map, "pcy", 0x43f); - nh_map_str_int32_set(hbr_entityrefs_map, "percnt", 0x25); - nh_map_str_int32_set(hbr_entityrefs_map, "period", 0x2e); - nh_map_str_int32_set(hbr_entityrefs_map, "permil", 0x2030); - nh_map_str_int32_set(hbr_entityrefs_map, "perp", 0x22a5); - nh_map_str_int32_set(hbr_entityrefs_map, "pertenk", 0x2031); - nh_map_str_int32_set(hbr_entityrefs_map, "pfr", 0x1d52d); - nh_map_str_int32_set(hbr_entityrefs_map, "phi", 0x3c6); - nh_map_str_int32_set(hbr_entityrefs_map, "phiv", 0x3c6); - nh_map_str_int32_set(hbr_entityrefs_map, "phmmat", 0x2133); - nh_map_str_int32_set(hbr_entityrefs_map, "phone", 0x260e); - nh_map_str_int32_set(hbr_entityrefs_map, "pi", 0x3c0); - nh_map_str_int32_set(hbr_entityrefs_map, "pitchfork", 0x22d4); - nh_map_str_int32_set(hbr_entityrefs_map, "piv", 0x3d6); - nh_map_str_int32_set(hbr_entityrefs_map, "planck", 0x210f); - nh_map_str_int32_set(hbr_entityrefs_map, "planckh", 0x210e); - nh_map_str_int32_set(hbr_entityrefs_map, "plankv", 0x210f); - nh_map_str_int32_set(hbr_entityrefs_map, "plus", 0x2b); - nh_map_str_int32_set(hbr_entityrefs_map, "plusacir", 0x2a23); - nh_map_str_int32_set(hbr_entityrefs_map, "plusb", 0x229e); - nh_map_str_int32_set(hbr_entityrefs_map, "pluscir", 0x2a22); - nh_map_str_int32_set(hbr_entityrefs_map, "plusdo", 0x2214); - nh_map_str_int32_set(hbr_entityrefs_map, "plusdu", 0x2a25); - nh_map_str_int32_set(hbr_entityrefs_map, "pluse", 0x2a72); - nh_map_str_int32_set(hbr_entityrefs_map, "plusmn", 0xb1); - nh_map_str_int32_set(hbr_entityrefs_map, "plussim", 0x2a26); - nh_map_str_int32_set(hbr_entityrefs_map, "plustwo", 0x2a27); - nh_map_str_int32_set(hbr_entityrefs_map, "pm", 0xb1); - nh_map_str_int32_set(hbr_entityrefs_map, "pointint", 0x2a15); - nh_map_str_int32_set(hbr_entityrefs_map, "popf", 0x1d561); - nh_map_str_int32_set(hbr_entityrefs_map, "pound", 0xa3); - nh_map_str_int32_set(hbr_entityrefs_map, "pr", 0x227a); - nh_map_str_int32_set(hbr_entityrefs_map, "prE", 0x2ab3); - nh_map_str_int32_set(hbr_entityrefs_map, "prap", 0x2ab7); - nh_map_str_int32_set(hbr_entityrefs_map, "prcue", 0x227c); - nh_map_str_int32_set(hbr_entityrefs_map, "pre", 0x2aaf); - nh_map_str_int32_set(hbr_entityrefs_map, "prec", 0x227a); - nh_map_str_int32_set(hbr_entityrefs_map, "precapprox", 0x2ab7); - nh_map_str_int32_set(hbr_entityrefs_map, "preccurlyeq", 0x227c); - nh_map_str_int32_set(hbr_entityrefs_map, "preceq", 0x2aaf); - nh_map_str_int32_set(hbr_entityrefs_map, "precnapprox", 0x2ab9); - nh_map_str_int32_set(hbr_entityrefs_map, "precneqq", 0x2ab5); - nh_map_str_int32_set(hbr_entityrefs_map, "precnsim", 0x22e8); - nh_map_str_int32_set(hbr_entityrefs_map, "precsim", 0x227e); - nh_map_str_int32_set(hbr_entityrefs_map, "prime", 0x2032); - nh_map_str_int32_set(hbr_entityrefs_map, "primes", 0x2119); - nh_map_str_int32_set(hbr_entityrefs_map, "prnE", 0x2ab5); - nh_map_str_int32_set(hbr_entityrefs_map, "prnap", 0x2ab9); - nh_map_str_int32_set(hbr_entityrefs_map, "prnsim", 0x22e8); - nh_map_str_int32_set(hbr_entityrefs_map, "prod", 0x220f); - nh_map_str_int32_set(hbr_entityrefs_map, "profalar", 0x232e); - nh_map_str_int32_set(hbr_entityrefs_map, "profline", 0x2312); - nh_map_str_int32_set(hbr_entityrefs_map, "profsurf", 0x2313); - nh_map_str_int32_set(hbr_entityrefs_map, "prop", 0x221d); - nh_map_str_int32_set(hbr_entityrefs_map, "propto", 0x221d); - nh_map_str_int32_set(hbr_entityrefs_map, "prsim", 0x227e); - nh_map_str_int32_set(hbr_entityrefs_map, "prurel", 0x22b0); - nh_map_str_int32_set(hbr_entityrefs_map, "pscr", 0x1d4c5); - nh_map_str_int32_set(hbr_entityrefs_map, "psi", 0x3c8); - nh_map_str_int32_set(hbr_entityrefs_map, "puncsp", 0x2008); - nh_map_str_int32_set(hbr_entityrefs_map, "qfr", 0x1d52e); - nh_map_str_int32_set(hbr_entityrefs_map, "qint", 0x2a0c); - nh_map_str_int32_set(hbr_entityrefs_map, "qopf", 0x1d562); - nh_map_str_int32_set(hbr_entityrefs_map, "qprime", 0x2057); - nh_map_str_int32_set(hbr_entityrefs_map, "qscr", 0x1d4c6); - nh_map_str_int32_set(hbr_entityrefs_map, "quaternions", 0x210d); - nh_map_str_int32_set(hbr_entityrefs_map, "quatint", 0x2a16); - nh_map_str_int32_set(hbr_entityrefs_map, "quest", 0x3f); - nh_map_str_int32_set(hbr_entityrefs_map, "questeq", 0x225f); - nh_map_str_int32_set(hbr_entityrefs_map, "quot", 0x22); - nh_map_str_int32_set(hbr_entityrefs_map, "rAarr", 0x21db); - nh_map_str_int32_set(hbr_entityrefs_map, "rArr", 0x21d2); - nh_map_str_int32_set(hbr_entityrefs_map, "rAtail", 0x291c); - nh_map_str_int32_set(hbr_entityrefs_map, "rBarr", 0x290f); - nh_map_str_int32_set(hbr_entityrefs_map, "rHar", 0x2964); - nh_map_str_int32_set(hbr_entityrefs_map, "race", 0x29da); - nh_map_str_int32_set(hbr_entityrefs_map, "racute", 0x155); - nh_map_str_int32_set(hbr_entityrefs_map, "radic", 0x221a); - nh_map_str_int32_set(hbr_entityrefs_map, "raemptyv", 0x29b3); - nh_map_str_int32_set(hbr_entityrefs_map, "rang", 0x27e9); - nh_map_str_int32_set(hbr_entityrefs_map, "rangd", 0x2992); - nh_map_str_int32_set(hbr_entityrefs_map, "range", 0x29a5); - nh_map_str_int32_set(hbr_entityrefs_map, "rangle", 0x27e9); - nh_map_str_int32_set(hbr_entityrefs_map, "raquo", 0xbb); - nh_map_str_int32_set(hbr_entityrefs_map, "rarr", 0x2192); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrap", 0x2975); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrb", 0x21e5); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrbfs", 0x2920); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrc", 0x2933); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrfs", 0x291e); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrhk", 0x21aa); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrlp", 0x21ac); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrpl", 0x2945); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrsim", 0x2974); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrtl", 0x21a3); - nh_map_str_int32_set(hbr_entityrefs_map, "rarrw", 0x219d); - nh_map_str_int32_set(hbr_entityrefs_map, "ratail", 0x291a); - nh_map_str_int32_set(hbr_entityrefs_map, "ratio", 0x2236); - nh_map_str_int32_set(hbr_entityrefs_map, "rationals", 0x211a); - nh_map_str_int32_set(hbr_entityrefs_map, "rbarr", 0x290d); - nh_map_str_int32_set(hbr_entityrefs_map, "rbbrk", 0x2773); - nh_map_str_int32_set(hbr_entityrefs_map, "rbrace", 0x7d); - nh_map_str_int32_set(hbr_entityrefs_map, "rbrack", 0x5d); - nh_map_str_int32_set(hbr_entityrefs_map, "rbrke", 0x298c); - nh_map_str_int32_set(hbr_entityrefs_map, "rbrksld", 0x298e); - nh_map_str_int32_set(hbr_entityrefs_map, "rbrkslu", 0x2990); - nh_map_str_int32_set(hbr_entityrefs_map, "rcaron", 0x159); - nh_map_str_int32_set(hbr_entityrefs_map, "rcedil", 0x157); - nh_map_str_int32_set(hbr_entityrefs_map, "rceil", 0x2309); - nh_map_str_int32_set(hbr_entityrefs_map, "rcub", 0x7d); - nh_map_str_int32_set(hbr_entityrefs_map, "rcy", 0x440); - nh_map_str_int32_set(hbr_entityrefs_map, "rdca", 0x2937); - nh_map_str_int32_set(hbr_entityrefs_map, "rdldhar", 0x2969); - nh_map_str_int32_set(hbr_entityrefs_map, "rdquo", 0x201d); - nh_map_str_int32_set(hbr_entityrefs_map, "rdquor", 0x201d); - nh_map_str_int32_set(hbr_entityrefs_map, "rdsh", 0x21b3); - nh_map_str_int32_set(hbr_entityrefs_map, "real", 0x211c); - nh_map_str_int32_set(hbr_entityrefs_map, "realine", 0x211b); - nh_map_str_int32_set(hbr_entityrefs_map, "realpart", 0x211c); - nh_map_str_int32_set(hbr_entityrefs_map, "reals", 0x211d); - nh_map_str_int32_set(hbr_entityrefs_map, "rect", 0x25ad); - nh_map_str_int32_set(hbr_entityrefs_map, "reg", 0xae); - nh_map_str_int32_set(hbr_entityrefs_map, "rfisht", 0x297d); - nh_map_str_int32_set(hbr_entityrefs_map, "rfloor", 0x230b); - nh_map_str_int32_set(hbr_entityrefs_map, "rfr", 0x1d52f); - nh_map_str_int32_set(hbr_entityrefs_map, "rhard", 0x21c1); - nh_map_str_int32_set(hbr_entityrefs_map, "rharu", 0x21c0); - nh_map_str_int32_set(hbr_entityrefs_map, "rharul", 0x296c); - nh_map_str_int32_set(hbr_entityrefs_map, "rho", 0x3c1); - nh_map_str_int32_set(hbr_entityrefs_map, "rhov", 0x3f1); - nh_map_str_int32_set(hbr_entityrefs_map, "rightarrow", 0x2192); - nh_map_str_int32_set(hbr_entityrefs_map, "rightarrowtail", 0x21a3); - nh_map_str_int32_set(hbr_entityrefs_map, "rightharpoondown", 0x21c1); - nh_map_str_int32_set(hbr_entityrefs_map, "rightharpoonup", 0x21c0); - nh_map_str_int32_set(hbr_entityrefs_map, "rightleftarrows", 0x21c4); - nh_map_str_int32_set(hbr_entityrefs_map, "rightleftharpoons", 0x21cc); - nh_map_str_int32_set(hbr_entityrefs_map, "rightrightarrows", 0x21c9); - nh_map_str_int32_set(hbr_entityrefs_map, "rightsquigarrow", 0x219d); - nh_map_str_int32_set(hbr_entityrefs_map, "rightthreetimes", 0x22cc); - nh_map_str_int32_set(hbr_entityrefs_map, "ring", 0x2da); - nh_map_str_int32_set(hbr_entityrefs_map, "risingdotseq", 0x2253); - nh_map_str_int32_set(hbr_entityrefs_map, "rlarr", 0x21c4); - nh_map_str_int32_set(hbr_entityrefs_map, "rlhar", 0x21cc); - nh_map_str_int32_set(hbr_entityrefs_map, "rlm", 0x200f); - nh_map_str_int32_set(hbr_entityrefs_map, "rmoust", 0x23b1); - nh_map_str_int32_set(hbr_entityrefs_map, "rmoustache", 0x23b1); - nh_map_str_int32_set(hbr_entityrefs_map, "rnmid", 0x2aee); - nh_map_str_int32_set(hbr_entityrefs_map, "roang", 0x27ed); - nh_map_str_int32_set(hbr_entityrefs_map, "roarr", 0x21fe); - nh_map_str_int32_set(hbr_entityrefs_map, "robrk", 0x27e7); - nh_map_str_int32_set(hbr_entityrefs_map, "ropar", 0x2986); - nh_map_str_int32_set(hbr_entityrefs_map, "ropf", 0x1d563); - nh_map_str_int32_set(hbr_entityrefs_map, "roplus", 0x2a2e); - nh_map_str_int32_set(hbr_entityrefs_map, "rotimes", 0x2a35); - nh_map_str_int32_set(hbr_entityrefs_map, "rpar", 0x29); - nh_map_str_int32_set(hbr_entityrefs_map, "rpargt", 0x2994); - nh_map_str_int32_set(hbr_entityrefs_map, "rppolint", 0x2a12); - nh_map_str_int32_set(hbr_entityrefs_map, "rrarr", 0x21c9); - nh_map_str_int32_set(hbr_entityrefs_map, "rsaquo", 0x203a); - nh_map_str_int32_set(hbr_entityrefs_map, "rscr", 0x1d4c7); - nh_map_str_int32_set(hbr_entityrefs_map, "rsh", 0x21b1); - nh_map_str_int32_set(hbr_entityrefs_map, "rsqb", 0x5d); - nh_map_str_int32_set(hbr_entityrefs_map, "rsquo", 0x2019); - nh_map_str_int32_set(hbr_entityrefs_map, "rsquor", 0x2019); - nh_map_str_int32_set(hbr_entityrefs_map, "rthree", 0x22cc); - nh_map_str_int32_set(hbr_entityrefs_map, "rtimes", 0x22ca); - nh_map_str_int32_set(hbr_entityrefs_map, "rtri", 0x25b9); - nh_map_str_int32_set(hbr_entityrefs_map, "rtrie", 0x22b5); - nh_map_str_int32_set(hbr_entityrefs_map, "rtrif", 0x25b8); - nh_map_str_int32_set(hbr_entityrefs_map, "rtriltri", 0x29ce); - nh_map_str_int32_set(hbr_entityrefs_map, "ruluhar", 0x2968); - nh_map_str_int32_set(hbr_entityrefs_map, "rx", 0x211e); - nh_map_str_int32_set(hbr_entityrefs_map, "sacute", 0x15b); - nh_map_str_int32_set(hbr_entityrefs_map, "sbquo", 0x201a); - nh_map_str_int32_set(hbr_entityrefs_map, "sc", 0x227b); - nh_map_str_int32_set(hbr_entityrefs_map, "scE", 0x2ab4); - nh_map_str_int32_set(hbr_entityrefs_map, "scap", 0x2ab8); - nh_map_str_int32_set(hbr_entityrefs_map, "scaron", 0x161); - nh_map_str_int32_set(hbr_entityrefs_map, "sccue", 0x227d); - nh_map_str_int32_set(hbr_entityrefs_map, "sce", 0x2ab0); - nh_map_str_int32_set(hbr_entityrefs_map, "scedil", 0x15f); - nh_map_str_int32_set(hbr_entityrefs_map, "scirc", 0x15d); - nh_map_str_int32_set(hbr_entityrefs_map, "scnE", 0x2ab6); - nh_map_str_int32_set(hbr_entityrefs_map, "scnap", 0x2aba); - nh_map_str_int32_set(hbr_entityrefs_map, "scnsim", 0x22e9); - nh_map_str_int32_set(hbr_entityrefs_map, "scpolint", 0x2a13); - nh_map_str_int32_set(hbr_entityrefs_map, "scsim", 0x227f); - nh_map_str_int32_set(hbr_entityrefs_map, "scy", 0x441); - nh_map_str_int32_set(hbr_entityrefs_map, "sdot", 0x22c5); - nh_map_str_int32_set(hbr_entityrefs_map, "sdotb", 0x22a1); - nh_map_str_int32_set(hbr_entityrefs_map, "sdote", 0x2a66); - nh_map_str_int32_set(hbr_entityrefs_map, "seArr", 0x21d8); - nh_map_str_int32_set(hbr_entityrefs_map, "searhk", 0x2925); - nh_map_str_int32_set(hbr_entityrefs_map, "searr", 0x2198); - nh_map_str_int32_set(hbr_entityrefs_map, "searrow", 0x2198); - nh_map_str_int32_set(hbr_entityrefs_map, "sect", 0xa7); - nh_map_str_int32_set(hbr_entityrefs_map, "semi", 0x3b); - nh_map_str_int32_set(hbr_entityrefs_map, "seswar", 0x2929); - nh_map_str_int32_set(hbr_entityrefs_map, "setminus", 0x2216); - nh_map_str_int32_set(hbr_entityrefs_map, "setmn", 0x2216); - nh_map_str_int32_set(hbr_entityrefs_map, "sext", 0x2736); - nh_map_str_int32_set(hbr_entityrefs_map, "sfr", 0x1d530); - nh_map_str_int32_set(hbr_entityrefs_map, "sfrown", 0x2322); - nh_map_str_int32_set(hbr_entityrefs_map, "sharp", 0x266f); - nh_map_str_int32_set(hbr_entityrefs_map, "shchcy", 0x449); - nh_map_str_int32_set(hbr_entityrefs_map, "shcy", 0x448); - nh_map_str_int32_set(hbr_entityrefs_map, "shortmid", 0x2223); - nh_map_str_int32_set(hbr_entityrefs_map, "shortparallel", 0x2225); - nh_map_str_int32_set(hbr_entityrefs_map, "shy", 0xad); - nh_map_str_int32_set(hbr_entityrefs_map, "sigma", 0x3c3); - nh_map_str_int32_set(hbr_entityrefs_map, "sigmaf", 0x3c2); - nh_map_str_int32_set(hbr_entityrefs_map, "sigmav", 0x3c2); - nh_map_str_int32_set(hbr_entityrefs_map, "sim", 0x223c); - nh_map_str_int32_set(hbr_entityrefs_map, "simdot", 0x2a6a); - nh_map_str_int32_set(hbr_entityrefs_map, "sime", 0x2243); - nh_map_str_int32_set(hbr_entityrefs_map, "simeq", 0x2243); - nh_map_str_int32_set(hbr_entityrefs_map, "simg", 0x2a9e); - nh_map_str_int32_set(hbr_entityrefs_map, "simgE", 0x2aa0); - nh_map_str_int32_set(hbr_entityrefs_map, "siml", 0x2a9d); - nh_map_str_int32_set(hbr_entityrefs_map, "simlE", 0x2a9f); - nh_map_str_int32_set(hbr_entityrefs_map, "simne", 0x2246); - nh_map_str_int32_set(hbr_entityrefs_map, "simplus", 0x2a24); - nh_map_str_int32_set(hbr_entityrefs_map, "simrarr", 0x2972); - nh_map_str_int32_set(hbr_entityrefs_map, "slarr", 0x2190); - nh_map_str_int32_set(hbr_entityrefs_map, "smallsetminus", 0x2216); - nh_map_str_int32_set(hbr_entityrefs_map, "smashp", 0x2a33); - nh_map_str_int32_set(hbr_entityrefs_map, "smeparsl", 0x29e4); - nh_map_str_int32_set(hbr_entityrefs_map, "smid", 0x2223); - nh_map_str_int32_set(hbr_entityrefs_map, "smile", 0x2323); - nh_map_str_int32_set(hbr_entityrefs_map, "smt", 0x2aaa); - nh_map_str_int32_set(hbr_entityrefs_map, "smte", 0x2aac); - nh_map_str_int32_set(hbr_entityrefs_map, "softcy", 0x44c); - nh_map_str_int32_set(hbr_entityrefs_map, "sol", 0x2f); - nh_map_str_int32_set(hbr_entityrefs_map, "solb", 0x29c4); - nh_map_str_int32_set(hbr_entityrefs_map, "solbar", 0x233f); - nh_map_str_int32_set(hbr_entityrefs_map, "sopf", 0x1d564); - nh_map_str_int32_set(hbr_entityrefs_map, "spades", 0x2660); - nh_map_str_int32_set(hbr_entityrefs_map, "spadesuit", 0x2660); - nh_map_str_int32_set(hbr_entityrefs_map, "spar", 0x2225); - nh_map_str_int32_set(hbr_entityrefs_map, "sqcap", 0x2293); - nh_map_str_int32_set(hbr_entityrefs_map, "sqcup", 0x2294); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsub", 0x228f); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsube", 0x2291); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsubset", 0x228f); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsubseteq", 0x2291); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsup", 0x2290); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsupe", 0x2292); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsupset", 0x2290); - nh_map_str_int32_set(hbr_entityrefs_map, "sqsupseteq", 0x2292); - nh_map_str_int32_set(hbr_entityrefs_map, "squ", 0x25a1); - nh_map_str_int32_set(hbr_entityrefs_map, "square", 0x25a1); - nh_map_str_int32_set(hbr_entityrefs_map, "squarf", 0x25aa); - nh_map_str_int32_set(hbr_entityrefs_map, "squf", 0x25aa); - nh_map_str_int32_set(hbr_entityrefs_map, "srarr", 0x2192); - nh_map_str_int32_set(hbr_entityrefs_map, "sscr", 0x1d4c8); - nh_map_str_int32_set(hbr_entityrefs_map, "ssetmn", 0x2216); - nh_map_str_int32_set(hbr_entityrefs_map, "ssmile", 0x2323); - nh_map_str_int32_set(hbr_entityrefs_map, "sstarf", 0x22c6); - nh_map_str_int32_set(hbr_entityrefs_map, "star", 0x2606); - nh_map_str_int32_set(hbr_entityrefs_map, "starf", 0x2605); - nh_map_str_int32_set(hbr_entityrefs_map, "straightepsilon", 0x3f5); - nh_map_str_int32_set(hbr_entityrefs_map, "straightphi", 0x3d5); - nh_map_str_int32_set(hbr_entityrefs_map, "strns", 0xaf); - nh_map_str_int32_set(hbr_entityrefs_map, "sub", 0x2282); - nh_map_str_int32_set(hbr_entityrefs_map, "subE", 0x2ac5); - nh_map_str_int32_set(hbr_entityrefs_map, "subdot", 0x2abd); - nh_map_str_int32_set(hbr_entityrefs_map, "sube", 0x2286); - nh_map_str_int32_set(hbr_entityrefs_map, "subedot", 0x2ac3); - nh_map_str_int32_set(hbr_entityrefs_map, "submult", 0x2ac1); - nh_map_str_int32_set(hbr_entityrefs_map, "subnE", 0x2acb); - nh_map_str_int32_set(hbr_entityrefs_map, "subne", 0x228a); - nh_map_str_int32_set(hbr_entityrefs_map, "subplus", 0x2abf); - nh_map_str_int32_set(hbr_entityrefs_map, "subrarr", 0x2979); - nh_map_str_int32_set(hbr_entityrefs_map, "subset", 0x2282); - nh_map_str_int32_set(hbr_entityrefs_map, "subseteq", 0x2286); - nh_map_str_int32_set(hbr_entityrefs_map, "subseteqq", 0x2ac5); - nh_map_str_int32_set(hbr_entityrefs_map, "subsetneq", 0x228a); - nh_map_str_int32_set(hbr_entityrefs_map, "subsetneqq", 0x2acb); - nh_map_str_int32_set(hbr_entityrefs_map, "subsim", 0x2ac7); - nh_map_str_int32_set(hbr_entityrefs_map, "subsub", 0x2ad5); - nh_map_str_int32_set(hbr_entityrefs_map, "subsup", 0x2ad3); - nh_map_str_int32_set(hbr_entityrefs_map, "succ", 0x227b); - nh_map_str_int32_set(hbr_entityrefs_map, "succapprox", 0x2ab8); - nh_map_str_int32_set(hbr_entityrefs_map, "succcurlyeq", 0x227d); - nh_map_str_int32_set(hbr_entityrefs_map, "succeq", 0x2ab0); - nh_map_str_int32_set(hbr_entityrefs_map, "succnapprox", 0x2aba); - nh_map_str_int32_set(hbr_entityrefs_map, "succneqq", 0x2ab6); - nh_map_str_int32_set(hbr_entityrefs_map, "succnsim", 0x22e9); - nh_map_str_int32_set(hbr_entityrefs_map, "succsim", 0x227f); - nh_map_str_int32_set(hbr_entityrefs_map, "sum", 0x2211); - nh_map_str_int32_set(hbr_entityrefs_map, "sung", 0x266a); - nh_map_str_int32_set(hbr_entityrefs_map, "sup", 0x2283); - nh_map_str_int32_set(hbr_entityrefs_map, "sup1", 0xb9); - nh_map_str_int32_set(hbr_entityrefs_map, "sup2", 0xb2); - nh_map_str_int32_set(hbr_entityrefs_map, "sup3", 0xb3); - nh_map_str_int32_set(hbr_entityrefs_map, "supE", 0x2ac6); - nh_map_str_int32_set(hbr_entityrefs_map, "supdot", 0x2abe); - nh_map_str_int32_set(hbr_entityrefs_map, "supdsub", 0x2ad8); - nh_map_str_int32_set(hbr_entityrefs_map, "supe", 0x2287); - nh_map_str_int32_set(hbr_entityrefs_map, "supedot", 0x2ac4); - nh_map_str_int32_set(hbr_entityrefs_map, "suphsub", 0x2ad7); - nh_map_str_int32_set(hbr_entityrefs_map, "suplarr", 0x297b); - nh_map_str_int32_set(hbr_entityrefs_map, "supmult", 0x2ac2); - nh_map_str_int32_set(hbr_entityrefs_map, "supnE", 0x2acc); - nh_map_str_int32_set(hbr_entityrefs_map, "supne", 0x228b); - nh_map_str_int32_set(hbr_entityrefs_map, "supplus", 0x2ac0); - nh_map_str_int32_set(hbr_entityrefs_map, "supset", 0x2283); - nh_map_str_int32_set(hbr_entityrefs_map, "supseteq", 0x2287); - nh_map_str_int32_set(hbr_entityrefs_map, "supseteqq", 0x2ac6); - nh_map_str_int32_set(hbr_entityrefs_map, "supsetneq", 0x228b); - nh_map_str_int32_set(hbr_entityrefs_map, "supsetneqq", 0x2acc); - nh_map_str_int32_set(hbr_entityrefs_map, "supsim", 0x2ac8); - nh_map_str_int32_set(hbr_entityrefs_map, "supsub", 0x2ad4); - nh_map_str_int32_set(hbr_entityrefs_map, "supsup", 0x2ad6); - nh_map_str_int32_set(hbr_entityrefs_map, "swArr", 0x21d9); - nh_map_str_int32_set(hbr_entityrefs_map, "swarhk", 0x2926); - nh_map_str_int32_set(hbr_entityrefs_map, "swarr", 0x2199); - nh_map_str_int32_set(hbr_entityrefs_map, "swarrow", 0x2199); - nh_map_str_int32_set(hbr_entityrefs_map, "swnwar", 0x292a); - nh_map_str_int32_set(hbr_entityrefs_map, "szlig", 0xdf); - nh_map_str_int32_set(hbr_entityrefs_map, "target", 0x2316); - nh_map_str_int32_set(hbr_entityrefs_map, "tau", 0x3c4); - nh_map_str_int32_set(hbr_entityrefs_map, "tbrk", 0x23b4); - nh_map_str_int32_set(hbr_entityrefs_map, "tcaron", 0x165); - nh_map_str_int32_set(hbr_entityrefs_map, "tcedil", 0x163); - nh_map_str_int32_set(hbr_entityrefs_map, "tcy", 0x442); - nh_map_str_int32_set(hbr_entityrefs_map, "tdot", 0x20db); - nh_map_str_int32_set(hbr_entityrefs_map, "telrec", 0x2315); - nh_map_str_int32_set(hbr_entityrefs_map, "tfr", 0x1d531); - nh_map_str_int32_set(hbr_entityrefs_map, "there4", 0x2234); - nh_map_str_int32_set(hbr_entityrefs_map, "therefore", 0x2234); - nh_map_str_int32_set(hbr_entityrefs_map, "theta", 0x3b8); - nh_map_str_int32_set(hbr_entityrefs_map, "thetasym", 0x3d1); - nh_map_str_int32_set(hbr_entityrefs_map, "thetav", 0x3d1); - nh_map_str_int32_set(hbr_entityrefs_map, "thickapprox", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "thicksim", 0x223c); - nh_map_str_int32_set(hbr_entityrefs_map, "thinsp", 0x2009); - nh_map_str_int32_set(hbr_entityrefs_map, "thkap", 0x2248); - nh_map_str_int32_set(hbr_entityrefs_map, "thksim", 0x223c); - nh_map_str_int32_set(hbr_entityrefs_map, "thorn", 0xfe); - nh_map_str_int32_set(hbr_entityrefs_map, "tilde", 0x2dc); - nh_map_str_int32_set(hbr_entityrefs_map, "times", 0xd7); - nh_map_str_int32_set(hbr_entityrefs_map, "timesb", 0x22a0); - nh_map_str_int32_set(hbr_entityrefs_map, "timesbar", 0x2a31); - nh_map_str_int32_set(hbr_entityrefs_map, "timesd", 0x2a30); - nh_map_str_int32_set(hbr_entityrefs_map, "tint", 0x222d); - nh_map_str_int32_set(hbr_entityrefs_map, "toea", 0x2928); - nh_map_str_int32_set(hbr_entityrefs_map, "top", 0x22a4); - nh_map_str_int32_set(hbr_entityrefs_map, "topbot", 0x2336); - nh_map_str_int32_set(hbr_entityrefs_map, "topcir", 0x2af1); - nh_map_str_int32_set(hbr_entityrefs_map, "topf", 0x1d565); - nh_map_str_int32_set(hbr_entityrefs_map, "topfork", 0x2ada); - nh_map_str_int32_set(hbr_entityrefs_map, "tosa", 0x2929); - nh_map_str_int32_set(hbr_entityrefs_map, "tprime", 0x2034); - nh_map_str_int32_set(hbr_entityrefs_map, "trade", 0x2122); - nh_map_str_int32_set(hbr_entityrefs_map, "triangle", 0x25b5); - nh_map_str_int32_set(hbr_entityrefs_map, "triangledown", 0x25bf); - nh_map_str_int32_set(hbr_entityrefs_map, "triangleleft", 0x25c3); - nh_map_str_int32_set(hbr_entityrefs_map, "trianglelefteq", 0x22b4); - nh_map_str_int32_set(hbr_entityrefs_map, "triangleq", 0x225c); - nh_map_str_int32_set(hbr_entityrefs_map, "triangleright", 0x25b9); - nh_map_str_int32_set(hbr_entityrefs_map, "trianglerighteq", 0x22b5); - nh_map_str_int32_set(hbr_entityrefs_map, "tridot", 0x25ec); - nh_map_str_int32_set(hbr_entityrefs_map, "trie", 0x225c); - nh_map_str_int32_set(hbr_entityrefs_map, "triminus", 0x2a3a); - nh_map_str_int32_set(hbr_entityrefs_map, "triplus", 0x2a39); - nh_map_str_int32_set(hbr_entityrefs_map, "trisb", 0x29cd); - nh_map_str_int32_set(hbr_entityrefs_map, "tritime", 0x2a3b); - nh_map_str_int32_set(hbr_entityrefs_map, "trpezium", 0x23e2); - nh_map_str_int32_set(hbr_entityrefs_map, "tscr", 0x1d4c9); - nh_map_str_int32_set(hbr_entityrefs_map, "tscy", 0x446); - nh_map_str_int32_set(hbr_entityrefs_map, "tshcy", 0x45b); - nh_map_str_int32_set(hbr_entityrefs_map, "tstrok", 0x167); - nh_map_str_int32_set(hbr_entityrefs_map, "twixt", 0x226c); - nh_map_str_int32_set(hbr_entityrefs_map, "twoheadleftarrow", 0x219e); - nh_map_str_int32_set(hbr_entityrefs_map, "twoheadrightarrow", 0x21a0); - nh_map_str_int32_set(hbr_entityrefs_map, "uArr", 0x21d1); - nh_map_str_int32_set(hbr_entityrefs_map, "uHar", 0x2963); - nh_map_str_int32_set(hbr_entityrefs_map, "uacute", 0xfa); - nh_map_str_int32_set(hbr_entityrefs_map, "uarr", 0x2191); - nh_map_str_int32_set(hbr_entityrefs_map, "ubrcy", 0x45e); - nh_map_str_int32_set(hbr_entityrefs_map, "ubreve", 0x16d); - nh_map_str_int32_set(hbr_entityrefs_map, "ucirc", 0xfb); - nh_map_str_int32_set(hbr_entityrefs_map, "ucy", 0x443); - nh_map_str_int32_set(hbr_entityrefs_map, "udarr", 0x21c5); - nh_map_str_int32_set(hbr_entityrefs_map, "udblac", 0x171); - nh_map_str_int32_set(hbr_entityrefs_map, "udhar", 0x296e); - nh_map_str_int32_set(hbr_entityrefs_map, "ufisht", 0x297e); - nh_map_str_int32_set(hbr_entityrefs_map, "ufr", 0x1d532); - nh_map_str_int32_set(hbr_entityrefs_map, "ugrave", 0xf9); - nh_map_str_int32_set(hbr_entityrefs_map, "uharl", 0x21bf); - nh_map_str_int32_set(hbr_entityrefs_map, "uharr", 0x21be); - nh_map_str_int32_set(hbr_entityrefs_map, "uhblk", 0x2580); - nh_map_str_int32_set(hbr_entityrefs_map, "ulcorn", 0x231c); - nh_map_str_int32_set(hbr_entityrefs_map, "ulcorner", 0x231c); - nh_map_str_int32_set(hbr_entityrefs_map, "ulcrop", 0x230f); - nh_map_str_int32_set(hbr_entityrefs_map, "ultri", 0x25f8); - nh_map_str_int32_set(hbr_entityrefs_map, "umacr", 0x16b); - nh_map_str_int32_set(hbr_entityrefs_map, "uml", 0xa8); - nh_map_str_int32_set(hbr_entityrefs_map, "uogon", 0x173); - nh_map_str_int32_set(hbr_entityrefs_map, "uopf", 0x1d566); - nh_map_str_int32_set(hbr_entityrefs_map, "uparrow", 0x2191); - nh_map_str_int32_set(hbr_entityrefs_map, "updownarrow", 0x2195); - nh_map_str_int32_set(hbr_entityrefs_map, "upharpoonleft", 0x21bf); - nh_map_str_int32_set(hbr_entityrefs_map, "upharpoonright", 0x21be); - nh_map_str_int32_set(hbr_entityrefs_map, "uplus", 0x228e); - nh_map_str_int32_set(hbr_entityrefs_map, "upsi", 0x3c5); - nh_map_str_int32_set(hbr_entityrefs_map, "upsih", 0x3d2); - nh_map_str_int32_set(hbr_entityrefs_map, "upsilon", 0x3c5); - nh_map_str_int32_set(hbr_entityrefs_map, "upuparrows", 0x21c8); - nh_map_str_int32_set(hbr_entityrefs_map, "urcorn", 0x231d); - nh_map_str_int32_set(hbr_entityrefs_map, "urcorner", 0x231d); - nh_map_str_int32_set(hbr_entityrefs_map, "urcrop", 0x230e); - nh_map_str_int32_set(hbr_entityrefs_map, "uring", 0x16f); - nh_map_str_int32_set(hbr_entityrefs_map, "urtri", 0x25f9); - nh_map_str_int32_set(hbr_entityrefs_map, "uscr", 0x1d4ca); - nh_map_str_int32_set(hbr_entityrefs_map, "utdot", 0x22f0); - nh_map_str_int32_set(hbr_entityrefs_map, "utilde", 0x169); - nh_map_str_int32_set(hbr_entityrefs_map, "utri", 0x25b5); - nh_map_str_int32_set(hbr_entityrefs_map, "utrif", 0x25b4); - nh_map_str_int32_set(hbr_entityrefs_map, "uuarr", 0x21c8); - nh_map_str_int32_set(hbr_entityrefs_map, "uuml", 0xfc); - nh_map_str_int32_set(hbr_entityrefs_map, "uwangle", 0x29a7); - nh_map_str_int32_set(hbr_entityrefs_map, "vArr", 0x21d5); - nh_map_str_int32_set(hbr_entityrefs_map, "vBar", 0x2ae8); - nh_map_str_int32_set(hbr_entityrefs_map, "vBarv", 0x2ae9); - nh_map_str_int32_set(hbr_entityrefs_map, "vDash", 0x22a8); - nh_map_str_int32_set(hbr_entityrefs_map, "vangrt", 0x299c); - nh_map_str_int32_set(hbr_entityrefs_map, "varepsilon", 0x3b5); - nh_map_str_int32_set(hbr_entityrefs_map, "varkappa", 0x3f0); - nh_map_str_int32_set(hbr_entityrefs_map, "varnothing", 0x2205); - nh_map_str_int32_set(hbr_entityrefs_map, "varphi", 0x3c6); - nh_map_str_int32_set(hbr_entityrefs_map, "varpi", 0x3d6); - nh_map_str_int32_set(hbr_entityrefs_map, "varpropto", 0x221d); - nh_map_str_int32_set(hbr_entityrefs_map, "varr", 0x2195); - nh_map_str_int32_set(hbr_entityrefs_map, "varrho", 0x3f1); - nh_map_str_int32_set(hbr_entityrefs_map, "varsigma", 0x3c2); - nh_map_str_int32_set(hbr_entityrefs_map, "vartheta", 0x3d1); - nh_map_str_int32_set(hbr_entityrefs_map, "vartriangleleft", 0x22b2); - nh_map_str_int32_set(hbr_entityrefs_map, "vartriangleright", 0x22b3); - nh_map_str_int32_set(hbr_entityrefs_map, "vcy", 0x432); - nh_map_str_int32_set(hbr_entityrefs_map, "vdash", 0x22a2); - nh_map_str_int32_set(hbr_entityrefs_map, "vee", 0x2228); - nh_map_str_int32_set(hbr_entityrefs_map, "veebar", 0x22bb); - nh_map_str_int32_set(hbr_entityrefs_map, "veeeq", 0x225a); - nh_map_str_int32_set(hbr_entityrefs_map, "vellip", 0x22ee); - nh_map_str_int32_set(hbr_entityrefs_map, "verbar", 0x7c); - nh_map_str_int32_set(hbr_entityrefs_map, "vert", 0x7c); - nh_map_str_int32_set(hbr_entityrefs_map, "vfr", 0x1d533); - nh_map_str_int32_set(hbr_entityrefs_map, "vltri", 0x22b2); - nh_map_str_int32_set(hbr_entityrefs_map, "vopf", 0x1d567); - nh_map_str_int32_set(hbr_entityrefs_map, "vprop", 0x221d); - nh_map_str_int32_set(hbr_entityrefs_map, "vrtri", 0x22b3); - nh_map_str_int32_set(hbr_entityrefs_map, "vscr", 0x1d4cb); - nh_map_str_int32_set(hbr_entityrefs_map, "vzigzag", 0x299a); - nh_map_str_int32_set(hbr_entityrefs_map, "wcirc", 0x175); - nh_map_str_int32_set(hbr_entityrefs_map, "wedbar", 0x2a5f); - nh_map_str_int32_set(hbr_entityrefs_map, "wedge", 0x2227); - nh_map_str_int32_set(hbr_entityrefs_map, "wedgeq", 0x2259); - nh_map_str_int32_set(hbr_entityrefs_map, "weierp", 0x2118); - nh_map_str_int32_set(hbr_entityrefs_map, "wfr", 0x1d534); - nh_map_str_int32_set(hbr_entityrefs_map, "wopf", 0x1d568); - nh_map_str_int32_set(hbr_entityrefs_map, "wp", 0x2118); - nh_map_str_int32_set(hbr_entityrefs_map, "wr", 0x2240); - nh_map_str_int32_set(hbr_entityrefs_map, "wreath", 0x2240); - nh_map_str_int32_set(hbr_entityrefs_map, "wscr", 0x1d4cc); - nh_map_str_int32_set(hbr_entityrefs_map, "xcap", 0x22c2); - nh_map_str_int32_set(hbr_entityrefs_map, "xcirc", 0x25ef); - nh_map_str_int32_set(hbr_entityrefs_map, "xcup", 0x22c3); - nh_map_str_int32_set(hbr_entityrefs_map, "xdtri", 0x25bd); - nh_map_str_int32_set(hbr_entityrefs_map, "xfr", 0x1d535); - nh_map_str_int32_set(hbr_entityrefs_map, "xhArr", 0x27fa); - nh_map_str_int32_set(hbr_entityrefs_map, "xharr", 0x27f7); - nh_map_str_int32_set(hbr_entityrefs_map, "xi", 0x3be); - nh_map_str_int32_set(hbr_entityrefs_map, "xlArr", 0x27f8); - nh_map_str_int32_set(hbr_entityrefs_map, "xlarr", 0x27f5); - nh_map_str_int32_set(hbr_entityrefs_map, "xmap", 0x27fc); - nh_map_str_int32_set(hbr_entityrefs_map, "xnis", 0x22fb); - nh_map_str_int32_set(hbr_entityrefs_map, "xodot", 0x2a00); - nh_map_str_int32_set(hbr_entityrefs_map, "xopf", 0x1d569); - nh_map_str_int32_set(hbr_entityrefs_map, "xoplus", 0x2a01); - nh_map_str_int32_set(hbr_entityrefs_map, "xotime", 0x2a02); - nh_map_str_int32_set(hbr_entityrefs_map, "xrArr", 0x27f9); - nh_map_str_int32_set(hbr_entityrefs_map, "xrarr", 0x27f6); - nh_map_str_int32_set(hbr_entityrefs_map, "xscr", 0x1d4cd); - nh_map_str_int32_set(hbr_entityrefs_map, "xsqcup", 0x2a06); - nh_map_str_int32_set(hbr_entityrefs_map, "xuplus", 0x2a04); - nh_map_str_int32_set(hbr_entityrefs_map, "xutri", 0x25b3); - nh_map_str_int32_set(hbr_entityrefs_map, "xvee", 0x22c1); - nh_map_str_int32_set(hbr_entityrefs_map, "xwedge", 0x22c0); - nh_map_str_int32_set(hbr_entityrefs_map, "yacute", 0xfd); - nh_map_str_int32_set(hbr_entityrefs_map, "yacy", 0x44f); - nh_map_str_int32_set(hbr_entityrefs_map, "ycirc", 0x177); - nh_map_str_int32_set(hbr_entityrefs_map, "ycy", 0x44b); - nh_map_str_int32_set(hbr_entityrefs_map, "yen", 0xa5); - nh_map_str_int32_set(hbr_entityrefs_map, "yfr", 0x1d536); - nh_map_str_int32_set(hbr_entityrefs_map, "yicy", 0x457); - nh_map_str_int32_set(hbr_entityrefs_map, "yopf", 0x1d56a); - nh_map_str_int32_set(hbr_entityrefs_map, "yscr", 0x1d4ce); - nh_map_str_int32_set(hbr_entityrefs_map, "yucy", 0x44e); - nh_map_str_int32_set(hbr_entityrefs_map, "yuml", 0xff); - nh_map_str_int32_set(hbr_entityrefs_map, "zacute", 0x17a); - nh_map_str_int32_set(hbr_entityrefs_map, "zcaron", 0x17e); - nh_map_str_int32_set(hbr_entityrefs_map, "zcy", 0x437); - nh_map_str_int32_set(hbr_entityrefs_map, "zdot", 0x17c); - nh_map_str_int32_set(hbr_entityrefs_map, "zeetrf", 0x2128); - nh_map_str_int32_set(hbr_entityrefs_map, "zeta", 0x3b6); - nh_map_str_int32_set(hbr_entityrefs_map, "zfr", 0x1d537); - nh_map_str_int32_set(hbr_entityrefs_map, "zhcy", 0x436); - nh_map_str_int32_set(hbr_entityrefs_map, "zigrarr", 0x21dd); - nh_map_str_int32_set(hbr_entityrefs_map, "zopf", 0x1d56b); - nh_map_str_int32_set(hbr_entityrefs_map, "zscr", 0x1d4cf); - nh_map_str_int32_set(hbr_entityrefs_map, "zwj", 0x200d); - nh_map_str_int32_set(hbr_entityrefs_map, "zwnj", 0x200c); +// Sourced from https://dev.w3.org/html5/html-author/charref at +// 2018-07-02T10:00:00Z + +static nh_map_str_int32 _entity_references; + +void hb_rule_entity_references_init(void) +{ + _entity_references = nh_map_str_int32_create(); + nh_map_str_int32_set(_entity_references, "AElig", 0xc6); + nh_map_str_int32_set(_entity_references, "AMP", 0x26); + nh_map_str_int32_set(_entity_references, "Aacute", 0xc1); + nh_map_str_int32_set(_entity_references, "Abreve", 0x102); + nh_map_str_int32_set(_entity_references, "Acirc", 0xc2); + nh_map_str_int32_set(_entity_references, "Acy", 0x410); + nh_map_str_int32_set(_entity_references, "Afr", 0x1d504); + nh_map_str_int32_set(_entity_references, "Agrave", 0xc0); + nh_map_str_int32_set(_entity_references, "Alpha", 0x391); + nh_map_str_int32_set(_entity_references, "Amacr", 0x100); + nh_map_str_int32_set(_entity_references, "And", 0x2a53); + nh_map_str_int32_set(_entity_references, "Aogon", 0x104); + nh_map_str_int32_set(_entity_references, "Aopf", 0x1d538); + nh_map_str_int32_set(_entity_references, "ApplyFunction", 0x2061); + nh_map_str_int32_set(_entity_references, "Aring", 0xc5); + nh_map_str_int32_set(_entity_references, "Ascr", 0x1d49c); + nh_map_str_int32_set(_entity_references, "Assign", 0x2254); + nh_map_str_int32_set(_entity_references, "Atilde", 0xc3); + nh_map_str_int32_set(_entity_references, "Auml", 0xc4); + nh_map_str_int32_set(_entity_references, "Backslash", 0x2216); + nh_map_str_int32_set(_entity_references, "Barv", 0x2ae7); + nh_map_str_int32_set(_entity_references, "Barwed", 0x2306); + nh_map_str_int32_set(_entity_references, "Bcy", 0x411); + nh_map_str_int32_set(_entity_references, "Because", 0x2235); + nh_map_str_int32_set(_entity_references, "Bernoullis", 0x212c); + nh_map_str_int32_set(_entity_references, "Beta", 0x392); + nh_map_str_int32_set(_entity_references, "Bfr", 0x1d505); + nh_map_str_int32_set(_entity_references, "Bopf", 0x1d539); + nh_map_str_int32_set(_entity_references, "Breve", 0x2d8); + nh_map_str_int32_set(_entity_references, "Bscr", 0x212c); + nh_map_str_int32_set(_entity_references, "Bumpeq", 0x224e); + nh_map_str_int32_set(_entity_references, "CHcy", 0x427); + nh_map_str_int32_set(_entity_references, "COPY", 0xa9); + nh_map_str_int32_set(_entity_references, "Cacute", 0x106); + nh_map_str_int32_set(_entity_references, "Cap", 0x22d2); + nh_map_str_int32_set(_entity_references, "CapitalDifferentialD", + 0x2145); + nh_map_str_int32_set(_entity_references, "Cayleys", 0x212d); + nh_map_str_int32_set(_entity_references, "Ccaron", 0x10c); + nh_map_str_int32_set(_entity_references, "Ccedil", 0xc7); + nh_map_str_int32_set(_entity_references, "Ccirc", 0x108); + nh_map_str_int32_set(_entity_references, "Cconint", 0x2230); + nh_map_str_int32_set(_entity_references, "Cdot", 0x10a); + nh_map_str_int32_set(_entity_references, "Cedilla", 0xb8); + nh_map_str_int32_set(_entity_references, "CenterDot", 0xb7); + nh_map_str_int32_set(_entity_references, "Cfr", 0x212d); + nh_map_str_int32_set(_entity_references, "Chi", 0x3a7); + nh_map_str_int32_set(_entity_references, "CircleDot", 0x2299); + nh_map_str_int32_set(_entity_references, "CircleMinus", 0x2296); + nh_map_str_int32_set(_entity_references, "CirclePlus", 0x2295); + nh_map_str_int32_set(_entity_references, "CircleTimes", 0x2297); + nh_map_str_int32_set(_entity_references, "ClockwiseContourIntegral", + 0x2232); + nh_map_str_int32_set(_entity_references, "CloseCurlyDoubleQuote", + 0x201d); + nh_map_str_int32_set(_entity_references, "CloseCurlyQuote", 0x2019); + nh_map_str_int32_set(_entity_references, "Colon", 0x2237); + nh_map_str_int32_set(_entity_references, "Colone", 0x2a74); + nh_map_str_int32_set(_entity_references, "Congruent", 0x2261); + nh_map_str_int32_set(_entity_references, "Conint", 0x222f); + nh_map_str_int32_set(_entity_references, "ContourIntegral", 0x222e); + nh_map_str_int32_set(_entity_references, "Copf", 0x2102); + nh_map_str_int32_set(_entity_references, "Coproduct", 0x2210); + nh_map_str_int32_set(_entity_references, + "CounterClockwiseContourIntegral", 0x2233); + nh_map_str_int32_set(_entity_references, "Cross", 0x2a2f); + nh_map_str_int32_set(_entity_references, "Cscr", 0x1d49e); + nh_map_str_int32_set(_entity_references, "Cup", 0x22d3); + nh_map_str_int32_set(_entity_references, "CupCap", 0x224d); + nh_map_str_int32_set(_entity_references, "DD", 0x2145); + nh_map_str_int32_set(_entity_references, "DDotrahd", 0x2911); + nh_map_str_int32_set(_entity_references, "DJcy", 0x402); + nh_map_str_int32_set(_entity_references, "DScy", 0x405); + nh_map_str_int32_set(_entity_references, "DZcy", 0x40f); + nh_map_str_int32_set(_entity_references, "Dagger", 0x2021); + nh_map_str_int32_set(_entity_references, "Darr", 0x21a1); + nh_map_str_int32_set(_entity_references, "Dashv", 0x2ae4); + nh_map_str_int32_set(_entity_references, "Dcaron", 0x10e); + nh_map_str_int32_set(_entity_references, "Dcy", 0x414); + nh_map_str_int32_set(_entity_references, "Del", 0x2207); + nh_map_str_int32_set(_entity_references, "Delta", 0x394); + nh_map_str_int32_set(_entity_references, "Dfr", 0x1d507); + nh_map_str_int32_set(_entity_references, "DiacriticalAcute", 0xb4); + nh_map_str_int32_set(_entity_references, "DiacriticalDot", 0x2d9); + nh_map_str_int32_set(_entity_references, "DiacriticalDoubleAcute", + 0x2dd); + nh_map_str_int32_set(_entity_references, "DiacriticalGrave", 0x60); + nh_map_str_int32_set(_entity_references, "DiacriticalTilde", 0x2dc); + nh_map_str_int32_set(_entity_references, "Diamond", 0x22c4); + nh_map_str_int32_set(_entity_references, "DifferentialD", 0x2146); + nh_map_str_int32_set(_entity_references, "Dopf", 0x1d53b); + nh_map_str_int32_set(_entity_references, "Dot", 0xa8); + nh_map_str_int32_set(_entity_references, "DotDot", 0x20dc); + nh_map_str_int32_set(_entity_references, "DotEqual", 0x2250); + nh_map_str_int32_set(_entity_references, "DoubleContourIntegral", + 0x222f); + nh_map_str_int32_set(_entity_references, "DoubleDot", 0xa8); + nh_map_str_int32_set(_entity_references, "DoubleDownArrow", 0x21d3); + nh_map_str_int32_set(_entity_references, "DoubleLeftArrow", 0x21d0); + nh_map_str_int32_set(_entity_references, "DoubleLeftRightArrow", + 0x21d4); + nh_map_str_int32_set(_entity_references, "DoubleLeftTee", 0x2ae4); + nh_map_str_int32_set(_entity_references, "DoubleLongLeftArrow", 0x27f8); + nh_map_str_int32_set(_entity_references, "DoubleLongLeftRightArrow", + 0x27fa); + nh_map_str_int32_set(_entity_references, "DoubleLongRightArrow", + 0x27f9); + nh_map_str_int32_set(_entity_references, "DoubleRightArrow", 0x21d2); + nh_map_str_int32_set(_entity_references, "DoubleRightTee", 0x22a8); + nh_map_str_int32_set(_entity_references, "DoubleUpArrow", 0x21d1); + nh_map_str_int32_set(_entity_references, "DoubleUpDownArrow", 0x21d5); + nh_map_str_int32_set(_entity_references, "DoubleVerticalBar", 0x2225); + nh_map_str_int32_set(_entity_references, "DownArrow", 0x2193); + nh_map_str_int32_set(_entity_references, "DownArrowBar", 0x2913); + nh_map_str_int32_set(_entity_references, "DownArrowUpArrow", 0x21f5); + nh_map_str_int32_set(_entity_references, "DownBreve", 0x311); + nh_map_str_int32_set(_entity_references, "DownLeftRightVector", 0x2950); + nh_map_str_int32_set(_entity_references, "DownLeftTeeVector", 0x295e); + nh_map_str_int32_set(_entity_references, "DownLeftVector", 0x21bd); + nh_map_str_int32_set(_entity_references, "DownLeftVectorBar", 0x2956); + nh_map_str_int32_set(_entity_references, "DownRightTeeVector", 0x295f); + nh_map_str_int32_set(_entity_references, "DownRightVector", 0x21c1); + nh_map_str_int32_set(_entity_references, "DownRightVectorBar", 0x2957); + nh_map_str_int32_set(_entity_references, "DownTee", 0x22a4); + nh_map_str_int32_set(_entity_references, "DownTeeArrow", 0x21a7); + nh_map_str_int32_set(_entity_references, "Downarrow", 0x21d3); + nh_map_str_int32_set(_entity_references, "Dscr", 0x1d49f); + nh_map_str_int32_set(_entity_references, "Dstrok", 0x110); + nh_map_str_int32_set(_entity_references, "ENG", 0x14a); + nh_map_str_int32_set(_entity_references, "ETH", 0xd0); + nh_map_str_int32_set(_entity_references, "Eacute", 0xc9); + nh_map_str_int32_set(_entity_references, "Ecaron", 0x11a); + nh_map_str_int32_set(_entity_references, "Ecirc", 0xca); + nh_map_str_int32_set(_entity_references, "Ecy", 0x42d); + nh_map_str_int32_set(_entity_references, "Edot", 0x116); + nh_map_str_int32_set(_entity_references, "Efr", 0x1d508); + nh_map_str_int32_set(_entity_references, "Egrave", 0xc8); + nh_map_str_int32_set(_entity_references, "Element", 0x2208); + nh_map_str_int32_set(_entity_references, "Emacr", 0x112); + nh_map_str_int32_set(_entity_references, "EmptySmallSquare", 0x25fb); + nh_map_str_int32_set(_entity_references, "EmptyVerySmallSquare", + 0x25ab); + nh_map_str_int32_set(_entity_references, "Eogon", 0x118); + nh_map_str_int32_set(_entity_references, "Eopf", 0x1d53c); + nh_map_str_int32_set(_entity_references, "Epsilon", 0x395); + nh_map_str_int32_set(_entity_references, "Equal", 0x2a75); + nh_map_str_int32_set(_entity_references, "EqualTilde", 0x2242); + nh_map_str_int32_set(_entity_references, "Equilibrium", 0x21cc); + nh_map_str_int32_set(_entity_references, "Escr", 0x2130); + nh_map_str_int32_set(_entity_references, "Esim", 0x2a73); + nh_map_str_int32_set(_entity_references, "Eta", 0x397); + nh_map_str_int32_set(_entity_references, "Euml", 0xcb); + nh_map_str_int32_set(_entity_references, "Exists", 0x2203); + nh_map_str_int32_set(_entity_references, "ExponentialE", 0x2147); + nh_map_str_int32_set(_entity_references, "Fcy", 0x424); + nh_map_str_int32_set(_entity_references, "Ffr", 0x1d509); + nh_map_str_int32_set(_entity_references, "FilledSmallSquare", 0x25fc); + nh_map_str_int32_set(_entity_references, "FilledVerySmallSquare", + 0x25aa); + nh_map_str_int32_set(_entity_references, "Fopf", 0x1d53d); + nh_map_str_int32_set(_entity_references, "ForAll", 0x2200); + nh_map_str_int32_set(_entity_references, "Fouriertrf", 0x2131); + nh_map_str_int32_set(_entity_references, "Fscr", 0x2131); + nh_map_str_int32_set(_entity_references, "GJcy", 0x403); + nh_map_str_int32_set(_entity_references, "GT", 0x3e); + nh_map_str_int32_set(_entity_references, "Gamma", 0x393); + nh_map_str_int32_set(_entity_references, "Gammad", 0x3dc); + nh_map_str_int32_set(_entity_references, "Gbreve", 0x11e); + nh_map_str_int32_set(_entity_references, "Gcedil", 0x122); + nh_map_str_int32_set(_entity_references, "Gcirc", 0x11c); + nh_map_str_int32_set(_entity_references, "Gcy", 0x413); + nh_map_str_int32_set(_entity_references, "Gdot", 0x120); + nh_map_str_int32_set(_entity_references, "Gfr", 0x1d50a); + nh_map_str_int32_set(_entity_references, "Gg", 0x22d9); + nh_map_str_int32_set(_entity_references, "Gopf", 0x1d53e); + nh_map_str_int32_set(_entity_references, "GreaterEqual", 0x2265); + nh_map_str_int32_set(_entity_references, "GreaterEqualLess", 0x22db); + nh_map_str_int32_set(_entity_references, "GreaterFullEqual", 0x2267); + nh_map_str_int32_set(_entity_references, "GreaterGreater", 0x2aa2); + nh_map_str_int32_set(_entity_references, "GreaterLess", 0x2277); + nh_map_str_int32_set(_entity_references, "GreaterSlantEqual", 0x2a7e); + nh_map_str_int32_set(_entity_references, "GreaterTilde", 0x2273); + nh_map_str_int32_set(_entity_references, "Gscr", 0x1d4a2); + nh_map_str_int32_set(_entity_references, "Gt", 0x226b); + nh_map_str_int32_set(_entity_references, "HARDcy", 0x42a); + nh_map_str_int32_set(_entity_references, "Hacek", 0x2c7); + nh_map_str_int32_set(_entity_references, "Hat", 0x5e); + nh_map_str_int32_set(_entity_references, "Hcirc", 0x124); + nh_map_str_int32_set(_entity_references, "Hfr", 0x210c); + nh_map_str_int32_set(_entity_references, "HilbertSpace", 0x210b); + nh_map_str_int32_set(_entity_references, "Hopf", 0x210d); + nh_map_str_int32_set(_entity_references, "HorizontalLine", 0x2500); + nh_map_str_int32_set(_entity_references, "Hscr", 0x210b); + nh_map_str_int32_set(_entity_references, "Hstrok", 0x126); + nh_map_str_int32_set(_entity_references, "HumpDownHump", 0x224e); + nh_map_str_int32_set(_entity_references, "HumpEqual", 0x224f); + nh_map_str_int32_set(_entity_references, "IEcy", 0x415); + nh_map_str_int32_set(_entity_references, "IJlig", 0x132); + nh_map_str_int32_set(_entity_references, "IOcy", 0x401); + nh_map_str_int32_set(_entity_references, "Iacute", 0xcd); + nh_map_str_int32_set(_entity_references, "Icirc", 0xce); + nh_map_str_int32_set(_entity_references, "Icy", 0x418); + nh_map_str_int32_set(_entity_references, "Idot", 0x130); + nh_map_str_int32_set(_entity_references, "Ifr", 0x2111); + nh_map_str_int32_set(_entity_references, "Igrave", 0xcc); + nh_map_str_int32_set(_entity_references, "Im", 0x2111); + nh_map_str_int32_set(_entity_references, "Imacr", 0x12a); + nh_map_str_int32_set(_entity_references, "ImaginaryI", 0x2148); + nh_map_str_int32_set(_entity_references, "Implies", 0x21d2); + nh_map_str_int32_set(_entity_references, "Int", 0x222c); + nh_map_str_int32_set(_entity_references, "Integral", 0x222b); + nh_map_str_int32_set(_entity_references, "Intersection", 0x22c2); + nh_map_str_int32_set(_entity_references, "InvisibleComma", 0x2063); + nh_map_str_int32_set(_entity_references, "InvisibleTimes", 0x2062); + nh_map_str_int32_set(_entity_references, "Iogon", 0x12e); + nh_map_str_int32_set(_entity_references, "Iopf", 0x1d540); + nh_map_str_int32_set(_entity_references, "Iota", 0x399); + nh_map_str_int32_set(_entity_references, "Iscr", 0x2110); + nh_map_str_int32_set(_entity_references, "Itilde", 0x128); + nh_map_str_int32_set(_entity_references, "Iukcy", 0x406); + nh_map_str_int32_set(_entity_references, "Iuml", 0xcf); + nh_map_str_int32_set(_entity_references, "Jcirc", 0x134); + nh_map_str_int32_set(_entity_references, "Jcy", 0x419); + nh_map_str_int32_set(_entity_references, "Jfr", 0x1d50d); + nh_map_str_int32_set(_entity_references, "Jopf", 0x1d541); + nh_map_str_int32_set(_entity_references, "Jscr", 0x1d4a5); + nh_map_str_int32_set(_entity_references, "Jsercy", 0x408); + nh_map_str_int32_set(_entity_references, "Jukcy", 0x404); + nh_map_str_int32_set(_entity_references, "KHcy", 0x425); + nh_map_str_int32_set(_entity_references, "KJcy", 0x40c); + nh_map_str_int32_set(_entity_references, "Kappa", 0x39a); + nh_map_str_int32_set(_entity_references, "Kcedil", 0x136); + nh_map_str_int32_set(_entity_references, "Kcy", 0x41a); + nh_map_str_int32_set(_entity_references, "Kfr", 0x1d50e); + nh_map_str_int32_set(_entity_references, "Kopf", 0x1d542); + nh_map_str_int32_set(_entity_references, "Kscr", 0x1d4a6); + nh_map_str_int32_set(_entity_references, "LJcy", 0x409); + nh_map_str_int32_set(_entity_references, "LT", 0x3c); + nh_map_str_int32_set(_entity_references, "Lacute", 0x139); + nh_map_str_int32_set(_entity_references, "Lambda", 0x39b); + nh_map_str_int32_set(_entity_references, "Lang", 0x27ea); + nh_map_str_int32_set(_entity_references, "Laplacetrf", 0x2112); + nh_map_str_int32_set(_entity_references, "Larr", 0x219e); + nh_map_str_int32_set(_entity_references, "Lcaron", 0x13d); + nh_map_str_int32_set(_entity_references, "Lcedil", 0x13b); + nh_map_str_int32_set(_entity_references, "Lcy", 0x41b); + nh_map_str_int32_set(_entity_references, "LeftAngleBracket", 0x27e8); + nh_map_str_int32_set(_entity_references, "LeftArrow", 0x2190); + nh_map_str_int32_set(_entity_references, "LeftArrowBar", 0x21e4); + nh_map_str_int32_set(_entity_references, "LeftArrowRightArrow", 0x21c6); + nh_map_str_int32_set(_entity_references, "LeftCeiling", 0x2308); + nh_map_str_int32_set(_entity_references, "LeftDoubleBracket", 0x27e6); + nh_map_str_int32_set(_entity_references, "LeftDownTeeVector", 0x2961); + nh_map_str_int32_set(_entity_references, "LeftDownVector", 0x21c3); + nh_map_str_int32_set(_entity_references, "LeftDownVectorBar", 0x2959); + nh_map_str_int32_set(_entity_references, "LeftFloor", 0x230a); + nh_map_str_int32_set(_entity_references, "LeftRightArrow", 0x2194); + nh_map_str_int32_set(_entity_references, "LeftRightVector", 0x294e); + nh_map_str_int32_set(_entity_references, "LeftTee", 0x22a3); + nh_map_str_int32_set(_entity_references, "LeftTeeArrow", 0x21a4); + nh_map_str_int32_set(_entity_references, "LeftTeeVector", 0x295a); + nh_map_str_int32_set(_entity_references, "LeftTriangle", 0x22b2); + nh_map_str_int32_set(_entity_references, "LeftTriangleBar", 0x29cf); + nh_map_str_int32_set(_entity_references, "LeftTriangleEqual", 0x22b4); + nh_map_str_int32_set(_entity_references, "LeftUpDownVector", 0x2951); + nh_map_str_int32_set(_entity_references, "LeftUpTeeVector", 0x2960); + nh_map_str_int32_set(_entity_references, "LeftUpVector", 0x21bf); + nh_map_str_int32_set(_entity_references, "LeftUpVectorBar", 0x2958); + nh_map_str_int32_set(_entity_references, "LeftVector", 0x21bc); + nh_map_str_int32_set(_entity_references, "LeftVectorBar", 0x2952); + nh_map_str_int32_set(_entity_references, "Leftarrow", 0x21d0); + nh_map_str_int32_set(_entity_references, "Leftrightarrow", 0x21d4); + nh_map_str_int32_set(_entity_references, "LessEqualGreater", 0x22da); + nh_map_str_int32_set(_entity_references, "LessFullEqual", 0x2266); + nh_map_str_int32_set(_entity_references, "LessGreater", 0x2276); + nh_map_str_int32_set(_entity_references, "LessLess", 0x2aa1); + nh_map_str_int32_set(_entity_references, "LessSlantEqual", 0x2a7d); + nh_map_str_int32_set(_entity_references, "LessTilde", 0x2272); + nh_map_str_int32_set(_entity_references, "Lfr", 0x1d50f); + nh_map_str_int32_set(_entity_references, "Ll", 0x22d8); + nh_map_str_int32_set(_entity_references, "Lleftarrow", 0x21da); + nh_map_str_int32_set(_entity_references, "Lmidot", 0x13f); + nh_map_str_int32_set(_entity_references, "LongLeftArrow", 0x27f5); + nh_map_str_int32_set(_entity_references, "LongLeftRightArrow", 0x27f7); + nh_map_str_int32_set(_entity_references, "LongRightArrow", 0x27f6); + nh_map_str_int32_set(_entity_references, "Longleftarrow", 0x27f8); + nh_map_str_int32_set(_entity_references, "Longleftrightarrow", 0x27fa); + nh_map_str_int32_set(_entity_references, "Longrightarrow", 0x27f9); + nh_map_str_int32_set(_entity_references, "Lopf", 0x1d543); + nh_map_str_int32_set(_entity_references, "LowerLeftArrow", 0x2199); + nh_map_str_int32_set(_entity_references, "LowerRightArrow", 0x2198); + nh_map_str_int32_set(_entity_references, "Lscr", 0x2112); + nh_map_str_int32_set(_entity_references, "Lsh", 0x21b0); + nh_map_str_int32_set(_entity_references, "Lstrok", 0x141); + nh_map_str_int32_set(_entity_references, "Lt", 0x226a); + nh_map_str_int32_set(_entity_references, "Map", 0x2905); + nh_map_str_int32_set(_entity_references, "Mcy", 0x41c); + nh_map_str_int32_set(_entity_references, "MediumSpace", 0x205f); + nh_map_str_int32_set(_entity_references, "Mellintrf", 0x2133); + nh_map_str_int32_set(_entity_references, "Mfr", 0x1d510); + nh_map_str_int32_set(_entity_references, "MinusPlus", 0x2213); + nh_map_str_int32_set(_entity_references, "Mopf", 0x1d544); + nh_map_str_int32_set(_entity_references, "Mscr", 0x2133); + nh_map_str_int32_set(_entity_references, "Mu", 0x39c); + nh_map_str_int32_set(_entity_references, "NJcy", 0x40a); + nh_map_str_int32_set(_entity_references, "Nacute", 0x143); + nh_map_str_int32_set(_entity_references, "Ncaron", 0x147); + nh_map_str_int32_set(_entity_references, "Ncedil", 0x145); + nh_map_str_int32_set(_entity_references, "Ncy", 0x41d); + nh_map_str_int32_set(_entity_references, "NegativeMediumSpace", 0x200b); + nh_map_str_int32_set(_entity_references, "NegativeThickSpace", 0x200b); + nh_map_str_int32_set(_entity_references, "NegativeThinSpace", 0x200b); + nh_map_str_int32_set(_entity_references, "NegativeVeryThinSpace", + 0x200b); + nh_map_str_int32_set(_entity_references, "NestedGreaterGreater", + 0x226b); + nh_map_str_int32_set(_entity_references, "NestedLessLess", 0x226a); + nh_map_str_int32_set(_entity_references, "NewLine", 0xa); + nh_map_str_int32_set(_entity_references, "Nfr", 0x1d511); + nh_map_str_int32_set(_entity_references, "NoBreak", 0x2060); + nh_map_str_int32_set(_entity_references, "NonBreakingSpace", 0xa0); + nh_map_str_int32_set(_entity_references, "Nopf", 0x2115); + nh_map_str_int32_set(_entity_references, "Not", 0x2aec); + nh_map_str_int32_set(_entity_references, "NotCongruent", 0x2262); + nh_map_str_int32_set(_entity_references, "NotCupCap", 0x226d); + nh_map_str_int32_set(_entity_references, "NotDoubleVerticalBar", + 0x2226); + nh_map_str_int32_set(_entity_references, "NotElement", 0x2209); + nh_map_str_int32_set(_entity_references, "NotEqual", 0x2260); + nh_map_str_int32_set(_entity_references, "NotExists", 0x2204); + nh_map_str_int32_set(_entity_references, "NotGreater", 0x226f); + nh_map_str_int32_set(_entity_references, "NotGreaterEqual", 0x2271); + nh_map_str_int32_set(_entity_references, "NotGreaterLess", 0x2279); + nh_map_str_int32_set(_entity_references, "NotGreaterTilde", 0x2275); + nh_map_str_int32_set(_entity_references, "NotLeftTriangle", 0x22ea); + nh_map_str_int32_set(_entity_references, "NotLeftTriangleEqual", + 0x22ec); + nh_map_str_int32_set(_entity_references, "NotLess", 0x226e); + nh_map_str_int32_set(_entity_references, "NotLessEqual", 0x2270); + nh_map_str_int32_set(_entity_references, "NotLessGreater", 0x2278); + nh_map_str_int32_set(_entity_references, "NotLessTilde", 0x2274); + nh_map_str_int32_set(_entity_references, "NotPrecedes", 0x2280); + nh_map_str_int32_set(_entity_references, "NotPrecedesSlantEqual", + 0x22e0); + nh_map_str_int32_set(_entity_references, "NotReverseElement", 0x220c); + nh_map_str_int32_set(_entity_references, "NotRightTriangle", 0x22eb); + nh_map_str_int32_set(_entity_references, "NotRightTriangleEqual", + 0x22ed); + nh_map_str_int32_set(_entity_references, "NotSquareSubsetEqual", + 0x22e2); + nh_map_str_int32_set(_entity_references, "NotSquareSupersetEqual", + 0x22e3); + nh_map_str_int32_set(_entity_references, "NotSubsetEqual", 0x2288); + nh_map_str_int32_set(_entity_references, "NotSucceeds", 0x2281); + nh_map_str_int32_set(_entity_references, "NotSucceedsSlantEqual", + 0x22e1); + nh_map_str_int32_set(_entity_references, "NotSupersetEqual", 0x2289); + nh_map_str_int32_set(_entity_references, "NotTilde", 0x2241); + nh_map_str_int32_set(_entity_references, "NotTildeEqual", 0x2244); + nh_map_str_int32_set(_entity_references, "NotTildeFullEqual", 0x2247); + nh_map_str_int32_set(_entity_references, "NotTildeTilde", 0x2249); + nh_map_str_int32_set(_entity_references, "NotVerticalBar", 0x2224); + nh_map_str_int32_set(_entity_references, "Nscr", 0x1d4a9); + nh_map_str_int32_set(_entity_references, "Ntilde", 0xd1); + nh_map_str_int32_set(_entity_references, "Nu", 0x39d); + nh_map_str_int32_set(_entity_references, "OElig", 0x152); + nh_map_str_int32_set(_entity_references, "Oacute", 0xd3); + nh_map_str_int32_set(_entity_references, "Ocirc", 0xd4); + nh_map_str_int32_set(_entity_references, "Ocy", 0x41e); + nh_map_str_int32_set(_entity_references, "Odblac", 0x150); + nh_map_str_int32_set(_entity_references, "Ofr", 0x1d512); + nh_map_str_int32_set(_entity_references, "Ograve", 0xd2); + nh_map_str_int32_set(_entity_references, "Omacr", 0x14c); + nh_map_str_int32_set(_entity_references, "Omega", 0x3a9); + nh_map_str_int32_set(_entity_references, "Omicron", 0x39f); + nh_map_str_int32_set(_entity_references, "Oopf", 0x1d546); + nh_map_str_int32_set(_entity_references, "OpenCurlyDoubleQuote", + 0x201c); + nh_map_str_int32_set(_entity_references, "OpenCurlyQuote", 0x2018); + nh_map_str_int32_set(_entity_references, "Or", 0x2a54); + nh_map_str_int32_set(_entity_references, "Oscr", 0x1d4aa); + nh_map_str_int32_set(_entity_references, "Oslash", 0xd8); + nh_map_str_int32_set(_entity_references, "Otilde", 0xd5); + nh_map_str_int32_set(_entity_references, "Otimes", 0x2a37); + nh_map_str_int32_set(_entity_references, "Ouml", 0xd6); + nh_map_str_int32_set(_entity_references, "OverBar", 0xaf); + nh_map_str_int32_set(_entity_references, "OverBrace", 0x23de); + nh_map_str_int32_set(_entity_references, "OverBracket", 0x23b4); + nh_map_str_int32_set(_entity_references, "OverParenthesis", 0x23dc); + nh_map_str_int32_set(_entity_references, "PartialD", 0x2202); + nh_map_str_int32_set(_entity_references, "Pcy", 0x41f); + nh_map_str_int32_set(_entity_references, "Pfr", 0x1d513); + nh_map_str_int32_set(_entity_references, "Phi", 0x3a6); + nh_map_str_int32_set(_entity_references, "Pi", 0x3a0); + nh_map_str_int32_set(_entity_references, "PlusMinus", 0xb1); + nh_map_str_int32_set(_entity_references, "Poincareplane", 0x210c); + nh_map_str_int32_set(_entity_references, "Popf", 0x2119); + nh_map_str_int32_set(_entity_references, "Pr", 0x2abb); + nh_map_str_int32_set(_entity_references, "Precedes", 0x227a); + nh_map_str_int32_set(_entity_references, "PrecedesEqual", 0x2aaf); + nh_map_str_int32_set(_entity_references, "PrecedesSlantEqual", 0x227c); + nh_map_str_int32_set(_entity_references, "PrecedesTilde", 0x227e); + nh_map_str_int32_set(_entity_references, "Prime", 0x2033); + nh_map_str_int32_set(_entity_references, "Product", 0x220f); + nh_map_str_int32_set(_entity_references, "Proportion", 0x2237); + nh_map_str_int32_set(_entity_references, "Proportional", 0x221d); + nh_map_str_int32_set(_entity_references, "Pscr", 0x1d4ab); + nh_map_str_int32_set(_entity_references, "Psi", 0x3a8); + nh_map_str_int32_set(_entity_references, "QUOT", 0x22); + nh_map_str_int32_set(_entity_references, "Qfr", 0x1d514); + nh_map_str_int32_set(_entity_references, "Qopf", 0x211a); + nh_map_str_int32_set(_entity_references, "Qscr", 0x1d4ac); + nh_map_str_int32_set(_entity_references, "RBarr", 0x2910); + nh_map_str_int32_set(_entity_references, "REG", 0xae); + nh_map_str_int32_set(_entity_references, "Racute", 0x154); + nh_map_str_int32_set(_entity_references, "Rang", 0x27eb); + nh_map_str_int32_set(_entity_references, "Rarr", 0x21a0); + nh_map_str_int32_set(_entity_references, "Rarrtl", 0x2916); + nh_map_str_int32_set(_entity_references, "Rcaron", 0x158); + nh_map_str_int32_set(_entity_references, "Rcedil", 0x156); + nh_map_str_int32_set(_entity_references, "Rcy", 0x420); + nh_map_str_int32_set(_entity_references, "Re", 0x211c); + nh_map_str_int32_set(_entity_references, "ReverseElement", 0x220b); + nh_map_str_int32_set(_entity_references, "ReverseEquilibrium", 0x21cb); + nh_map_str_int32_set(_entity_references, "ReverseUpEquilibrium", + 0x296f); + nh_map_str_int32_set(_entity_references, "Rfr", 0x211c); + nh_map_str_int32_set(_entity_references, "Rho", 0x3a1); + nh_map_str_int32_set(_entity_references, "RightAngleBracket", 0x27e9); + nh_map_str_int32_set(_entity_references, "RightArrow", 0x2192); + nh_map_str_int32_set(_entity_references, "RightArrowBar", 0x21e5); + nh_map_str_int32_set(_entity_references, "RightArrowLeftArrow", 0x21c4); + nh_map_str_int32_set(_entity_references, "RightCeiling", 0x2309); + nh_map_str_int32_set(_entity_references, "RightDoubleBracket", 0x27e7); + nh_map_str_int32_set(_entity_references, "RightDownTeeVector", 0x295d); + nh_map_str_int32_set(_entity_references, "RightDownVector", 0x21c2); + nh_map_str_int32_set(_entity_references, "RightDownVectorBar", 0x2955); + nh_map_str_int32_set(_entity_references, "RightFloor", 0x230b); + nh_map_str_int32_set(_entity_references, "RightTee", 0x22a2); + nh_map_str_int32_set(_entity_references, "RightTeeArrow", 0x21a6); + nh_map_str_int32_set(_entity_references, "RightTeeVector", 0x295b); + nh_map_str_int32_set(_entity_references, "RightTriangle", 0x22b3); + nh_map_str_int32_set(_entity_references, "RightTriangleBar", 0x29d0); + nh_map_str_int32_set(_entity_references, "RightTriangleEqual", 0x22b5); + nh_map_str_int32_set(_entity_references, "RightUpDownVector", 0x294f); + nh_map_str_int32_set(_entity_references, "RightUpTeeVector", 0x295c); + nh_map_str_int32_set(_entity_references, "RightUpVector", 0x21be); + nh_map_str_int32_set(_entity_references, "RightUpVectorBar", 0x2954); + nh_map_str_int32_set(_entity_references, "RightVector", 0x21c0); + nh_map_str_int32_set(_entity_references, "RightVectorBar", 0x2953); + nh_map_str_int32_set(_entity_references, "Rightarrow", 0x21d2); + nh_map_str_int32_set(_entity_references, "Ropf", 0x211d); + nh_map_str_int32_set(_entity_references, "RoundImplies", 0x2970); + nh_map_str_int32_set(_entity_references, "Rrightarrow", 0x21db); + nh_map_str_int32_set(_entity_references, "Rscr", 0x211b); + nh_map_str_int32_set(_entity_references, "Rsh", 0x21b1); + nh_map_str_int32_set(_entity_references, "RuleDelayed", 0x29f4); + nh_map_str_int32_set(_entity_references, "SHCHcy", 0x429); + nh_map_str_int32_set(_entity_references, "SHcy", 0x428); + nh_map_str_int32_set(_entity_references, "SOFTcy", 0x42c); + nh_map_str_int32_set(_entity_references, "Sacute", 0x15a); + nh_map_str_int32_set(_entity_references, "Sc", 0x2abc); + nh_map_str_int32_set(_entity_references, "Scaron", 0x160); + nh_map_str_int32_set(_entity_references, "Scedil", 0x15e); + nh_map_str_int32_set(_entity_references, "Scirc", 0x15c); + nh_map_str_int32_set(_entity_references, "Scy", 0x421); + nh_map_str_int32_set(_entity_references, "Sfr", 0x1d516); + nh_map_str_int32_set(_entity_references, "ShortDownArrow", 0x2193); + nh_map_str_int32_set(_entity_references, "ShortLeftArrow", 0x2190); + nh_map_str_int32_set(_entity_references, "ShortRightArrow", 0x2192); + nh_map_str_int32_set(_entity_references, "ShortUpArrow", 0x2191); + nh_map_str_int32_set(_entity_references, "Sigma", 0x3a3); + nh_map_str_int32_set(_entity_references, "SmallCircle", 0x2218); + nh_map_str_int32_set(_entity_references, "Sopf", 0x1d54a); + nh_map_str_int32_set(_entity_references, "Sqrt", 0x221a); + nh_map_str_int32_set(_entity_references, "Square", 0x25a1); + nh_map_str_int32_set(_entity_references, "SquareIntersection", 0x2293); + nh_map_str_int32_set(_entity_references, "SquareSubset", 0x228f); + nh_map_str_int32_set(_entity_references, "SquareSubsetEqual", 0x2291); + nh_map_str_int32_set(_entity_references, "SquareSuperset", 0x2290); + nh_map_str_int32_set(_entity_references, "SquareSupersetEqual", 0x2292); + nh_map_str_int32_set(_entity_references, "SquareUnion", 0x2294); + nh_map_str_int32_set(_entity_references, "Sscr", 0x1d4ae); + nh_map_str_int32_set(_entity_references, "Star", 0x22c6); + nh_map_str_int32_set(_entity_references, "Sub", 0x22d0); + nh_map_str_int32_set(_entity_references, "Subset", 0x22d0); + nh_map_str_int32_set(_entity_references, "SubsetEqual", 0x2286); + nh_map_str_int32_set(_entity_references, "Succeeds", 0x227b); + nh_map_str_int32_set(_entity_references, "SucceedsEqual", 0x2ab0); + nh_map_str_int32_set(_entity_references, "SucceedsSlantEqual", 0x227d); + nh_map_str_int32_set(_entity_references, "SucceedsTilde", 0x227f); + nh_map_str_int32_set(_entity_references, "SuchThat", 0x220b); + nh_map_str_int32_set(_entity_references, "Sum", 0x2211); + nh_map_str_int32_set(_entity_references, "Sup", 0x22d1); + nh_map_str_int32_set(_entity_references, "Superset", 0x2283); + nh_map_str_int32_set(_entity_references, "SupersetEqual", 0x2287); + nh_map_str_int32_set(_entity_references, "Supset", 0x22d1); + nh_map_str_int32_set(_entity_references, "THORN", 0xde); + nh_map_str_int32_set(_entity_references, "TRADE", 0x2122); + nh_map_str_int32_set(_entity_references, "TSHcy", 0x40b); + nh_map_str_int32_set(_entity_references, "TScy", 0x426); + nh_map_str_int32_set(_entity_references, "Tab", 0x9); + nh_map_str_int32_set(_entity_references, "Tau", 0x3a4); + nh_map_str_int32_set(_entity_references, "Tcaron", 0x164); + nh_map_str_int32_set(_entity_references, "Tcedil", 0x162); + nh_map_str_int32_set(_entity_references, "Tcy", 0x422); + nh_map_str_int32_set(_entity_references, "Tfr", 0x1d517); + nh_map_str_int32_set(_entity_references, "Therefore", 0x2234); + nh_map_str_int32_set(_entity_references, "Theta", 0x398); + nh_map_str_int32_set(_entity_references, "ThinSpace", 0x2009); + nh_map_str_int32_set(_entity_references, "Tilde", 0x223c); + nh_map_str_int32_set(_entity_references, "TildeEqual", 0x2243); + nh_map_str_int32_set(_entity_references, "TildeFullEqual", 0x2245); + nh_map_str_int32_set(_entity_references, "TildeTilde", 0x2248); + nh_map_str_int32_set(_entity_references, "Topf", 0x1d54b); + nh_map_str_int32_set(_entity_references, "TripleDot", 0x20db); + nh_map_str_int32_set(_entity_references, "Tscr", 0x1d4af); + nh_map_str_int32_set(_entity_references, "Tstrok", 0x166); + nh_map_str_int32_set(_entity_references, "Uacute", 0xda); + nh_map_str_int32_set(_entity_references, "Uarr", 0x219f); + nh_map_str_int32_set(_entity_references, "Uarrocir", 0x2949); + nh_map_str_int32_set(_entity_references, "Ubrcy", 0x40e); + nh_map_str_int32_set(_entity_references, "Ubreve", 0x16c); + nh_map_str_int32_set(_entity_references, "Ucirc", 0xdb); + nh_map_str_int32_set(_entity_references, "Ucy", 0x423); + nh_map_str_int32_set(_entity_references, "Udblac", 0x170); + nh_map_str_int32_set(_entity_references, "Ufr", 0x1d518); + nh_map_str_int32_set(_entity_references, "Ugrave", 0xd9); + nh_map_str_int32_set(_entity_references, "Umacr", 0x16a); + nh_map_str_int32_set(_entity_references, "UnderBar", 0x332); + nh_map_str_int32_set(_entity_references, "UnderBrace", 0x23df); + nh_map_str_int32_set(_entity_references, "UnderBracket", 0x23b5); + nh_map_str_int32_set(_entity_references, "UnderParenthesis", 0x23dd); + nh_map_str_int32_set(_entity_references, "Union", 0x22c3); + nh_map_str_int32_set(_entity_references, "UnionPlus", 0x228e); + nh_map_str_int32_set(_entity_references, "Uogon", 0x172); + nh_map_str_int32_set(_entity_references, "Uopf", 0x1d54c); + nh_map_str_int32_set(_entity_references, "UpArrow", 0x2191); + nh_map_str_int32_set(_entity_references, "UpArrowBar", 0x2912); + nh_map_str_int32_set(_entity_references, "UpArrowDownArrow", 0x21c5); + nh_map_str_int32_set(_entity_references, "UpDownArrow", 0x2195); + nh_map_str_int32_set(_entity_references, "UpEquilibrium", 0x296e); + nh_map_str_int32_set(_entity_references, "UpTee", 0x22a5); + nh_map_str_int32_set(_entity_references, "UpTeeArrow", 0x21a5); + nh_map_str_int32_set(_entity_references, "Uparrow", 0x21d1); + nh_map_str_int32_set(_entity_references, "Updownarrow", 0x21d5); + nh_map_str_int32_set(_entity_references, "UpperLeftArrow", 0x2196); + nh_map_str_int32_set(_entity_references, "UpperRightArrow", 0x2197); + nh_map_str_int32_set(_entity_references, "Upsi", 0x3d2); + nh_map_str_int32_set(_entity_references, "Upsilon", 0x3a5); + nh_map_str_int32_set(_entity_references, "Uring", 0x16e); + nh_map_str_int32_set(_entity_references, "Uscr", 0x1d4b0); + nh_map_str_int32_set(_entity_references, "Utilde", 0x168); + nh_map_str_int32_set(_entity_references, "Uuml", 0xdc); + nh_map_str_int32_set(_entity_references, "VDash", 0x22ab); + nh_map_str_int32_set(_entity_references, "Vbar", 0x2aeb); + nh_map_str_int32_set(_entity_references, "Vcy", 0x412); + nh_map_str_int32_set(_entity_references, "Vdash", 0x22a9); + nh_map_str_int32_set(_entity_references, "Vdashl", 0x2ae6); + nh_map_str_int32_set(_entity_references, "Vee", 0x22c1); + nh_map_str_int32_set(_entity_references, "Verbar", 0x2016); + nh_map_str_int32_set(_entity_references, "Vert", 0x2016); + nh_map_str_int32_set(_entity_references, "VerticalBar", 0x2223); + nh_map_str_int32_set(_entity_references, "VerticalLine", 0x7c); + nh_map_str_int32_set(_entity_references, "VerticalSeparator", 0x2758); + nh_map_str_int32_set(_entity_references, "VerticalTilde", 0x2240); + nh_map_str_int32_set(_entity_references, "VeryThinSpace", 0x200a); + nh_map_str_int32_set(_entity_references, "Vfr", 0x1d519); + nh_map_str_int32_set(_entity_references, "Vopf", 0x1d54d); + nh_map_str_int32_set(_entity_references, "Vscr", 0x1d4b1); + nh_map_str_int32_set(_entity_references, "Vvdash", 0x22aa); + nh_map_str_int32_set(_entity_references, "Wcirc", 0x174); + nh_map_str_int32_set(_entity_references, "Wedge", 0x22c0); + nh_map_str_int32_set(_entity_references, "Wfr", 0x1d51a); + nh_map_str_int32_set(_entity_references, "Wopf", 0x1d54e); + nh_map_str_int32_set(_entity_references, "Wscr", 0x1d4b2); + nh_map_str_int32_set(_entity_references, "Xfr", 0x1d51b); + nh_map_str_int32_set(_entity_references, "Xi", 0x39e); + nh_map_str_int32_set(_entity_references, "Xopf", 0x1d54f); + nh_map_str_int32_set(_entity_references, "Xscr", 0x1d4b3); + nh_map_str_int32_set(_entity_references, "YAcy", 0x42f); + nh_map_str_int32_set(_entity_references, "YIcy", 0x407); + nh_map_str_int32_set(_entity_references, "YUcy", 0x42e); + nh_map_str_int32_set(_entity_references, "Yacute", 0xdd); + nh_map_str_int32_set(_entity_references, "Ycirc", 0x176); + nh_map_str_int32_set(_entity_references, "Ycy", 0x42b); + nh_map_str_int32_set(_entity_references, "Yfr", 0x1d51c); + nh_map_str_int32_set(_entity_references, "Yopf", 0x1d550); + nh_map_str_int32_set(_entity_references, "Yscr", 0x1d4b4); + nh_map_str_int32_set(_entity_references, "Yuml", 0x178); + nh_map_str_int32_set(_entity_references, "ZHcy", 0x416); + nh_map_str_int32_set(_entity_references, "Zacute", 0x179); + nh_map_str_int32_set(_entity_references, "Zcaron", 0x17d); + nh_map_str_int32_set(_entity_references, "Zcy", 0x417); + nh_map_str_int32_set(_entity_references, "Zdot", 0x17b); + nh_map_str_int32_set(_entity_references, "ZeroWidthSpace", 0x200b); + nh_map_str_int32_set(_entity_references, "Zeta", 0x396); + nh_map_str_int32_set(_entity_references, "Zfr", 0x2128); + nh_map_str_int32_set(_entity_references, "Zopf", 0x2124); + nh_map_str_int32_set(_entity_references, "Zscr", 0x1d4b5); + nh_map_str_int32_set(_entity_references, "aacute", 0xe1); + nh_map_str_int32_set(_entity_references, "abreve", 0x103); + nh_map_str_int32_set(_entity_references, "ac", 0x223e); + nh_map_str_int32_set(_entity_references, "acd", 0x223f); + nh_map_str_int32_set(_entity_references, "acirc", 0xe2); + nh_map_str_int32_set(_entity_references, "acute", 0xb4); + nh_map_str_int32_set(_entity_references, "acy", 0x430); + nh_map_str_int32_set(_entity_references, "aelig", 0xe6); + nh_map_str_int32_set(_entity_references, "af", 0x2061); + nh_map_str_int32_set(_entity_references, "afr", 0x1d51e); + nh_map_str_int32_set(_entity_references, "agrave", 0xe0); + nh_map_str_int32_set(_entity_references, "alefsym", 0x2135); + nh_map_str_int32_set(_entity_references, "aleph", 0x2135); + nh_map_str_int32_set(_entity_references, "alpha", 0x3b1); + nh_map_str_int32_set(_entity_references, "amacr", 0x101); + nh_map_str_int32_set(_entity_references, "amalg", 0x2a3f); + nh_map_str_int32_set(_entity_references, "amp", 0x26); + nh_map_str_int32_set(_entity_references, "and", 0x2227); + nh_map_str_int32_set(_entity_references, "andand", 0x2a55); + nh_map_str_int32_set(_entity_references, "andd", 0x2a5c); + nh_map_str_int32_set(_entity_references, "andslope", 0x2a58); + nh_map_str_int32_set(_entity_references, "andv", 0x2a5a); + nh_map_str_int32_set(_entity_references, "ang", 0x2220); + nh_map_str_int32_set(_entity_references, "ange", 0x29a4); + nh_map_str_int32_set(_entity_references, "angle", 0x2220); + nh_map_str_int32_set(_entity_references, "angmsd", 0x2221); + nh_map_str_int32_set(_entity_references, "angmsdaa", 0x29a8); + nh_map_str_int32_set(_entity_references, "angmsdab", 0x29a9); + nh_map_str_int32_set(_entity_references, "angmsdac", 0x29aa); + nh_map_str_int32_set(_entity_references, "angmsdad", 0x29ab); + nh_map_str_int32_set(_entity_references, "angmsdae", 0x29ac); + nh_map_str_int32_set(_entity_references, "angmsdaf", 0x29ad); + nh_map_str_int32_set(_entity_references, "angmsdag", 0x29ae); + nh_map_str_int32_set(_entity_references, "angmsdah", 0x29af); + nh_map_str_int32_set(_entity_references, "angrt", 0x221f); + nh_map_str_int32_set(_entity_references, "angrtvb", 0x22be); + nh_map_str_int32_set(_entity_references, "angrtvbd", 0x299d); + nh_map_str_int32_set(_entity_references, "angsph", 0x2222); + nh_map_str_int32_set(_entity_references, "angst", 0x212b); + nh_map_str_int32_set(_entity_references, "angzarr", 0x237c); + nh_map_str_int32_set(_entity_references, "aogon", 0x105); + nh_map_str_int32_set(_entity_references, "aopf", 0x1d552); + nh_map_str_int32_set(_entity_references, "ap", 0x2248); + nh_map_str_int32_set(_entity_references, "apE", 0x2a70); + nh_map_str_int32_set(_entity_references, "apacir", 0x2a6f); + nh_map_str_int32_set(_entity_references, "ape", 0x224a); + nh_map_str_int32_set(_entity_references, "apid", 0x224b); + nh_map_str_int32_set(_entity_references, "apos", 0x27); + nh_map_str_int32_set(_entity_references, "approx", 0x2248); + nh_map_str_int32_set(_entity_references, "approxeq", 0x224a); + nh_map_str_int32_set(_entity_references, "aring", 0xe5); + nh_map_str_int32_set(_entity_references, "ascr", 0x1d4b6); + nh_map_str_int32_set(_entity_references, "ast", 0x2a); + nh_map_str_int32_set(_entity_references, "asymp", 0x2248); + nh_map_str_int32_set(_entity_references, "asympeq", 0x224d); + nh_map_str_int32_set(_entity_references, "atilde", 0xe3); + nh_map_str_int32_set(_entity_references, "auml", 0xe4); + nh_map_str_int32_set(_entity_references, "awconint", 0x2233); + nh_map_str_int32_set(_entity_references, "awint", 0x2a11); + nh_map_str_int32_set(_entity_references, "bNot", 0x2aed); + nh_map_str_int32_set(_entity_references, "backcong", 0x224c); + nh_map_str_int32_set(_entity_references, "backepsilon", 0x3f6); + nh_map_str_int32_set(_entity_references, "backprime", 0x2035); + nh_map_str_int32_set(_entity_references, "backsim", 0x223d); + nh_map_str_int32_set(_entity_references, "backsimeq", 0x22cd); + nh_map_str_int32_set(_entity_references, "barvee", 0x22bd); + nh_map_str_int32_set(_entity_references, "barwed", 0x2305); + nh_map_str_int32_set(_entity_references, "barwedge", 0x2305); + nh_map_str_int32_set(_entity_references, "bbrk", 0x23b5); + nh_map_str_int32_set(_entity_references, "bbrktbrk", 0x23b6); + nh_map_str_int32_set(_entity_references, "bcong", 0x224c); + nh_map_str_int32_set(_entity_references, "bcy", 0x431); + nh_map_str_int32_set(_entity_references, "bdquo", 0x201e); + nh_map_str_int32_set(_entity_references, "becaus", 0x2235); + nh_map_str_int32_set(_entity_references, "because", 0x2235); + nh_map_str_int32_set(_entity_references, "bemptyv", 0x29b0); + nh_map_str_int32_set(_entity_references, "bepsi", 0x3f6); + nh_map_str_int32_set(_entity_references, "bernou", 0x212c); + nh_map_str_int32_set(_entity_references, "beta", 0x3b2); + nh_map_str_int32_set(_entity_references, "beth", 0x2136); + nh_map_str_int32_set(_entity_references, "between", 0x226c); + nh_map_str_int32_set(_entity_references, "bfr", 0x1d51f); + nh_map_str_int32_set(_entity_references, "bigcap", 0x22c2); + nh_map_str_int32_set(_entity_references, "bigcirc", 0x25ef); + nh_map_str_int32_set(_entity_references, "bigcup", 0x22c3); + nh_map_str_int32_set(_entity_references, "bigodot", 0x2a00); + nh_map_str_int32_set(_entity_references, "bigoplus", 0x2a01); + nh_map_str_int32_set(_entity_references, "bigotimes", 0x2a02); + nh_map_str_int32_set(_entity_references, "bigsqcup", 0x2a06); + nh_map_str_int32_set(_entity_references, "bigstar", 0x2605); + nh_map_str_int32_set(_entity_references, "bigtriangledown", 0x25bd); + nh_map_str_int32_set(_entity_references, "bigtriangleup", 0x25b3); + nh_map_str_int32_set(_entity_references, "biguplus", 0x2a04); + nh_map_str_int32_set(_entity_references, "bigvee", 0x22c1); + nh_map_str_int32_set(_entity_references, "bigwedge", 0x22c0); + nh_map_str_int32_set(_entity_references, "bkarow", 0x290d); + nh_map_str_int32_set(_entity_references, "blacklozenge", 0x29eb); + nh_map_str_int32_set(_entity_references, "blacksquare", 0x25aa); + nh_map_str_int32_set(_entity_references, "blacktriangle", 0x25b4); + nh_map_str_int32_set(_entity_references, "blacktriangledown", 0x25be); + nh_map_str_int32_set(_entity_references, "blacktriangleleft", 0x25c2); + nh_map_str_int32_set(_entity_references, "blacktriangleright", 0x25b8); + nh_map_str_int32_set(_entity_references, "blank", 0x2423); + nh_map_str_int32_set(_entity_references, "blk12", 0x2592); + nh_map_str_int32_set(_entity_references, "blk14", 0x2591); + nh_map_str_int32_set(_entity_references, "blk34", 0x2593); + nh_map_str_int32_set(_entity_references, "block", 0x2588); + nh_map_str_int32_set(_entity_references, "bnot", 0x2310); + nh_map_str_int32_set(_entity_references, "bopf", 0x1d553); + nh_map_str_int32_set(_entity_references, "bot", 0x22a5); + nh_map_str_int32_set(_entity_references, "bottom", 0x22a5); + nh_map_str_int32_set(_entity_references, "bowtie", 0x22c8); + nh_map_str_int32_set(_entity_references, "boxDL", 0x2557); + nh_map_str_int32_set(_entity_references, "boxDR", 0x2554); + nh_map_str_int32_set(_entity_references, "boxDl", 0x2556); + nh_map_str_int32_set(_entity_references, "boxDr", 0x2553); + nh_map_str_int32_set(_entity_references, "boxH", 0x2550); + nh_map_str_int32_set(_entity_references, "boxHD", 0x2566); + nh_map_str_int32_set(_entity_references, "boxHU", 0x2569); + nh_map_str_int32_set(_entity_references, "boxHd", 0x2564); + nh_map_str_int32_set(_entity_references, "boxHu", 0x2567); + nh_map_str_int32_set(_entity_references, "boxUL", 0x255d); + nh_map_str_int32_set(_entity_references, "boxUR", 0x255a); + nh_map_str_int32_set(_entity_references, "boxUl", 0x255c); + nh_map_str_int32_set(_entity_references, "boxUr", 0x2559); + nh_map_str_int32_set(_entity_references, "boxV", 0x2551); + nh_map_str_int32_set(_entity_references, "boxVH", 0x256c); + nh_map_str_int32_set(_entity_references, "boxVL", 0x2563); + nh_map_str_int32_set(_entity_references, "boxVR", 0x2560); + nh_map_str_int32_set(_entity_references, "boxVh", 0x256b); + nh_map_str_int32_set(_entity_references, "boxVl", 0x2562); + nh_map_str_int32_set(_entity_references, "boxVr", 0x255f); + nh_map_str_int32_set(_entity_references, "boxbox", 0x29c9); + nh_map_str_int32_set(_entity_references, "boxdL", 0x2555); + nh_map_str_int32_set(_entity_references, "boxdR", 0x2552); + nh_map_str_int32_set(_entity_references, "boxdl", 0x2510); + nh_map_str_int32_set(_entity_references, "boxdr", 0x250c); + nh_map_str_int32_set(_entity_references, "boxh", 0x2500); + nh_map_str_int32_set(_entity_references, "boxhD", 0x2565); + nh_map_str_int32_set(_entity_references, "boxhU", 0x2568); + nh_map_str_int32_set(_entity_references, "boxhd", 0x252c); + nh_map_str_int32_set(_entity_references, "boxhu", 0x2534); + nh_map_str_int32_set(_entity_references, "boxminus", 0x229f); + nh_map_str_int32_set(_entity_references, "boxplus", 0x229e); + nh_map_str_int32_set(_entity_references, "boxtimes", 0x22a0); + nh_map_str_int32_set(_entity_references, "boxuL", 0x255b); + nh_map_str_int32_set(_entity_references, "boxuR", 0x2558); + nh_map_str_int32_set(_entity_references, "boxul", 0x2518); + nh_map_str_int32_set(_entity_references, "boxur", 0x2514); + nh_map_str_int32_set(_entity_references, "boxv", 0x2502); + nh_map_str_int32_set(_entity_references, "boxvH", 0x256a); + nh_map_str_int32_set(_entity_references, "boxvL", 0x2561); + nh_map_str_int32_set(_entity_references, "boxvR", 0x255e); + nh_map_str_int32_set(_entity_references, "boxvh", 0x253c); + nh_map_str_int32_set(_entity_references, "boxvl", 0x2524); + nh_map_str_int32_set(_entity_references, "boxvr", 0x251c); + nh_map_str_int32_set(_entity_references, "bprime", 0x2035); + nh_map_str_int32_set(_entity_references, "breve", 0x2d8); + nh_map_str_int32_set(_entity_references, "brvbar", 0xa6); + nh_map_str_int32_set(_entity_references, "bscr", 0x1d4b7); + nh_map_str_int32_set(_entity_references, "bsemi", 0x204f); + nh_map_str_int32_set(_entity_references, "bsim", 0x223d); + nh_map_str_int32_set(_entity_references, "bsime", 0x22cd); + nh_map_str_int32_set(_entity_references, "bsol", 0x5c); + nh_map_str_int32_set(_entity_references, "bsolb", 0x29c5); + nh_map_str_int32_set(_entity_references, "bull", 0x2022); + nh_map_str_int32_set(_entity_references, "bullet", 0x2022); + nh_map_str_int32_set(_entity_references, "bump", 0x224e); + nh_map_str_int32_set(_entity_references, "bumpE", 0x2aae); + nh_map_str_int32_set(_entity_references, "bumpe", 0x224f); + nh_map_str_int32_set(_entity_references, "bumpeq", 0x224f); + nh_map_str_int32_set(_entity_references, "cacute", 0x107); + nh_map_str_int32_set(_entity_references, "cap", 0x2229); + nh_map_str_int32_set(_entity_references, "capand", 0x2a44); + nh_map_str_int32_set(_entity_references, "capbrcup", 0x2a49); + nh_map_str_int32_set(_entity_references, "capcap", 0x2a4b); + nh_map_str_int32_set(_entity_references, "capcup", 0x2a47); + nh_map_str_int32_set(_entity_references, "capdot", 0x2a40); + nh_map_str_int32_set(_entity_references, "caret", 0x2041); + nh_map_str_int32_set(_entity_references, "caron", 0x2c7); + nh_map_str_int32_set(_entity_references, "ccaps", 0x2a4d); + nh_map_str_int32_set(_entity_references, "ccaron", 0x10d); + nh_map_str_int32_set(_entity_references, "ccedil", 0xe7); + nh_map_str_int32_set(_entity_references, "ccirc", 0x109); + nh_map_str_int32_set(_entity_references, "ccups", 0x2a4c); + nh_map_str_int32_set(_entity_references, "ccupssm", 0x2a50); + nh_map_str_int32_set(_entity_references, "cdot", 0x10b); + nh_map_str_int32_set(_entity_references, "cedil", 0xb8); + nh_map_str_int32_set(_entity_references, "cemptyv", 0x29b2); + nh_map_str_int32_set(_entity_references, "cent", 0xa2); + nh_map_str_int32_set(_entity_references, "centerdot", 0xb7); + nh_map_str_int32_set(_entity_references, "cfr", 0x1d520); + nh_map_str_int32_set(_entity_references, "chcy", 0x447); + nh_map_str_int32_set(_entity_references, "check", 0x2713); + nh_map_str_int32_set(_entity_references, "checkmark", 0x2713); + nh_map_str_int32_set(_entity_references, "chi", 0x3c7); + nh_map_str_int32_set(_entity_references, "cir", 0x25cb); + nh_map_str_int32_set(_entity_references, "cirE", 0x29c3); + nh_map_str_int32_set(_entity_references, "circ", 0x2c6); + nh_map_str_int32_set(_entity_references, "circeq", 0x2257); + nh_map_str_int32_set(_entity_references, "circlearrowleft", 0x21ba); + nh_map_str_int32_set(_entity_references, "circlearrowright", 0x21bb); + nh_map_str_int32_set(_entity_references, "circledR", 0xae); + nh_map_str_int32_set(_entity_references, "circledS", 0x24c8); + nh_map_str_int32_set(_entity_references, "circledast", 0x229b); + nh_map_str_int32_set(_entity_references, "circledcirc", 0x229a); + nh_map_str_int32_set(_entity_references, "circleddash", 0x229d); + nh_map_str_int32_set(_entity_references, "cire", 0x2257); + nh_map_str_int32_set(_entity_references, "cirfnint", 0x2a10); + nh_map_str_int32_set(_entity_references, "cirmid", 0x2aef); + nh_map_str_int32_set(_entity_references, "cirscir", 0x29c2); + nh_map_str_int32_set(_entity_references, "clubs", 0x2663); + nh_map_str_int32_set(_entity_references, "clubsuit", 0x2663); + nh_map_str_int32_set(_entity_references, "colon", 0x3a); + nh_map_str_int32_set(_entity_references, "colone", 0x2254); + nh_map_str_int32_set(_entity_references, "coloneq", 0x2254); + nh_map_str_int32_set(_entity_references, "comma", 0x2c); + nh_map_str_int32_set(_entity_references, "commat", 0x40); + nh_map_str_int32_set(_entity_references, "comp", 0x2201); + nh_map_str_int32_set(_entity_references, "compfn", 0x2218); + nh_map_str_int32_set(_entity_references, "complement", 0x2201); + nh_map_str_int32_set(_entity_references, "complexes", 0x2102); + nh_map_str_int32_set(_entity_references, "cong", 0x2245); + nh_map_str_int32_set(_entity_references, "congdot", 0x2a6d); + nh_map_str_int32_set(_entity_references, "conint", 0x222e); + nh_map_str_int32_set(_entity_references, "copf", 0x1d554); + nh_map_str_int32_set(_entity_references, "coprod", 0x2210); + nh_map_str_int32_set(_entity_references, "copy", 0xa9); + nh_map_str_int32_set(_entity_references, "copysr", 0x2117); + nh_map_str_int32_set(_entity_references, "crarr", 0x21b5); + nh_map_str_int32_set(_entity_references, "cross", 0x2717); + nh_map_str_int32_set(_entity_references, "cscr", 0x1d4b8); + nh_map_str_int32_set(_entity_references, "csub", 0x2acf); + nh_map_str_int32_set(_entity_references, "csube", 0x2ad1); + nh_map_str_int32_set(_entity_references, "csup", 0x2ad0); + nh_map_str_int32_set(_entity_references, "csupe", 0x2ad2); + nh_map_str_int32_set(_entity_references, "ctdot", 0x22ef); + nh_map_str_int32_set(_entity_references, "cudarrl", 0x2938); + nh_map_str_int32_set(_entity_references, "cudarrr", 0x2935); + nh_map_str_int32_set(_entity_references, "cuepr", 0x22de); + nh_map_str_int32_set(_entity_references, "cuesc", 0x22df); + nh_map_str_int32_set(_entity_references, "cularr", 0x21b6); + nh_map_str_int32_set(_entity_references, "cularrp", 0x293d); + nh_map_str_int32_set(_entity_references, "cup", 0x222a); + nh_map_str_int32_set(_entity_references, "cupbrcap", 0x2a48); + nh_map_str_int32_set(_entity_references, "cupcap", 0x2a46); + nh_map_str_int32_set(_entity_references, "cupcup", 0x2a4a); + nh_map_str_int32_set(_entity_references, "cupdot", 0x228d); + nh_map_str_int32_set(_entity_references, "cupor", 0x2a45); + nh_map_str_int32_set(_entity_references, "curarr", 0x21b7); + nh_map_str_int32_set(_entity_references, "curarrm", 0x293c); + nh_map_str_int32_set(_entity_references, "curlyeqprec", 0x22de); + nh_map_str_int32_set(_entity_references, "curlyeqsucc", 0x22df); + nh_map_str_int32_set(_entity_references, "curlyvee", 0x22ce); + nh_map_str_int32_set(_entity_references, "curlywedge", 0x22cf); + nh_map_str_int32_set(_entity_references, "curren", 0xa4); + nh_map_str_int32_set(_entity_references, "curvearrowleft", 0x21b6); + nh_map_str_int32_set(_entity_references, "curvearrowright", 0x21b7); + nh_map_str_int32_set(_entity_references, "cuvee", 0x22ce); + nh_map_str_int32_set(_entity_references, "cuwed", 0x22cf); + nh_map_str_int32_set(_entity_references, "cwconint", 0x2232); + nh_map_str_int32_set(_entity_references, "cwint", 0x2231); + nh_map_str_int32_set(_entity_references, "cylcty", 0x232d); + nh_map_str_int32_set(_entity_references, "dArr", 0x21d3); + nh_map_str_int32_set(_entity_references, "dHar", 0x2965); + nh_map_str_int32_set(_entity_references, "dagger", 0x2020); + nh_map_str_int32_set(_entity_references, "daleth", 0x2138); + nh_map_str_int32_set(_entity_references, "darr", 0x2193); + nh_map_str_int32_set(_entity_references, "dash", 0x2010); + nh_map_str_int32_set(_entity_references, "dashv", 0x22a3); + nh_map_str_int32_set(_entity_references, "dbkarow", 0x290f); + nh_map_str_int32_set(_entity_references, "dblac", 0x2dd); + nh_map_str_int32_set(_entity_references, "dcaron", 0x10f); + nh_map_str_int32_set(_entity_references, "dcy", 0x434); + nh_map_str_int32_set(_entity_references, "dd", 0x2146); + nh_map_str_int32_set(_entity_references, "ddagger", 0x2021); + nh_map_str_int32_set(_entity_references, "ddarr", 0x21ca); + nh_map_str_int32_set(_entity_references, "ddotseq", 0x2a77); + nh_map_str_int32_set(_entity_references, "deg", 0xb0); + nh_map_str_int32_set(_entity_references, "delta", 0x3b4); + nh_map_str_int32_set(_entity_references, "demptyv", 0x29b1); + nh_map_str_int32_set(_entity_references, "dfisht", 0x297f); + nh_map_str_int32_set(_entity_references, "dfr", 0x1d521); + nh_map_str_int32_set(_entity_references, "dharl", 0x21c3); + nh_map_str_int32_set(_entity_references, "dharr", 0x21c2); + nh_map_str_int32_set(_entity_references, "diam", 0x22c4); + nh_map_str_int32_set(_entity_references, "diamond", 0x22c4); + nh_map_str_int32_set(_entity_references, "diamondsuit", 0x2666); + nh_map_str_int32_set(_entity_references, "diams", 0x2666); + nh_map_str_int32_set(_entity_references, "die", 0xa8); + nh_map_str_int32_set(_entity_references, "digamma", 0x3dd); + nh_map_str_int32_set(_entity_references, "disin", 0x22f2); + nh_map_str_int32_set(_entity_references, "div", 0xf7); + nh_map_str_int32_set(_entity_references, "divide", 0xf7); + nh_map_str_int32_set(_entity_references, "divideontimes", 0x22c7); + nh_map_str_int32_set(_entity_references, "divonx", 0x22c7); + nh_map_str_int32_set(_entity_references, "djcy", 0x452); + nh_map_str_int32_set(_entity_references, "dlcorn", 0x231e); + nh_map_str_int32_set(_entity_references, "dlcrop", 0x230d); + nh_map_str_int32_set(_entity_references, "dollar", 0x24); + nh_map_str_int32_set(_entity_references, "dopf", 0x1d555); + nh_map_str_int32_set(_entity_references, "dot", 0x2d9); + nh_map_str_int32_set(_entity_references, "doteq", 0x2250); + nh_map_str_int32_set(_entity_references, "doteqdot", 0x2251); + nh_map_str_int32_set(_entity_references, "dotminus", 0x2238); + nh_map_str_int32_set(_entity_references, "dotplus", 0x2214); + nh_map_str_int32_set(_entity_references, "dotsquare", 0x22a1); + nh_map_str_int32_set(_entity_references, "doublebarwedge", 0x2306); + nh_map_str_int32_set(_entity_references, "downarrow", 0x2193); + nh_map_str_int32_set(_entity_references, "downdownarrows", 0x21ca); + nh_map_str_int32_set(_entity_references, "downharpoonleft", 0x21c3); + nh_map_str_int32_set(_entity_references, "downharpoonright", 0x21c2); + nh_map_str_int32_set(_entity_references, "drbkarow", 0x2910); + nh_map_str_int32_set(_entity_references, "drcorn", 0x231f); + nh_map_str_int32_set(_entity_references, "drcrop", 0x230c); + nh_map_str_int32_set(_entity_references, "dscr", 0x1d4b9); + nh_map_str_int32_set(_entity_references, "dscy", 0x455); + nh_map_str_int32_set(_entity_references, "dsol", 0x29f6); + nh_map_str_int32_set(_entity_references, "dstrok", 0x111); + nh_map_str_int32_set(_entity_references, "dtdot", 0x22f1); + nh_map_str_int32_set(_entity_references, "dtri", 0x25bf); + nh_map_str_int32_set(_entity_references, "dtrif", 0x25be); + nh_map_str_int32_set(_entity_references, "duarr", 0x21f5); + nh_map_str_int32_set(_entity_references, "duhar", 0x296f); + nh_map_str_int32_set(_entity_references, "dwangle", 0x29a6); + nh_map_str_int32_set(_entity_references, "dzcy", 0x45f); + nh_map_str_int32_set(_entity_references, "dzigrarr", 0x27ff); + nh_map_str_int32_set(_entity_references, "eDDot", 0x2a77); + nh_map_str_int32_set(_entity_references, "eDot", 0x2251); + nh_map_str_int32_set(_entity_references, "eacute", 0xe9); + nh_map_str_int32_set(_entity_references, "easter", 0x2a6e); + nh_map_str_int32_set(_entity_references, "ecaron", 0x11b); + nh_map_str_int32_set(_entity_references, "ecir", 0x2256); + nh_map_str_int32_set(_entity_references, "ecirc", 0xea); + nh_map_str_int32_set(_entity_references, "ecolon", 0x2255); + nh_map_str_int32_set(_entity_references, "ecy", 0x44d); + nh_map_str_int32_set(_entity_references, "edot", 0x117); + nh_map_str_int32_set(_entity_references, "ee", 0x2147); + nh_map_str_int32_set(_entity_references, "efDot", 0x2252); + nh_map_str_int32_set(_entity_references, "efr", 0x1d522); + nh_map_str_int32_set(_entity_references, "eg", 0x2a9a); + nh_map_str_int32_set(_entity_references, "egrave", 0xe8); + nh_map_str_int32_set(_entity_references, "egs", 0x2a96); + nh_map_str_int32_set(_entity_references, "egsdot", 0x2a98); + nh_map_str_int32_set(_entity_references, "el", 0x2a99); + nh_map_str_int32_set(_entity_references, "elinters", 0x23e7); + nh_map_str_int32_set(_entity_references, "ell", 0x2113); + nh_map_str_int32_set(_entity_references, "els", 0x2a95); + nh_map_str_int32_set(_entity_references, "elsdot", 0x2a97); + nh_map_str_int32_set(_entity_references, "emacr", 0x113); + nh_map_str_int32_set(_entity_references, "empty", 0x2205); + nh_map_str_int32_set(_entity_references, "emptyset", 0x2205); + nh_map_str_int32_set(_entity_references, "emptyv", 0x2205); + nh_map_str_int32_set(_entity_references, "emsp", 0x2003); + nh_map_str_int32_set(_entity_references, "emsp13", 0x2004); + nh_map_str_int32_set(_entity_references, "emsp14", 0x2005); + nh_map_str_int32_set(_entity_references, "eng", 0x14b); + nh_map_str_int32_set(_entity_references, "ensp", 0x2002); + nh_map_str_int32_set(_entity_references, "eogon", 0x119); + nh_map_str_int32_set(_entity_references, "eopf", 0x1d556); + nh_map_str_int32_set(_entity_references, "epar", 0x22d5); + nh_map_str_int32_set(_entity_references, "eparsl", 0x29e3); + nh_map_str_int32_set(_entity_references, "eplus", 0x2a71); + nh_map_str_int32_set(_entity_references, "epsi", 0x3f5); + nh_map_str_int32_set(_entity_references, "epsilon", 0x3b5); + nh_map_str_int32_set(_entity_references, "epsiv", 0x3b5); + nh_map_str_int32_set(_entity_references, "eqcirc", 0x2256); + nh_map_str_int32_set(_entity_references, "eqcolon", 0x2255); + nh_map_str_int32_set(_entity_references, "eqsim", 0x2242); + nh_map_str_int32_set(_entity_references, "eqslantgtr", 0x2a96); + nh_map_str_int32_set(_entity_references, "eqslantless", 0x2a95); + nh_map_str_int32_set(_entity_references, "equals", 0x3d); + nh_map_str_int32_set(_entity_references, "equest", 0x225f); + nh_map_str_int32_set(_entity_references, "equiv", 0x2261); + nh_map_str_int32_set(_entity_references, "equivDD", 0x2a78); + nh_map_str_int32_set(_entity_references, "eqvparsl", 0x29e5); + nh_map_str_int32_set(_entity_references, "erDot", 0x2253); + nh_map_str_int32_set(_entity_references, "erarr", 0x2971); + nh_map_str_int32_set(_entity_references, "escr", 0x212f); + nh_map_str_int32_set(_entity_references, "esdot", 0x2250); + nh_map_str_int32_set(_entity_references, "esim", 0x2242); + nh_map_str_int32_set(_entity_references, "eta", 0x3b7); + nh_map_str_int32_set(_entity_references, "eth", 0xf0); + nh_map_str_int32_set(_entity_references, "euml", 0xeb); + nh_map_str_int32_set(_entity_references, "euro", 0x20ac); + nh_map_str_int32_set(_entity_references, "excl", 0x21); + nh_map_str_int32_set(_entity_references, "exist", 0x2203); + nh_map_str_int32_set(_entity_references, "expectation", 0x2130); + nh_map_str_int32_set(_entity_references, "exponentiale", 0x2147); + nh_map_str_int32_set(_entity_references, "fallingdotseq", 0x2252); + nh_map_str_int32_set(_entity_references, "fcy", 0x444); + nh_map_str_int32_set(_entity_references, "female", 0x2640); + nh_map_str_int32_set(_entity_references, "ffilig", 0xfb03); + nh_map_str_int32_set(_entity_references, "fflig", 0xfb00); + nh_map_str_int32_set(_entity_references, "ffllig", 0xfb04); + nh_map_str_int32_set(_entity_references, "ffr", 0x1d523); + nh_map_str_int32_set(_entity_references, "filig", 0xfb01); + nh_map_str_int32_set(_entity_references, "flat", 0x266d); + nh_map_str_int32_set(_entity_references, "fllig", 0xfb02); + nh_map_str_int32_set(_entity_references, "fltns", 0x25b1); + nh_map_str_int32_set(_entity_references, "fnof", 0x192); + nh_map_str_int32_set(_entity_references, "fopf", 0x1d557); + nh_map_str_int32_set(_entity_references, "forall", 0x2200); + nh_map_str_int32_set(_entity_references, "fork", 0x22d4); + nh_map_str_int32_set(_entity_references, "forkv", 0x2ad9); + nh_map_str_int32_set(_entity_references, "fpartint", 0x2a0d); + nh_map_str_int32_set(_entity_references, "frac12", 0xbd); + nh_map_str_int32_set(_entity_references, "frac13", 0x2153); + nh_map_str_int32_set(_entity_references, "frac14", 0xbc); + nh_map_str_int32_set(_entity_references, "frac15", 0x2155); + nh_map_str_int32_set(_entity_references, "frac16", 0x2159); + nh_map_str_int32_set(_entity_references, "frac18", 0x215b); + nh_map_str_int32_set(_entity_references, "frac23", 0x2154); + nh_map_str_int32_set(_entity_references, "frac25", 0x2156); + nh_map_str_int32_set(_entity_references, "frac34", 0xbe); + nh_map_str_int32_set(_entity_references, "frac35", 0x2157); + nh_map_str_int32_set(_entity_references, "frac38", 0x215c); + nh_map_str_int32_set(_entity_references, "frac45", 0x2158); + nh_map_str_int32_set(_entity_references, "frac56", 0x215a); + nh_map_str_int32_set(_entity_references, "frac58", 0x215d); + nh_map_str_int32_set(_entity_references, "frac78", 0x215e); + nh_map_str_int32_set(_entity_references, "frasl", 0x2044); + nh_map_str_int32_set(_entity_references, "frown", 0x2322); + nh_map_str_int32_set(_entity_references, "fscr", 0x1d4bb); + nh_map_str_int32_set(_entity_references, "gE", 0x2267); + nh_map_str_int32_set(_entity_references, "gEl", 0x2a8c); + nh_map_str_int32_set(_entity_references, "gacute", 0x1f5); + nh_map_str_int32_set(_entity_references, "gamma", 0x3b3); + nh_map_str_int32_set(_entity_references, "gammad", 0x3dd); + nh_map_str_int32_set(_entity_references, "gap", 0x2a86); + nh_map_str_int32_set(_entity_references, "gbreve", 0x11f); + nh_map_str_int32_set(_entity_references, "gcirc", 0x11d); + nh_map_str_int32_set(_entity_references, "gcy", 0x433); + nh_map_str_int32_set(_entity_references, "gdot", 0x121); + nh_map_str_int32_set(_entity_references, "ge", 0x2265); + nh_map_str_int32_set(_entity_references, "gel", 0x22db); + nh_map_str_int32_set(_entity_references, "geq", 0x2265); + nh_map_str_int32_set(_entity_references, "geqq", 0x2267); + nh_map_str_int32_set(_entity_references, "geqslant", 0x2a7e); + nh_map_str_int32_set(_entity_references, "ges", 0x2a7e); + nh_map_str_int32_set(_entity_references, "gescc", 0x2aa9); + nh_map_str_int32_set(_entity_references, "gesdot", 0x2a80); + nh_map_str_int32_set(_entity_references, "gesdoto", 0x2a82); + nh_map_str_int32_set(_entity_references, "gesdotol", 0x2a84); + nh_map_str_int32_set(_entity_references, "gesles", 0x2a94); + nh_map_str_int32_set(_entity_references, "gfr", 0x1d524); + nh_map_str_int32_set(_entity_references, "gg", 0x226b); + nh_map_str_int32_set(_entity_references, "ggg", 0x22d9); + nh_map_str_int32_set(_entity_references, "gimel", 0x2137); + nh_map_str_int32_set(_entity_references, "gjcy", 0x453); + nh_map_str_int32_set(_entity_references, "gl", 0x2277); + nh_map_str_int32_set(_entity_references, "glE", 0x2a92); + nh_map_str_int32_set(_entity_references, "gla", 0x2aa5); + nh_map_str_int32_set(_entity_references, "glj", 0x2aa4); + nh_map_str_int32_set(_entity_references, "gnE", 0x2269); + nh_map_str_int32_set(_entity_references, "gnap", 0x2a8a); + nh_map_str_int32_set(_entity_references, "gnapprox", 0x2a8a); + nh_map_str_int32_set(_entity_references, "gne", 0x2a88); + nh_map_str_int32_set(_entity_references, "gneq", 0x2a88); + nh_map_str_int32_set(_entity_references, "gneqq", 0x2269); + nh_map_str_int32_set(_entity_references, "gnsim", 0x22e7); + nh_map_str_int32_set(_entity_references, "gopf", 0x1d558); + nh_map_str_int32_set(_entity_references, "grave", 0x60); + nh_map_str_int32_set(_entity_references, "gscr", 0x210a); + nh_map_str_int32_set(_entity_references, "gsim", 0x2273); + nh_map_str_int32_set(_entity_references, "gsime", 0x2a8e); + nh_map_str_int32_set(_entity_references, "gsiml", 0x2a90); + nh_map_str_int32_set(_entity_references, "gt", 0x3e); + nh_map_str_int32_set(_entity_references, "gtcc", 0x2aa7); + nh_map_str_int32_set(_entity_references, "gtcir", 0x2a7a); + nh_map_str_int32_set(_entity_references, "gtdot", 0x22d7); + nh_map_str_int32_set(_entity_references, "gtlPar", 0x2995); + nh_map_str_int32_set(_entity_references, "gtquest", 0x2a7c); + nh_map_str_int32_set(_entity_references, "gtrapprox", 0x2a86); + nh_map_str_int32_set(_entity_references, "gtrarr", 0x2978); + nh_map_str_int32_set(_entity_references, "gtrdot", 0x22d7); + nh_map_str_int32_set(_entity_references, "gtreqless", 0x22db); + nh_map_str_int32_set(_entity_references, "gtreqqless", 0x2a8c); + nh_map_str_int32_set(_entity_references, "gtrless", 0x2277); + nh_map_str_int32_set(_entity_references, "gtrsim", 0x2273); + nh_map_str_int32_set(_entity_references, "hArr", 0x21d4); + nh_map_str_int32_set(_entity_references, "hairsp", 0x200a); + nh_map_str_int32_set(_entity_references, "half", 0xbd); + nh_map_str_int32_set(_entity_references, "hamilt", 0x210b); + nh_map_str_int32_set(_entity_references, "hardcy", 0x44a); + nh_map_str_int32_set(_entity_references, "harr", 0x2194); + nh_map_str_int32_set(_entity_references, "harrcir", 0x2948); + nh_map_str_int32_set(_entity_references, "harrw", 0x21ad); + nh_map_str_int32_set(_entity_references, "hbar", 0x210f); + nh_map_str_int32_set(_entity_references, "hcirc", 0x125); + nh_map_str_int32_set(_entity_references, "hearts", 0x2665); + nh_map_str_int32_set(_entity_references, "heartsuit", 0x2665); + nh_map_str_int32_set(_entity_references, "hellip", 0x2026); + nh_map_str_int32_set(_entity_references, "hercon", 0x22b9); + nh_map_str_int32_set(_entity_references, "hfr", 0x1d525); + nh_map_str_int32_set(_entity_references, "hksearow", 0x2925); + nh_map_str_int32_set(_entity_references, "hkswarow", 0x2926); + nh_map_str_int32_set(_entity_references, "hoarr", 0x21ff); + nh_map_str_int32_set(_entity_references, "homtht", 0x223b); + nh_map_str_int32_set(_entity_references, "hookleftarrow", 0x21a9); + nh_map_str_int32_set(_entity_references, "hookrightarrow", 0x21aa); + nh_map_str_int32_set(_entity_references, "hopf", 0x1d559); + nh_map_str_int32_set(_entity_references, "horbar", 0x2015); + nh_map_str_int32_set(_entity_references, "hscr", 0x1d4bd); + nh_map_str_int32_set(_entity_references, "hslash", 0x210f); + nh_map_str_int32_set(_entity_references, "hstrok", 0x127); + nh_map_str_int32_set(_entity_references, "hybull", 0x2043); + nh_map_str_int32_set(_entity_references, "hyphen", 0x2010); + nh_map_str_int32_set(_entity_references, "iacute", 0xed); + nh_map_str_int32_set(_entity_references, "ic", 0x2063); + nh_map_str_int32_set(_entity_references, "icirc", 0xee); + nh_map_str_int32_set(_entity_references, "icy", 0x438); + nh_map_str_int32_set(_entity_references, "iecy", 0x435); + nh_map_str_int32_set(_entity_references, "iexcl", 0xa1); + nh_map_str_int32_set(_entity_references, "iff", 0x21d4); + nh_map_str_int32_set(_entity_references, "ifr", 0x1d526); + nh_map_str_int32_set(_entity_references, "igrave", 0xec); + nh_map_str_int32_set(_entity_references, "ii", 0x2148); + nh_map_str_int32_set(_entity_references, "iiiint", 0x2a0c); + nh_map_str_int32_set(_entity_references, "iiint", 0x222d); + nh_map_str_int32_set(_entity_references, "iinfin", 0x29dc); + nh_map_str_int32_set(_entity_references, "iiota", 0x2129); + nh_map_str_int32_set(_entity_references, "ijlig", 0x133); + nh_map_str_int32_set(_entity_references, "imacr", 0x12b); + nh_map_str_int32_set(_entity_references, "image", 0x2111); + nh_map_str_int32_set(_entity_references, "imagline", 0x2110); + nh_map_str_int32_set(_entity_references, "imagpart", 0x2111); + nh_map_str_int32_set(_entity_references, "imath", 0x131); + nh_map_str_int32_set(_entity_references, "imof", 0x22b7); + nh_map_str_int32_set(_entity_references, "imped", 0x1b5); + nh_map_str_int32_set(_entity_references, "in", 0x2208); + nh_map_str_int32_set(_entity_references, "incare", 0x2105); + nh_map_str_int32_set(_entity_references, "infin", 0x221e); + nh_map_str_int32_set(_entity_references, "infintie", 0x29dd); + nh_map_str_int32_set(_entity_references, "inodot", 0x131); + nh_map_str_int32_set(_entity_references, "int", 0x222b); + nh_map_str_int32_set(_entity_references, "intcal", 0x22ba); + nh_map_str_int32_set(_entity_references, "integers", 0x2124); + nh_map_str_int32_set(_entity_references, "intercal", 0x22ba); + nh_map_str_int32_set(_entity_references, "intlarhk", 0x2a17); + nh_map_str_int32_set(_entity_references, "intprod", 0x2a3c); + nh_map_str_int32_set(_entity_references, "iocy", 0x451); + nh_map_str_int32_set(_entity_references, "iogon", 0x12f); + nh_map_str_int32_set(_entity_references, "iopf", 0x1d55a); + nh_map_str_int32_set(_entity_references, "iota", 0x3b9); + nh_map_str_int32_set(_entity_references, "iprod", 0x2a3c); + nh_map_str_int32_set(_entity_references, "iquest", 0xbf); + nh_map_str_int32_set(_entity_references, "iscr", 0x1d4be); + nh_map_str_int32_set(_entity_references, "isin", 0x2208); + nh_map_str_int32_set(_entity_references, "isinE", 0x22f9); + nh_map_str_int32_set(_entity_references, "isindot", 0x22f5); + nh_map_str_int32_set(_entity_references, "isins", 0x22f4); + nh_map_str_int32_set(_entity_references, "isinsv", 0x22f3); + nh_map_str_int32_set(_entity_references, "isinv", 0x2208); + nh_map_str_int32_set(_entity_references, "it", 0x2062); + nh_map_str_int32_set(_entity_references, "itilde", 0x129); + nh_map_str_int32_set(_entity_references, "iukcy", 0x456); + nh_map_str_int32_set(_entity_references, "iuml", 0xef); + nh_map_str_int32_set(_entity_references, "jcirc", 0x135); + nh_map_str_int32_set(_entity_references, "jcy", 0x439); + nh_map_str_int32_set(_entity_references, "jfr", 0x1d527); + nh_map_str_int32_set(_entity_references, "jmath", 0x237); + nh_map_str_int32_set(_entity_references, "jopf", 0x1d55b); + nh_map_str_int32_set(_entity_references, "jscr", 0x1d4bf); + nh_map_str_int32_set(_entity_references, "jsercy", 0x458); + nh_map_str_int32_set(_entity_references, "jukcy", 0x454); + nh_map_str_int32_set(_entity_references, "kappa", 0x3ba); + nh_map_str_int32_set(_entity_references, "kappav", 0x3f0); + nh_map_str_int32_set(_entity_references, "kcedil", 0x137); + nh_map_str_int32_set(_entity_references, "kcy", 0x43a); + nh_map_str_int32_set(_entity_references, "kfr", 0x1d528); + nh_map_str_int32_set(_entity_references, "kgreen", 0x138); + nh_map_str_int32_set(_entity_references, "khcy", 0x445); + nh_map_str_int32_set(_entity_references, "kjcy", 0x45c); + nh_map_str_int32_set(_entity_references, "kopf", 0x1d55c); + nh_map_str_int32_set(_entity_references, "kscr", 0x1d4c0); + nh_map_str_int32_set(_entity_references, "lAarr", 0x21da); + nh_map_str_int32_set(_entity_references, "lArr", 0x21d0); + nh_map_str_int32_set(_entity_references, "lAtail", 0x291b); + nh_map_str_int32_set(_entity_references, "lBarr", 0x290e); + nh_map_str_int32_set(_entity_references, "lE", 0x2266); + nh_map_str_int32_set(_entity_references, "lEg", 0x2a8b); + nh_map_str_int32_set(_entity_references, "lHar", 0x2962); + nh_map_str_int32_set(_entity_references, "lacute", 0x13a); + nh_map_str_int32_set(_entity_references, "laemptyv", 0x29b4); + nh_map_str_int32_set(_entity_references, "lagran", 0x2112); + nh_map_str_int32_set(_entity_references, "lambda", 0x3bb); + nh_map_str_int32_set(_entity_references, "lang", 0x27e8); + nh_map_str_int32_set(_entity_references, "langd", 0x2991); + nh_map_str_int32_set(_entity_references, "langle", 0x27e8); + nh_map_str_int32_set(_entity_references, "lap", 0x2a85); + nh_map_str_int32_set(_entity_references, "laquo", 0xab); + nh_map_str_int32_set(_entity_references, "larr", 0x2190); + nh_map_str_int32_set(_entity_references, "larrb", 0x21e4); + nh_map_str_int32_set(_entity_references, "larrbfs", 0x291f); + nh_map_str_int32_set(_entity_references, "larrfs", 0x291d); + nh_map_str_int32_set(_entity_references, "larrhk", 0x21a9); + nh_map_str_int32_set(_entity_references, "larrlp", 0x21ab); + nh_map_str_int32_set(_entity_references, "larrpl", 0x2939); + nh_map_str_int32_set(_entity_references, "larrsim", 0x2973); + nh_map_str_int32_set(_entity_references, "larrtl", 0x21a2); + nh_map_str_int32_set(_entity_references, "lat", 0x2aab); + nh_map_str_int32_set(_entity_references, "latail", 0x2919); + nh_map_str_int32_set(_entity_references, "late", 0x2aad); + nh_map_str_int32_set(_entity_references, "lbarr", 0x290c); + nh_map_str_int32_set(_entity_references, "lbbrk", 0x2772); + nh_map_str_int32_set(_entity_references, "lbrace", 0x7b); + nh_map_str_int32_set(_entity_references, "lbrack", 0x5b); + nh_map_str_int32_set(_entity_references, "lbrke", 0x298b); + nh_map_str_int32_set(_entity_references, "lbrksld", 0x298f); + nh_map_str_int32_set(_entity_references, "lbrkslu", 0x298d); + nh_map_str_int32_set(_entity_references, "lcaron", 0x13e); + nh_map_str_int32_set(_entity_references, "lcedil", 0x13c); + nh_map_str_int32_set(_entity_references, "lceil", 0x2308); + nh_map_str_int32_set(_entity_references, "lcub", 0x7b); + nh_map_str_int32_set(_entity_references, "lcy", 0x43b); + nh_map_str_int32_set(_entity_references, "ldca", 0x2936); + nh_map_str_int32_set(_entity_references, "ldquo", 0x201c); + nh_map_str_int32_set(_entity_references, "ldquor", 0x201e); + nh_map_str_int32_set(_entity_references, "ldrdhar", 0x2967); + nh_map_str_int32_set(_entity_references, "ldrushar", 0x294b); + nh_map_str_int32_set(_entity_references, "ldsh", 0x21b2); + nh_map_str_int32_set(_entity_references, "le", 0x2264); + nh_map_str_int32_set(_entity_references, "leftarrow", 0x2190); + nh_map_str_int32_set(_entity_references, "leftarrowtail", 0x21a2); + nh_map_str_int32_set(_entity_references, "leftharpoondown", 0x21bd); + nh_map_str_int32_set(_entity_references, "leftharpoonup", 0x21bc); + nh_map_str_int32_set(_entity_references, "leftleftarrows", 0x21c7); + nh_map_str_int32_set(_entity_references, "leftrightarrow", 0x2194); + nh_map_str_int32_set(_entity_references, "leftrightarrows", 0x21c6); + nh_map_str_int32_set(_entity_references, "leftrightharpoons", 0x21cb); + nh_map_str_int32_set(_entity_references, "leftrightsquigarrow", 0x21ad); + nh_map_str_int32_set(_entity_references, "leftthreetimes", 0x22cb); + nh_map_str_int32_set(_entity_references, "leg", 0x22da); + nh_map_str_int32_set(_entity_references, "leq", 0x2264); + nh_map_str_int32_set(_entity_references, "leqq", 0x2266); + nh_map_str_int32_set(_entity_references, "leqslant", 0x2a7d); + nh_map_str_int32_set(_entity_references, "les", 0x2a7d); + nh_map_str_int32_set(_entity_references, "lescc", 0x2aa8); + nh_map_str_int32_set(_entity_references, "lesdot", 0x2a7f); + nh_map_str_int32_set(_entity_references, "lesdoto", 0x2a81); + nh_map_str_int32_set(_entity_references, "lesdotor", 0x2a83); + nh_map_str_int32_set(_entity_references, "lesges", 0x2a93); + nh_map_str_int32_set(_entity_references, "lessapprox", 0x2a85); + nh_map_str_int32_set(_entity_references, "lessdot", 0x22d6); + nh_map_str_int32_set(_entity_references, "lesseqgtr", 0x22da); + nh_map_str_int32_set(_entity_references, "lesseqqgtr", 0x2a8b); + nh_map_str_int32_set(_entity_references, "lessgtr", 0x2276); + nh_map_str_int32_set(_entity_references, "lesssim", 0x2272); + nh_map_str_int32_set(_entity_references, "lfisht", 0x297c); + nh_map_str_int32_set(_entity_references, "lfloor", 0x230a); + nh_map_str_int32_set(_entity_references, "lfr", 0x1d529); + nh_map_str_int32_set(_entity_references, "lg", 0x2276); + nh_map_str_int32_set(_entity_references, "lgE", 0x2a91); + nh_map_str_int32_set(_entity_references, "lhard", 0x21bd); + nh_map_str_int32_set(_entity_references, "lharu", 0x21bc); + nh_map_str_int32_set(_entity_references, "lharul", 0x296a); + nh_map_str_int32_set(_entity_references, "lhblk", 0x2584); + nh_map_str_int32_set(_entity_references, "ljcy", 0x459); + nh_map_str_int32_set(_entity_references, "ll", 0x226a); + nh_map_str_int32_set(_entity_references, "llarr", 0x21c7); + nh_map_str_int32_set(_entity_references, "llcorner", 0x231e); + nh_map_str_int32_set(_entity_references, "llhard", 0x296b); + nh_map_str_int32_set(_entity_references, "lltri", 0x25fa); + nh_map_str_int32_set(_entity_references, "lmidot", 0x140); + nh_map_str_int32_set(_entity_references, "lmoust", 0x23b0); + nh_map_str_int32_set(_entity_references, "lmoustache", 0x23b0); + nh_map_str_int32_set(_entity_references, "lnE", 0x2268); + nh_map_str_int32_set(_entity_references, "lnap", 0x2a89); + nh_map_str_int32_set(_entity_references, "lnapprox", 0x2a89); + nh_map_str_int32_set(_entity_references, "lne", 0x2a87); + nh_map_str_int32_set(_entity_references, "lneq", 0x2a87); + nh_map_str_int32_set(_entity_references, "lneqq", 0x2268); + nh_map_str_int32_set(_entity_references, "lnsim", 0x22e6); + nh_map_str_int32_set(_entity_references, "loang", 0x27ec); + nh_map_str_int32_set(_entity_references, "loarr", 0x21fd); + nh_map_str_int32_set(_entity_references, "lobrk", 0x27e6); + nh_map_str_int32_set(_entity_references, "longleftarrow", 0x27f5); + nh_map_str_int32_set(_entity_references, "longleftrightarrow", 0x27f7); + nh_map_str_int32_set(_entity_references, "longmapsto", 0x27fc); + nh_map_str_int32_set(_entity_references, "longrightarrow", 0x27f6); + nh_map_str_int32_set(_entity_references, "looparrowleft", 0x21ab); + nh_map_str_int32_set(_entity_references, "looparrowright", 0x21ac); + nh_map_str_int32_set(_entity_references, "lopar", 0x2985); + nh_map_str_int32_set(_entity_references, "lopf", 0x1d55d); + nh_map_str_int32_set(_entity_references, "loplus", 0x2a2d); + nh_map_str_int32_set(_entity_references, "lotimes", 0x2a34); + nh_map_str_int32_set(_entity_references, "lowast", 0x2217); + nh_map_str_int32_set(_entity_references, "lowbar", 0x5f); + nh_map_str_int32_set(_entity_references, "loz", 0x25ca); + nh_map_str_int32_set(_entity_references, "lozenge", 0x25ca); + nh_map_str_int32_set(_entity_references, "lozf", 0x29eb); + nh_map_str_int32_set(_entity_references, "lpar", 0x28); + nh_map_str_int32_set(_entity_references, "lparlt", 0x2993); + nh_map_str_int32_set(_entity_references, "lrarr", 0x21c6); + nh_map_str_int32_set(_entity_references, "lrcorner", 0x231f); + nh_map_str_int32_set(_entity_references, "lrhar", 0x21cb); + nh_map_str_int32_set(_entity_references, "lrhard", 0x296d); + nh_map_str_int32_set(_entity_references, "lrm", 0x200e); + nh_map_str_int32_set(_entity_references, "lrtri", 0x22bf); + nh_map_str_int32_set(_entity_references, "lsaquo", 0x2039); + nh_map_str_int32_set(_entity_references, "lscr", 0x1d4c1); + nh_map_str_int32_set(_entity_references, "lsh", 0x21b0); + nh_map_str_int32_set(_entity_references, "lsim", 0x2272); + nh_map_str_int32_set(_entity_references, "lsime", 0x2a8d); + nh_map_str_int32_set(_entity_references, "lsimg", 0x2a8f); + nh_map_str_int32_set(_entity_references, "lsqb", 0x5b); + nh_map_str_int32_set(_entity_references, "lsquo", 0x2018); + nh_map_str_int32_set(_entity_references, "lsquor", 0x201a); + nh_map_str_int32_set(_entity_references, "lstrok", 0x142); + nh_map_str_int32_set(_entity_references, "lt", 0x3c); + nh_map_str_int32_set(_entity_references, "ltcc", 0x2aa6); + nh_map_str_int32_set(_entity_references, "ltcir", 0x2a79); + nh_map_str_int32_set(_entity_references, "ltdot", 0x22d6); + nh_map_str_int32_set(_entity_references, "lthree", 0x22cb); + nh_map_str_int32_set(_entity_references, "ltimes", 0x22c9); + nh_map_str_int32_set(_entity_references, "ltlarr", 0x2976); + nh_map_str_int32_set(_entity_references, "ltquest", 0x2a7b); + nh_map_str_int32_set(_entity_references, "ltrPar", 0x2996); + nh_map_str_int32_set(_entity_references, "ltri", 0x25c3); + nh_map_str_int32_set(_entity_references, "ltrie", 0x22b4); + nh_map_str_int32_set(_entity_references, "ltrif", 0x25c2); + nh_map_str_int32_set(_entity_references, "lurdshar", 0x294a); + nh_map_str_int32_set(_entity_references, "luruhar", 0x2966); + nh_map_str_int32_set(_entity_references, "mDDot", 0x223a); + nh_map_str_int32_set(_entity_references, "macr", 0xaf); + nh_map_str_int32_set(_entity_references, "male", 0x2642); + nh_map_str_int32_set(_entity_references, "malt", 0x2720); + nh_map_str_int32_set(_entity_references, "maltese", 0x2720); + nh_map_str_int32_set(_entity_references, "map", 0x21a6); + nh_map_str_int32_set(_entity_references, "mapsto", 0x21a6); + nh_map_str_int32_set(_entity_references, "mapstodown", 0x21a7); + nh_map_str_int32_set(_entity_references, "mapstoleft", 0x21a4); + nh_map_str_int32_set(_entity_references, "mapstoup", 0x21a5); + nh_map_str_int32_set(_entity_references, "marker", 0x25ae); + nh_map_str_int32_set(_entity_references, "mcomma", 0x2a29); + nh_map_str_int32_set(_entity_references, "mcy", 0x43c); + nh_map_str_int32_set(_entity_references, "mdash", 0x2014); + nh_map_str_int32_set(_entity_references, "measuredangle", 0x2221); + nh_map_str_int32_set(_entity_references, "mfr", 0x1d52a); + nh_map_str_int32_set(_entity_references, "mho", 0x2127); + nh_map_str_int32_set(_entity_references, "micro", 0xb5); + nh_map_str_int32_set(_entity_references, "mid", 0x2223); + nh_map_str_int32_set(_entity_references, "midast", 0x2a); + nh_map_str_int32_set(_entity_references, "midcir", 0x2af0); + nh_map_str_int32_set(_entity_references, "middot", 0xb7); + nh_map_str_int32_set(_entity_references, "minus", 0x2212); + nh_map_str_int32_set(_entity_references, "minusb", 0x229f); + nh_map_str_int32_set(_entity_references, "minusd", 0x2238); + nh_map_str_int32_set(_entity_references, "minusdu", 0x2a2a); + nh_map_str_int32_set(_entity_references, "mlcp", 0x2adb); + nh_map_str_int32_set(_entity_references, "mldr", 0x2026); + nh_map_str_int32_set(_entity_references, "mnplus", 0x2213); + nh_map_str_int32_set(_entity_references, "models", 0x22a7); + nh_map_str_int32_set(_entity_references, "mopf", 0x1d55e); + nh_map_str_int32_set(_entity_references, "mp", 0x2213); + nh_map_str_int32_set(_entity_references, "mscr", 0x1d4c2); + nh_map_str_int32_set(_entity_references, "mstpos", 0x223e); + nh_map_str_int32_set(_entity_references, "mu", 0x3bc); + nh_map_str_int32_set(_entity_references, "multimap", 0x22b8); + nh_map_str_int32_set(_entity_references, "mumap", 0x22b8); + nh_map_str_int32_set(_entity_references, "nLeftarrow", 0x21cd); + nh_map_str_int32_set(_entity_references, "nLeftrightarrow", 0x21ce); + nh_map_str_int32_set(_entity_references, "nRightarrow", 0x21cf); + nh_map_str_int32_set(_entity_references, "nVDash", 0x22af); + nh_map_str_int32_set(_entity_references, "nVdash", 0x22ae); + nh_map_str_int32_set(_entity_references, "nabla", 0x2207); + nh_map_str_int32_set(_entity_references, "nacute", 0x144); + nh_map_str_int32_set(_entity_references, "nap", 0x2249); + nh_map_str_int32_set(_entity_references, "napos", 0x149); + nh_map_str_int32_set(_entity_references, "napprox", 0x2249); + nh_map_str_int32_set(_entity_references, "natur", 0x266e); + nh_map_str_int32_set(_entity_references, "natural", 0x266e); + nh_map_str_int32_set(_entity_references, "naturals", 0x2115); + nh_map_str_int32_set(_entity_references, "nbsp", 0xa0); + nh_map_str_int32_set(_entity_references, "ncap", 0x2a43); + nh_map_str_int32_set(_entity_references, "ncaron", 0x148); + nh_map_str_int32_set(_entity_references, "ncedil", 0x146); + nh_map_str_int32_set(_entity_references, "ncong", 0x2247); + nh_map_str_int32_set(_entity_references, "ncup", 0x2a42); + nh_map_str_int32_set(_entity_references, "ncy", 0x43d); + nh_map_str_int32_set(_entity_references, "ndash", 0x2013); + nh_map_str_int32_set(_entity_references, "ne", 0x2260); + nh_map_str_int32_set(_entity_references, "neArr", 0x21d7); + nh_map_str_int32_set(_entity_references, "nearhk", 0x2924); + nh_map_str_int32_set(_entity_references, "nearr", 0x2197); + nh_map_str_int32_set(_entity_references, "nearrow", 0x2197); + nh_map_str_int32_set(_entity_references, "nequiv", 0x2262); + nh_map_str_int32_set(_entity_references, "nesear", 0x2928); + nh_map_str_int32_set(_entity_references, "nexist", 0x2204); + nh_map_str_int32_set(_entity_references, "nexists", 0x2204); + nh_map_str_int32_set(_entity_references, "nfr", 0x1d52b); + nh_map_str_int32_set(_entity_references, "nge", 0x2271); + nh_map_str_int32_set(_entity_references, "ngeq", 0x2271); + nh_map_str_int32_set(_entity_references, "ngsim", 0x2275); + nh_map_str_int32_set(_entity_references, "ngt", 0x226f); + nh_map_str_int32_set(_entity_references, "ngtr", 0x226f); + nh_map_str_int32_set(_entity_references, "nhArr", 0x21ce); + nh_map_str_int32_set(_entity_references, "nharr", 0x21ae); + nh_map_str_int32_set(_entity_references, "nhpar", 0x2af2); + nh_map_str_int32_set(_entity_references, "ni", 0x220b); + nh_map_str_int32_set(_entity_references, "nis", 0x22fc); + nh_map_str_int32_set(_entity_references, "nisd", 0x22fa); + nh_map_str_int32_set(_entity_references, "niv", 0x220b); + nh_map_str_int32_set(_entity_references, "njcy", 0x45a); + nh_map_str_int32_set(_entity_references, "nlArr", 0x21cd); + nh_map_str_int32_set(_entity_references, "nlarr", 0x219a); + nh_map_str_int32_set(_entity_references, "nldr", 0x2025); + nh_map_str_int32_set(_entity_references, "nle", 0x2270); + nh_map_str_int32_set(_entity_references, "nleftarrow", 0x219a); + nh_map_str_int32_set(_entity_references, "nleftrightarrow", 0x21ae); + nh_map_str_int32_set(_entity_references, "nleq", 0x2270); + nh_map_str_int32_set(_entity_references, "nless", 0x226e); + nh_map_str_int32_set(_entity_references, "nlsim", 0x2274); + nh_map_str_int32_set(_entity_references, "nlt", 0x226e); + nh_map_str_int32_set(_entity_references, "nltri", 0x22ea); + nh_map_str_int32_set(_entity_references, "nltrie", 0x22ec); + nh_map_str_int32_set(_entity_references, "nmid", 0x2224); + nh_map_str_int32_set(_entity_references, "nopf", 0x1d55f); + nh_map_str_int32_set(_entity_references, "not", 0xac); + nh_map_str_int32_set(_entity_references, "notin", 0x2209); + nh_map_str_int32_set(_entity_references, "notinva", 0x2209); + nh_map_str_int32_set(_entity_references, "notinvb", 0x22f7); + nh_map_str_int32_set(_entity_references, "notinvc", 0x22f6); + nh_map_str_int32_set(_entity_references, "notni", 0x220c); + nh_map_str_int32_set(_entity_references, "notniva", 0x220c); + nh_map_str_int32_set(_entity_references, "notnivb", 0x22fe); + nh_map_str_int32_set(_entity_references, "notnivc", 0x22fd); + nh_map_str_int32_set(_entity_references, "npar", 0x2226); + nh_map_str_int32_set(_entity_references, "nparallel", 0x2226); + nh_map_str_int32_set(_entity_references, "npolint", 0x2a14); + nh_map_str_int32_set(_entity_references, "npr", 0x2280); + nh_map_str_int32_set(_entity_references, "nprcue", 0x22e0); + nh_map_str_int32_set(_entity_references, "nprec", 0x2280); + nh_map_str_int32_set(_entity_references, "nrArr", 0x21cf); + nh_map_str_int32_set(_entity_references, "nrarr", 0x219b); + nh_map_str_int32_set(_entity_references, "nrightarrow", 0x219b); + nh_map_str_int32_set(_entity_references, "nrtri", 0x22eb); + nh_map_str_int32_set(_entity_references, "nrtrie", 0x22ed); + nh_map_str_int32_set(_entity_references, "nsc", 0x2281); + nh_map_str_int32_set(_entity_references, "nsccue", 0x22e1); + nh_map_str_int32_set(_entity_references, "nscr", 0x1d4c3); + nh_map_str_int32_set(_entity_references, "nshortmid", 0x2224); + nh_map_str_int32_set(_entity_references, "nshortparallel", 0x2226); + nh_map_str_int32_set(_entity_references, "nsim", 0x2241); + nh_map_str_int32_set(_entity_references, "nsime", 0x2244); + nh_map_str_int32_set(_entity_references, "nsimeq", 0x2244); + nh_map_str_int32_set(_entity_references, "nsmid", 0x2224); + nh_map_str_int32_set(_entity_references, "nspar", 0x2226); + nh_map_str_int32_set(_entity_references, "nsqsube", 0x22e2); + nh_map_str_int32_set(_entity_references, "nsqsupe", 0x22e3); + nh_map_str_int32_set(_entity_references, "nsub", 0x2284); + nh_map_str_int32_set(_entity_references, "nsube", 0x2288); + nh_map_str_int32_set(_entity_references, "nsubseteq", 0x2288); + nh_map_str_int32_set(_entity_references, "nsucc", 0x2281); + nh_map_str_int32_set(_entity_references, "nsup", 0x2285); + nh_map_str_int32_set(_entity_references, "nsupe", 0x2289); + nh_map_str_int32_set(_entity_references, "nsupseteq", 0x2289); + nh_map_str_int32_set(_entity_references, "ntgl", 0x2279); + nh_map_str_int32_set(_entity_references, "ntilde", 0xf1); + nh_map_str_int32_set(_entity_references, "ntlg", 0x2278); + nh_map_str_int32_set(_entity_references, "ntriangleleft", 0x22ea); + nh_map_str_int32_set(_entity_references, "ntrianglelefteq", 0x22ec); + nh_map_str_int32_set(_entity_references, "ntriangleright", 0x22eb); + nh_map_str_int32_set(_entity_references, "ntrianglerighteq", 0x22ed); + nh_map_str_int32_set(_entity_references, "nu", 0x3bd); + nh_map_str_int32_set(_entity_references, "num", 0x23); + nh_map_str_int32_set(_entity_references, "numero", 0x2116); + nh_map_str_int32_set(_entity_references, "numsp", 0x2007); + nh_map_str_int32_set(_entity_references, "nvDash", 0x22ad); + nh_map_str_int32_set(_entity_references, "nvHarr", 0x2904); + nh_map_str_int32_set(_entity_references, "nvdash", 0x22ac); + nh_map_str_int32_set(_entity_references, "nvinfin", 0x29de); + nh_map_str_int32_set(_entity_references, "nvlArr", 0x2902); + nh_map_str_int32_set(_entity_references, "nvrArr", 0x2903); + nh_map_str_int32_set(_entity_references, "nwArr", 0x21d6); + nh_map_str_int32_set(_entity_references, "nwarhk", 0x2923); + nh_map_str_int32_set(_entity_references, "nwarr", 0x2196); + nh_map_str_int32_set(_entity_references, "nwarrow", 0x2196); + nh_map_str_int32_set(_entity_references, "nwnear", 0x2927); + nh_map_str_int32_set(_entity_references, "oS", 0x24c8); + nh_map_str_int32_set(_entity_references, "oacute", 0xf3); + nh_map_str_int32_set(_entity_references, "oast", 0x229b); + nh_map_str_int32_set(_entity_references, "ocir", 0x229a); + nh_map_str_int32_set(_entity_references, "ocirc", 0xf4); + nh_map_str_int32_set(_entity_references, "ocy", 0x43e); + nh_map_str_int32_set(_entity_references, "odash", 0x229d); + nh_map_str_int32_set(_entity_references, "odblac", 0x151); + nh_map_str_int32_set(_entity_references, "odiv", 0x2a38); + nh_map_str_int32_set(_entity_references, "odot", 0x2299); + nh_map_str_int32_set(_entity_references, "odsold", 0x29bc); + nh_map_str_int32_set(_entity_references, "oelig", 0x153); + nh_map_str_int32_set(_entity_references, "ofcir", 0x29bf); + nh_map_str_int32_set(_entity_references, "ofr", 0x1d52c); + nh_map_str_int32_set(_entity_references, "ogon", 0x2db); + nh_map_str_int32_set(_entity_references, "ograve", 0xf2); + nh_map_str_int32_set(_entity_references, "ogt", 0x29c1); + nh_map_str_int32_set(_entity_references, "ohbar", 0x29b5); + nh_map_str_int32_set(_entity_references, "ohm", 0x2126); + nh_map_str_int32_set(_entity_references, "oint", 0x222e); + nh_map_str_int32_set(_entity_references, "olarr", 0x21ba); + nh_map_str_int32_set(_entity_references, "olcir", 0x29be); + nh_map_str_int32_set(_entity_references, "olcross", 0x29bb); + nh_map_str_int32_set(_entity_references, "oline", 0x203e); + nh_map_str_int32_set(_entity_references, "olt", 0x29c0); + nh_map_str_int32_set(_entity_references, "omacr", 0x14d); + nh_map_str_int32_set(_entity_references, "omega", 0x3c9); + nh_map_str_int32_set(_entity_references, "omicron", 0x3bf); + nh_map_str_int32_set(_entity_references, "omid", 0x29b6); + nh_map_str_int32_set(_entity_references, "ominus", 0x2296); + nh_map_str_int32_set(_entity_references, "oopf", 0x1d560); + nh_map_str_int32_set(_entity_references, "opar", 0x29b7); + nh_map_str_int32_set(_entity_references, "operp", 0x29b9); + nh_map_str_int32_set(_entity_references, "oplus", 0x2295); + nh_map_str_int32_set(_entity_references, "or", 0x2228); + nh_map_str_int32_set(_entity_references, "orarr", 0x21bb); + nh_map_str_int32_set(_entity_references, "ord", 0x2a5d); + nh_map_str_int32_set(_entity_references, "order", 0x2134); + nh_map_str_int32_set(_entity_references, "orderof", 0x2134); + nh_map_str_int32_set(_entity_references, "ordf", 0xaa); + nh_map_str_int32_set(_entity_references, "ordm", 0xba); + nh_map_str_int32_set(_entity_references, "origof", 0x22b6); + nh_map_str_int32_set(_entity_references, "oror", 0x2a56); + nh_map_str_int32_set(_entity_references, "orslope", 0x2a57); + nh_map_str_int32_set(_entity_references, "orv", 0x2a5b); + nh_map_str_int32_set(_entity_references, "oscr", 0x2134); + nh_map_str_int32_set(_entity_references, "oslash", 0xf8); + nh_map_str_int32_set(_entity_references, "osol", 0x2298); + nh_map_str_int32_set(_entity_references, "otilde", 0xf5); + nh_map_str_int32_set(_entity_references, "otimes", 0x2297); + nh_map_str_int32_set(_entity_references, "otimesas", 0x2a36); + nh_map_str_int32_set(_entity_references, "ouml", 0xf6); + nh_map_str_int32_set(_entity_references, "ovbar", 0x233d); + nh_map_str_int32_set(_entity_references, "par", 0x2225); + nh_map_str_int32_set(_entity_references, "para", 0xb6); + nh_map_str_int32_set(_entity_references, "parallel", 0x2225); + nh_map_str_int32_set(_entity_references, "parsim", 0x2af3); + nh_map_str_int32_set(_entity_references, "parsl", 0x2afd); + nh_map_str_int32_set(_entity_references, "part", 0x2202); + nh_map_str_int32_set(_entity_references, "pcy", 0x43f); + nh_map_str_int32_set(_entity_references, "percnt", 0x25); + nh_map_str_int32_set(_entity_references, "period", 0x2e); + nh_map_str_int32_set(_entity_references, "permil", 0x2030); + nh_map_str_int32_set(_entity_references, "perp", 0x22a5); + nh_map_str_int32_set(_entity_references, "pertenk", 0x2031); + nh_map_str_int32_set(_entity_references, "pfr", 0x1d52d); + nh_map_str_int32_set(_entity_references, "phi", 0x3c6); + nh_map_str_int32_set(_entity_references, "phiv", 0x3c6); + nh_map_str_int32_set(_entity_references, "phmmat", 0x2133); + nh_map_str_int32_set(_entity_references, "phone", 0x260e); + nh_map_str_int32_set(_entity_references, "pi", 0x3c0); + nh_map_str_int32_set(_entity_references, "pitchfork", 0x22d4); + nh_map_str_int32_set(_entity_references, "piv", 0x3d6); + nh_map_str_int32_set(_entity_references, "planck", 0x210f); + nh_map_str_int32_set(_entity_references, "planckh", 0x210e); + nh_map_str_int32_set(_entity_references, "plankv", 0x210f); + nh_map_str_int32_set(_entity_references, "plus", 0x2b); + nh_map_str_int32_set(_entity_references, "plusacir", 0x2a23); + nh_map_str_int32_set(_entity_references, "plusb", 0x229e); + nh_map_str_int32_set(_entity_references, "pluscir", 0x2a22); + nh_map_str_int32_set(_entity_references, "plusdo", 0x2214); + nh_map_str_int32_set(_entity_references, "plusdu", 0x2a25); + nh_map_str_int32_set(_entity_references, "pluse", 0x2a72); + nh_map_str_int32_set(_entity_references, "plusmn", 0xb1); + nh_map_str_int32_set(_entity_references, "plussim", 0x2a26); + nh_map_str_int32_set(_entity_references, "plustwo", 0x2a27); + nh_map_str_int32_set(_entity_references, "pm", 0xb1); + nh_map_str_int32_set(_entity_references, "pointint", 0x2a15); + nh_map_str_int32_set(_entity_references, "popf", 0x1d561); + nh_map_str_int32_set(_entity_references, "pound", 0xa3); + nh_map_str_int32_set(_entity_references, "pr", 0x227a); + nh_map_str_int32_set(_entity_references, "prE", 0x2ab3); + nh_map_str_int32_set(_entity_references, "prap", 0x2ab7); + nh_map_str_int32_set(_entity_references, "prcue", 0x227c); + nh_map_str_int32_set(_entity_references, "pre", 0x2aaf); + nh_map_str_int32_set(_entity_references, "prec", 0x227a); + nh_map_str_int32_set(_entity_references, "precapprox", 0x2ab7); + nh_map_str_int32_set(_entity_references, "preccurlyeq", 0x227c); + nh_map_str_int32_set(_entity_references, "preceq", 0x2aaf); + nh_map_str_int32_set(_entity_references, "precnapprox", 0x2ab9); + nh_map_str_int32_set(_entity_references, "precneqq", 0x2ab5); + nh_map_str_int32_set(_entity_references, "precnsim", 0x22e8); + nh_map_str_int32_set(_entity_references, "precsim", 0x227e); + nh_map_str_int32_set(_entity_references, "prime", 0x2032); + nh_map_str_int32_set(_entity_references, "primes", 0x2119); + nh_map_str_int32_set(_entity_references, "prnE", 0x2ab5); + nh_map_str_int32_set(_entity_references, "prnap", 0x2ab9); + nh_map_str_int32_set(_entity_references, "prnsim", 0x22e8); + nh_map_str_int32_set(_entity_references, "prod", 0x220f); + nh_map_str_int32_set(_entity_references, "profalar", 0x232e); + nh_map_str_int32_set(_entity_references, "profline", 0x2312); + nh_map_str_int32_set(_entity_references, "profsurf", 0x2313); + nh_map_str_int32_set(_entity_references, "prop", 0x221d); + nh_map_str_int32_set(_entity_references, "propto", 0x221d); + nh_map_str_int32_set(_entity_references, "prsim", 0x227e); + nh_map_str_int32_set(_entity_references, "prurel", 0x22b0); + nh_map_str_int32_set(_entity_references, "pscr", 0x1d4c5); + nh_map_str_int32_set(_entity_references, "psi", 0x3c8); + nh_map_str_int32_set(_entity_references, "puncsp", 0x2008); + nh_map_str_int32_set(_entity_references, "qfr", 0x1d52e); + nh_map_str_int32_set(_entity_references, "qint", 0x2a0c); + nh_map_str_int32_set(_entity_references, "qopf", 0x1d562); + nh_map_str_int32_set(_entity_references, "qprime", 0x2057); + nh_map_str_int32_set(_entity_references, "qscr", 0x1d4c6); + nh_map_str_int32_set(_entity_references, "quaternions", 0x210d); + nh_map_str_int32_set(_entity_references, "quatint", 0x2a16); + nh_map_str_int32_set(_entity_references, "quest", 0x3f); + nh_map_str_int32_set(_entity_references, "questeq", 0x225f); + nh_map_str_int32_set(_entity_references, "quot", 0x22); + nh_map_str_int32_set(_entity_references, "rAarr", 0x21db); + nh_map_str_int32_set(_entity_references, "rArr", 0x21d2); + nh_map_str_int32_set(_entity_references, "rAtail", 0x291c); + nh_map_str_int32_set(_entity_references, "rBarr", 0x290f); + nh_map_str_int32_set(_entity_references, "rHar", 0x2964); + nh_map_str_int32_set(_entity_references, "race", 0x29da); + nh_map_str_int32_set(_entity_references, "racute", 0x155); + nh_map_str_int32_set(_entity_references, "radic", 0x221a); + nh_map_str_int32_set(_entity_references, "raemptyv", 0x29b3); + nh_map_str_int32_set(_entity_references, "rang", 0x27e9); + nh_map_str_int32_set(_entity_references, "rangd", 0x2992); + nh_map_str_int32_set(_entity_references, "range", 0x29a5); + nh_map_str_int32_set(_entity_references, "rangle", 0x27e9); + nh_map_str_int32_set(_entity_references, "raquo", 0xbb); + nh_map_str_int32_set(_entity_references, "rarr", 0x2192); + nh_map_str_int32_set(_entity_references, "rarrap", 0x2975); + nh_map_str_int32_set(_entity_references, "rarrb", 0x21e5); + nh_map_str_int32_set(_entity_references, "rarrbfs", 0x2920); + nh_map_str_int32_set(_entity_references, "rarrc", 0x2933); + nh_map_str_int32_set(_entity_references, "rarrfs", 0x291e); + nh_map_str_int32_set(_entity_references, "rarrhk", 0x21aa); + nh_map_str_int32_set(_entity_references, "rarrlp", 0x21ac); + nh_map_str_int32_set(_entity_references, "rarrpl", 0x2945); + nh_map_str_int32_set(_entity_references, "rarrsim", 0x2974); + nh_map_str_int32_set(_entity_references, "rarrtl", 0x21a3); + nh_map_str_int32_set(_entity_references, "rarrw", 0x219d); + nh_map_str_int32_set(_entity_references, "ratail", 0x291a); + nh_map_str_int32_set(_entity_references, "ratio", 0x2236); + nh_map_str_int32_set(_entity_references, "rationals", 0x211a); + nh_map_str_int32_set(_entity_references, "rbarr", 0x290d); + nh_map_str_int32_set(_entity_references, "rbbrk", 0x2773); + nh_map_str_int32_set(_entity_references, "rbrace", 0x7d); + nh_map_str_int32_set(_entity_references, "rbrack", 0x5d); + nh_map_str_int32_set(_entity_references, "rbrke", 0x298c); + nh_map_str_int32_set(_entity_references, "rbrksld", 0x298e); + nh_map_str_int32_set(_entity_references, "rbrkslu", 0x2990); + nh_map_str_int32_set(_entity_references, "rcaron", 0x159); + nh_map_str_int32_set(_entity_references, "rcedil", 0x157); + nh_map_str_int32_set(_entity_references, "rceil", 0x2309); + nh_map_str_int32_set(_entity_references, "rcub", 0x7d); + nh_map_str_int32_set(_entity_references, "rcy", 0x440); + nh_map_str_int32_set(_entity_references, "rdca", 0x2937); + nh_map_str_int32_set(_entity_references, "rdldhar", 0x2969); + nh_map_str_int32_set(_entity_references, "rdquo", 0x201d); + nh_map_str_int32_set(_entity_references, "rdquor", 0x201d); + nh_map_str_int32_set(_entity_references, "rdsh", 0x21b3); + nh_map_str_int32_set(_entity_references, "real", 0x211c); + nh_map_str_int32_set(_entity_references, "realine", 0x211b); + nh_map_str_int32_set(_entity_references, "realpart", 0x211c); + nh_map_str_int32_set(_entity_references, "reals", 0x211d); + nh_map_str_int32_set(_entity_references, "rect", 0x25ad); + nh_map_str_int32_set(_entity_references, "reg", 0xae); + nh_map_str_int32_set(_entity_references, "rfisht", 0x297d); + nh_map_str_int32_set(_entity_references, "rfloor", 0x230b); + nh_map_str_int32_set(_entity_references, "rfr", 0x1d52f); + nh_map_str_int32_set(_entity_references, "rhard", 0x21c1); + nh_map_str_int32_set(_entity_references, "rharu", 0x21c0); + nh_map_str_int32_set(_entity_references, "rharul", 0x296c); + nh_map_str_int32_set(_entity_references, "rho", 0x3c1); + nh_map_str_int32_set(_entity_references, "rhov", 0x3f1); + nh_map_str_int32_set(_entity_references, "rightarrow", 0x2192); + nh_map_str_int32_set(_entity_references, "rightarrowtail", 0x21a3); + nh_map_str_int32_set(_entity_references, "rightharpoondown", 0x21c1); + nh_map_str_int32_set(_entity_references, "rightharpoonup", 0x21c0); + nh_map_str_int32_set(_entity_references, "rightleftarrows", 0x21c4); + nh_map_str_int32_set(_entity_references, "rightleftharpoons", 0x21cc); + nh_map_str_int32_set(_entity_references, "rightrightarrows", 0x21c9); + nh_map_str_int32_set(_entity_references, "rightsquigarrow", 0x219d); + nh_map_str_int32_set(_entity_references, "rightthreetimes", 0x22cc); + nh_map_str_int32_set(_entity_references, "ring", 0x2da); + nh_map_str_int32_set(_entity_references, "risingdotseq", 0x2253); + nh_map_str_int32_set(_entity_references, "rlarr", 0x21c4); + nh_map_str_int32_set(_entity_references, "rlhar", 0x21cc); + nh_map_str_int32_set(_entity_references, "rlm", 0x200f); + nh_map_str_int32_set(_entity_references, "rmoust", 0x23b1); + nh_map_str_int32_set(_entity_references, "rmoustache", 0x23b1); + nh_map_str_int32_set(_entity_references, "rnmid", 0x2aee); + nh_map_str_int32_set(_entity_references, "roang", 0x27ed); + nh_map_str_int32_set(_entity_references, "roarr", 0x21fe); + nh_map_str_int32_set(_entity_references, "robrk", 0x27e7); + nh_map_str_int32_set(_entity_references, "ropar", 0x2986); + nh_map_str_int32_set(_entity_references, "ropf", 0x1d563); + nh_map_str_int32_set(_entity_references, "roplus", 0x2a2e); + nh_map_str_int32_set(_entity_references, "rotimes", 0x2a35); + nh_map_str_int32_set(_entity_references, "rpar", 0x29); + nh_map_str_int32_set(_entity_references, "rpargt", 0x2994); + nh_map_str_int32_set(_entity_references, "rppolint", 0x2a12); + nh_map_str_int32_set(_entity_references, "rrarr", 0x21c9); + nh_map_str_int32_set(_entity_references, "rsaquo", 0x203a); + nh_map_str_int32_set(_entity_references, "rscr", 0x1d4c7); + nh_map_str_int32_set(_entity_references, "rsh", 0x21b1); + nh_map_str_int32_set(_entity_references, "rsqb", 0x5d); + nh_map_str_int32_set(_entity_references, "rsquo", 0x2019); + nh_map_str_int32_set(_entity_references, "rsquor", 0x2019); + nh_map_str_int32_set(_entity_references, "rthree", 0x22cc); + nh_map_str_int32_set(_entity_references, "rtimes", 0x22ca); + nh_map_str_int32_set(_entity_references, "rtri", 0x25b9); + nh_map_str_int32_set(_entity_references, "rtrie", 0x22b5); + nh_map_str_int32_set(_entity_references, "rtrif", 0x25b8); + nh_map_str_int32_set(_entity_references, "rtriltri", 0x29ce); + nh_map_str_int32_set(_entity_references, "ruluhar", 0x2968); + nh_map_str_int32_set(_entity_references, "rx", 0x211e); + nh_map_str_int32_set(_entity_references, "sacute", 0x15b); + nh_map_str_int32_set(_entity_references, "sbquo", 0x201a); + nh_map_str_int32_set(_entity_references, "sc", 0x227b); + nh_map_str_int32_set(_entity_references, "scE", 0x2ab4); + nh_map_str_int32_set(_entity_references, "scap", 0x2ab8); + nh_map_str_int32_set(_entity_references, "scaron", 0x161); + nh_map_str_int32_set(_entity_references, "sccue", 0x227d); + nh_map_str_int32_set(_entity_references, "sce", 0x2ab0); + nh_map_str_int32_set(_entity_references, "scedil", 0x15f); + nh_map_str_int32_set(_entity_references, "scirc", 0x15d); + nh_map_str_int32_set(_entity_references, "scnE", 0x2ab6); + nh_map_str_int32_set(_entity_references, "scnap", 0x2aba); + nh_map_str_int32_set(_entity_references, "scnsim", 0x22e9); + nh_map_str_int32_set(_entity_references, "scpolint", 0x2a13); + nh_map_str_int32_set(_entity_references, "scsim", 0x227f); + nh_map_str_int32_set(_entity_references, "scy", 0x441); + nh_map_str_int32_set(_entity_references, "sdot", 0x22c5); + nh_map_str_int32_set(_entity_references, "sdotb", 0x22a1); + nh_map_str_int32_set(_entity_references, "sdote", 0x2a66); + nh_map_str_int32_set(_entity_references, "seArr", 0x21d8); + nh_map_str_int32_set(_entity_references, "searhk", 0x2925); + nh_map_str_int32_set(_entity_references, "searr", 0x2198); + nh_map_str_int32_set(_entity_references, "searrow", 0x2198); + nh_map_str_int32_set(_entity_references, "sect", 0xa7); + nh_map_str_int32_set(_entity_references, "semi", 0x3b); + nh_map_str_int32_set(_entity_references, "seswar", 0x2929); + nh_map_str_int32_set(_entity_references, "setminus", 0x2216); + nh_map_str_int32_set(_entity_references, "setmn", 0x2216); + nh_map_str_int32_set(_entity_references, "sext", 0x2736); + nh_map_str_int32_set(_entity_references, "sfr", 0x1d530); + nh_map_str_int32_set(_entity_references, "sfrown", 0x2322); + nh_map_str_int32_set(_entity_references, "sharp", 0x266f); + nh_map_str_int32_set(_entity_references, "shchcy", 0x449); + nh_map_str_int32_set(_entity_references, "shcy", 0x448); + nh_map_str_int32_set(_entity_references, "shortmid", 0x2223); + nh_map_str_int32_set(_entity_references, "shortparallel", 0x2225); + nh_map_str_int32_set(_entity_references, "shy", 0xad); + nh_map_str_int32_set(_entity_references, "sigma", 0x3c3); + nh_map_str_int32_set(_entity_references, "sigmaf", 0x3c2); + nh_map_str_int32_set(_entity_references, "sigmav", 0x3c2); + nh_map_str_int32_set(_entity_references, "sim", 0x223c); + nh_map_str_int32_set(_entity_references, "simdot", 0x2a6a); + nh_map_str_int32_set(_entity_references, "sime", 0x2243); + nh_map_str_int32_set(_entity_references, "simeq", 0x2243); + nh_map_str_int32_set(_entity_references, "simg", 0x2a9e); + nh_map_str_int32_set(_entity_references, "simgE", 0x2aa0); + nh_map_str_int32_set(_entity_references, "siml", 0x2a9d); + nh_map_str_int32_set(_entity_references, "simlE", 0x2a9f); + nh_map_str_int32_set(_entity_references, "simne", 0x2246); + nh_map_str_int32_set(_entity_references, "simplus", 0x2a24); + nh_map_str_int32_set(_entity_references, "simrarr", 0x2972); + nh_map_str_int32_set(_entity_references, "slarr", 0x2190); + nh_map_str_int32_set(_entity_references, "smallsetminus", 0x2216); + nh_map_str_int32_set(_entity_references, "smashp", 0x2a33); + nh_map_str_int32_set(_entity_references, "smeparsl", 0x29e4); + nh_map_str_int32_set(_entity_references, "smid", 0x2223); + nh_map_str_int32_set(_entity_references, "smile", 0x2323); + nh_map_str_int32_set(_entity_references, "smt", 0x2aaa); + nh_map_str_int32_set(_entity_references, "smte", 0x2aac); + nh_map_str_int32_set(_entity_references, "softcy", 0x44c); + nh_map_str_int32_set(_entity_references, "sol", 0x2f); + nh_map_str_int32_set(_entity_references, "solb", 0x29c4); + nh_map_str_int32_set(_entity_references, "solbar", 0x233f); + nh_map_str_int32_set(_entity_references, "sopf", 0x1d564); + nh_map_str_int32_set(_entity_references, "spades", 0x2660); + nh_map_str_int32_set(_entity_references, "spadesuit", 0x2660); + nh_map_str_int32_set(_entity_references, "spar", 0x2225); + nh_map_str_int32_set(_entity_references, "sqcap", 0x2293); + nh_map_str_int32_set(_entity_references, "sqcup", 0x2294); + nh_map_str_int32_set(_entity_references, "sqsub", 0x228f); + nh_map_str_int32_set(_entity_references, "sqsube", 0x2291); + nh_map_str_int32_set(_entity_references, "sqsubset", 0x228f); + nh_map_str_int32_set(_entity_references, "sqsubseteq", 0x2291); + nh_map_str_int32_set(_entity_references, "sqsup", 0x2290); + nh_map_str_int32_set(_entity_references, "sqsupe", 0x2292); + nh_map_str_int32_set(_entity_references, "sqsupset", 0x2290); + nh_map_str_int32_set(_entity_references, "sqsupseteq", 0x2292); + nh_map_str_int32_set(_entity_references, "squ", 0x25a1); + nh_map_str_int32_set(_entity_references, "square", 0x25a1); + nh_map_str_int32_set(_entity_references, "squarf", 0x25aa); + nh_map_str_int32_set(_entity_references, "squf", 0x25aa); + nh_map_str_int32_set(_entity_references, "srarr", 0x2192); + nh_map_str_int32_set(_entity_references, "sscr", 0x1d4c8); + nh_map_str_int32_set(_entity_references, "ssetmn", 0x2216); + nh_map_str_int32_set(_entity_references, "ssmile", 0x2323); + nh_map_str_int32_set(_entity_references, "sstarf", 0x22c6); + nh_map_str_int32_set(_entity_references, "star", 0x2606); + nh_map_str_int32_set(_entity_references, "starf", 0x2605); + nh_map_str_int32_set(_entity_references, "straightepsilon", 0x3f5); + nh_map_str_int32_set(_entity_references, "straightphi", 0x3d5); + nh_map_str_int32_set(_entity_references, "strns", 0xaf); + nh_map_str_int32_set(_entity_references, "sub", 0x2282); + nh_map_str_int32_set(_entity_references, "subE", 0x2ac5); + nh_map_str_int32_set(_entity_references, "subdot", 0x2abd); + nh_map_str_int32_set(_entity_references, "sube", 0x2286); + nh_map_str_int32_set(_entity_references, "subedot", 0x2ac3); + nh_map_str_int32_set(_entity_references, "submult", 0x2ac1); + nh_map_str_int32_set(_entity_references, "subnE", 0x2acb); + nh_map_str_int32_set(_entity_references, "subne", 0x228a); + nh_map_str_int32_set(_entity_references, "subplus", 0x2abf); + nh_map_str_int32_set(_entity_references, "subrarr", 0x2979); + nh_map_str_int32_set(_entity_references, "subset", 0x2282); + nh_map_str_int32_set(_entity_references, "subseteq", 0x2286); + nh_map_str_int32_set(_entity_references, "subseteqq", 0x2ac5); + nh_map_str_int32_set(_entity_references, "subsetneq", 0x228a); + nh_map_str_int32_set(_entity_references, "subsetneqq", 0x2acb); + nh_map_str_int32_set(_entity_references, "subsim", 0x2ac7); + nh_map_str_int32_set(_entity_references, "subsub", 0x2ad5); + nh_map_str_int32_set(_entity_references, "subsup", 0x2ad3); + nh_map_str_int32_set(_entity_references, "succ", 0x227b); + nh_map_str_int32_set(_entity_references, "succapprox", 0x2ab8); + nh_map_str_int32_set(_entity_references, "succcurlyeq", 0x227d); + nh_map_str_int32_set(_entity_references, "succeq", 0x2ab0); + nh_map_str_int32_set(_entity_references, "succnapprox", 0x2aba); + nh_map_str_int32_set(_entity_references, "succneqq", 0x2ab6); + nh_map_str_int32_set(_entity_references, "succnsim", 0x22e9); + nh_map_str_int32_set(_entity_references, "succsim", 0x227f); + nh_map_str_int32_set(_entity_references, "sum", 0x2211); + nh_map_str_int32_set(_entity_references, "sung", 0x266a); + nh_map_str_int32_set(_entity_references, "sup", 0x2283); + nh_map_str_int32_set(_entity_references, "sup1", 0xb9); + nh_map_str_int32_set(_entity_references, "sup2", 0xb2); + nh_map_str_int32_set(_entity_references, "sup3", 0xb3); + nh_map_str_int32_set(_entity_references, "supE", 0x2ac6); + nh_map_str_int32_set(_entity_references, "supdot", 0x2abe); + nh_map_str_int32_set(_entity_references, "supdsub", 0x2ad8); + nh_map_str_int32_set(_entity_references, "supe", 0x2287); + nh_map_str_int32_set(_entity_references, "supedot", 0x2ac4); + nh_map_str_int32_set(_entity_references, "suphsub", 0x2ad7); + nh_map_str_int32_set(_entity_references, "suplarr", 0x297b); + nh_map_str_int32_set(_entity_references, "supmult", 0x2ac2); + nh_map_str_int32_set(_entity_references, "supnE", 0x2acc); + nh_map_str_int32_set(_entity_references, "supne", 0x228b); + nh_map_str_int32_set(_entity_references, "supplus", 0x2ac0); + nh_map_str_int32_set(_entity_references, "supset", 0x2283); + nh_map_str_int32_set(_entity_references, "supseteq", 0x2287); + nh_map_str_int32_set(_entity_references, "supseteqq", 0x2ac6); + nh_map_str_int32_set(_entity_references, "supsetneq", 0x228b); + nh_map_str_int32_set(_entity_references, "supsetneqq", 0x2acc); + nh_map_str_int32_set(_entity_references, "supsim", 0x2ac8); + nh_map_str_int32_set(_entity_references, "supsub", 0x2ad4); + nh_map_str_int32_set(_entity_references, "supsup", 0x2ad6); + nh_map_str_int32_set(_entity_references, "swArr", 0x21d9); + nh_map_str_int32_set(_entity_references, "swarhk", 0x2926); + nh_map_str_int32_set(_entity_references, "swarr", 0x2199); + nh_map_str_int32_set(_entity_references, "swarrow", 0x2199); + nh_map_str_int32_set(_entity_references, "swnwar", 0x292a); + nh_map_str_int32_set(_entity_references, "szlig", 0xdf); + nh_map_str_int32_set(_entity_references, "target", 0x2316); + nh_map_str_int32_set(_entity_references, "tau", 0x3c4); + nh_map_str_int32_set(_entity_references, "tbrk", 0x23b4); + nh_map_str_int32_set(_entity_references, "tcaron", 0x165); + nh_map_str_int32_set(_entity_references, "tcedil", 0x163); + nh_map_str_int32_set(_entity_references, "tcy", 0x442); + nh_map_str_int32_set(_entity_references, "tdot", 0x20db); + nh_map_str_int32_set(_entity_references, "telrec", 0x2315); + nh_map_str_int32_set(_entity_references, "tfr", 0x1d531); + nh_map_str_int32_set(_entity_references, "there4", 0x2234); + nh_map_str_int32_set(_entity_references, "therefore", 0x2234); + nh_map_str_int32_set(_entity_references, "theta", 0x3b8); + nh_map_str_int32_set(_entity_references, "thetasym", 0x3d1); + nh_map_str_int32_set(_entity_references, "thetav", 0x3d1); + nh_map_str_int32_set(_entity_references, "thickapprox", 0x2248); + nh_map_str_int32_set(_entity_references, "thicksim", 0x223c); + nh_map_str_int32_set(_entity_references, "thinsp", 0x2009); + nh_map_str_int32_set(_entity_references, "thkap", 0x2248); + nh_map_str_int32_set(_entity_references, "thksim", 0x223c); + nh_map_str_int32_set(_entity_references, "thorn", 0xfe); + nh_map_str_int32_set(_entity_references, "tilde", 0x2dc); + nh_map_str_int32_set(_entity_references, "times", 0xd7); + nh_map_str_int32_set(_entity_references, "timesb", 0x22a0); + nh_map_str_int32_set(_entity_references, "timesbar", 0x2a31); + nh_map_str_int32_set(_entity_references, "timesd", 0x2a30); + nh_map_str_int32_set(_entity_references, "tint", 0x222d); + nh_map_str_int32_set(_entity_references, "toea", 0x2928); + nh_map_str_int32_set(_entity_references, "top", 0x22a4); + nh_map_str_int32_set(_entity_references, "topbot", 0x2336); + nh_map_str_int32_set(_entity_references, "topcir", 0x2af1); + nh_map_str_int32_set(_entity_references, "topf", 0x1d565); + nh_map_str_int32_set(_entity_references, "topfork", 0x2ada); + nh_map_str_int32_set(_entity_references, "tosa", 0x2929); + nh_map_str_int32_set(_entity_references, "tprime", 0x2034); + nh_map_str_int32_set(_entity_references, "trade", 0x2122); + nh_map_str_int32_set(_entity_references, "triangle", 0x25b5); + nh_map_str_int32_set(_entity_references, "triangledown", 0x25bf); + nh_map_str_int32_set(_entity_references, "triangleleft", 0x25c3); + nh_map_str_int32_set(_entity_references, "trianglelefteq", 0x22b4); + nh_map_str_int32_set(_entity_references, "triangleq", 0x225c); + nh_map_str_int32_set(_entity_references, "triangleright", 0x25b9); + nh_map_str_int32_set(_entity_references, "trianglerighteq", 0x22b5); + nh_map_str_int32_set(_entity_references, "tridot", 0x25ec); + nh_map_str_int32_set(_entity_references, "trie", 0x225c); + nh_map_str_int32_set(_entity_references, "triminus", 0x2a3a); + nh_map_str_int32_set(_entity_references, "triplus", 0x2a39); + nh_map_str_int32_set(_entity_references, "trisb", 0x29cd); + nh_map_str_int32_set(_entity_references, "tritime", 0x2a3b); + nh_map_str_int32_set(_entity_references, "trpezium", 0x23e2); + nh_map_str_int32_set(_entity_references, "tscr", 0x1d4c9); + nh_map_str_int32_set(_entity_references, "tscy", 0x446); + nh_map_str_int32_set(_entity_references, "tshcy", 0x45b); + nh_map_str_int32_set(_entity_references, "tstrok", 0x167); + nh_map_str_int32_set(_entity_references, "twixt", 0x226c); + nh_map_str_int32_set(_entity_references, "twoheadleftarrow", 0x219e); + nh_map_str_int32_set(_entity_references, "twoheadrightarrow", 0x21a0); + nh_map_str_int32_set(_entity_references, "uArr", 0x21d1); + nh_map_str_int32_set(_entity_references, "uHar", 0x2963); + nh_map_str_int32_set(_entity_references, "uacute", 0xfa); + nh_map_str_int32_set(_entity_references, "uarr", 0x2191); + nh_map_str_int32_set(_entity_references, "ubrcy", 0x45e); + nh_map_str_int32_set(_entity_references, "ubreve", 0x16d); + nh_map_str_int32_set(_entity_references, "ucirc", 0xfb); + nh_map_str_int32_set(_entity_references, "ucy", 0x443); + nh_map_str_int32_set(_entity_references, "udarr", 0x21c5); + nh_map_str_int32_set(_entity_references, "udblac", 0x171); + nh_map_str_int32_set(_entity_references, "udhar", 0x296e); + nh_map_str_int32_set(_entity_references, "ufisht", 0x297e); + nh_map_str_int32_set(_entity_references, "ufr", 0x1d532); + nh_map_str_int32_set(_entity_references, "ugrave", 0xf9); + nh_map_str_int32_set(_entity_references, "uharl", 0x21bf); + nh_map_str_int32_set(_entity_references, "uharr", 0x21be); + nh_map_str_int32_set(_entity_references, "uhblk", 0x2580); + nh_map_str_int32_set(_entity_references, "ulcorn", 0x231c); + nh_map_str_int32_set(_entity_references, "ulcorner", 0x231c); + nh_map_str_int32_set(_entity_references, "ulcrop", 0x230f); + nh_map_str_int32_set(_entity_references, "ultri", 0x25f8); + nh_map_str_int32_set(_entity_references, "umacr", 0x16b); + nh_map_str_int32_set(_entity_references, "uml", 0xa8); + nh_map_str_int32_set(_entity_references, "uogon", 0x173); + nh_map_str_int32_set(_entity_references, "uopf", 0x1d566); + nh_map_str_int32_set(_entity_references, "uparrow", 0x2191); + nh_map_str_int32_set(_entity_references, "updownarrow", 0x2195); + nh_map_str_int32_set(_entity_references, "upharpoonleft", 0x21bf); + nh_map_str_int32_set(_entity_references, "upharpoonright", 0x21be); + nh_map_str_int32_set(_entity_references, "uplus", 0x228e); + nh_map_str_int32_set(_entity_references, "upsi", 0x3c5); + nh_map_str_int32_set(_entity_references, "upsih", 0x3d2); + nh_map_str_int32_set(_entity_references, "upsilon", 0x3c5); + nh_map_str_int32_set(_entity_references, "upuparrows", 0x21c8); + nh_map_str_int32_set(_entity_references, "urcorn", 0x231d); + nh_map_str_int32_set(_entity_references, "urcorner", 0x231d); + nh_map_str_int32_set(_entity_references, "urcrop", 0x230e); + nh_map_str_int32_set(_entity_references, "uring", 0x16f); + nh_map_str_int32_set(_entity_references, "urtri", 0x25f9); + nh_map_str_int32_set(_entity_references, "uscr", 0x1d4ca); + nh_map_str_int32_set(_entity_references, "utdot", 0x22f0); + nh_map_str_int32_set(_entity_references, "utilde", 0x169); + nh_map_str_int32_set(_entity_references, "utri", 0x25b5); + nh_map_str_int32_set(_entity_references, "utrif", 0x25b4); + nh_map_str_int32_set(_entity_references, "uuarr", 0x21c8); + nh_map_str_int32_set(_entity_references, "uuml", 0xfc); + nh_map_str_int32_set(_entity_references, "uwangle", 0x29a7); + nh_map_str_int32_set(_entity_references, "vArr", 0x21d5); + nh_map_str_int32_set(_entity_references, "vBar", 0x2ae8); + nh_map_str_int32_set(_entity_references, "vBarv", 0x2ae9); + nh_map_str_int32_set(_entity_references, "vDash", 0x22a8); + nh_map_str_int32_set(_entity_references, "vangrt", 0x299c); + nh_map_str_int32_set(_entity_references, "varepsilon", 0x3b5); + nh_map_str_int32_set(_entity_references, "varkappa", 0x3f0); + nh_map_str_int32_set(_entity_references, "varnothing", 0x2205); + nh_map_str_int32_set(_entity_references, "varphi", 0x3c6); + nh_map_str_int32_set(_entity_references, "varpi", 0x3d6); + nh_map_str_int32_set(_entity_references, "varpropto", 0x221d); + nh_map_str_int32_set(_entity_references, "varr", 0x2195); + nh_map_str_int32_set(_entity_references, "varrho", 0x3f1); + nh_map_str_int32_set(_entity_references, "varsigma", 0x3c2); + nh_map_str_int32_set(_entity_references, "vartheta", 0x3d1); + nh_map_str_int32_set(_entity_references, "vartriangleleft", 0x22b2); + nh_map_str_int32_set(_entity_references, "vartriangleright", 0x22b3); + nh_map_str_int32_set(_entity_references, "vcy", 0x432); + nh_map_str_int32_set(_entity_references, "vdash", 0x22a2); + nh_map_str_int32_set(_entity_references, "vee", 0x2228); + nh_map_str_int32_set(_entity_references, "veebar", 0x22bb); + nh_map_str_int32_set(_entity_references, "veeeq", 0x225a); + nh_map_str_int32_set(_entity_references, "vellip", 0x22ee); + nh_map_str_int32_set(_entity_references, "verbar", 0x7c); + nh_map_str_int32_set(_entity_references, "vert", 0x7c); + nh_map_str_int32_set(_entity_references, "vfr", 0x1d533); + nh_map_str_int32_set(_entity_references, "vltri", 0x22b2); + nh_map_str_int32_set(_entity_references, "vopf", 0x1d567); + nh_map_str_int32_set(_entity_references, "vprop", 0x221d); + nh_map_str_int32_set(_entity_references, "vrtri", 0x22b3); + nh_map_str_int32_set(_entity_references, "vscr", 0x1d4cb); + nh_map_str_int32_set(_entity_references, "vzigzag", 0x299a); + nh_map_str_int32_set(_entity_references, "wcirc", 0x175); + nh_map_str_int32_set(_entity_references, "wedbar", 0x2a5f); + nh_map_str_int32_set(_entity_references, "wedge", 0x2227); + nh_map_str_int32_set(_entity_references, "wedgeq", 0x2259); + nh_map_str_int32_set(_entity_references, "weierp", 0x2118); + nh_map_str_int32_set(_entity_references, "wfr", 0x1d534); + nh_map_str_int32_set(_entity_references, "wopf", 0x1d568); + nh_map_str_int32_set(_entity_references, "wp", 0x2118); + nh_map_str_int32_set(_entity_references, "wr", 0x2240); + nh_map_str_int32_set(_entity_references, "wreath", 0x2240); + nh_map_str_int32_set(_entity_references, "wscr", 0x1d4cc); + nh_map_str_int32_set(_entity_references, "xcap", 0x22c2); + nh_map_str_int32_set(_entity_references, "xcirc", 0x25ef); + nh_map_str_int32_set(_entity_references, "xcup", 0x22c3); + nh_map_str_int32_set(_entity_references, "xdtri", 0x25bd); + nh_map_str_int32_set(_entity_references, "xfr", 0x1d535); + nh_map_str_int32_set(_entity_references, "xhArr", 0x27fa); + nh_map_str_int32_set(_entity_references, "xharr", 0x27f7); + nh_map_str_int32_set(_entity_references, "xi", 0x3be); + nh_map_str_int32_set(_entity_references, "xlArr", 0x27f8); + nh_map_str_int32_set(_entity_references, "xlarr", 0x27f5); + nh_map_str_int32_set(_entity_references, "xmap", 0x27fc); + nh_map_str_int32_set(_entity_references, "xnis", 0x22fb); + nh_map_str_int32_set(_entity_references, "xodot", 0x2a00); + nh_map_str_int32_set(_entity_references, "xopf", 0x1d569); + nh_map_str_int32_set(_entity_references, "xoplus", 0x2a01); + nh_map_str_int32_set(_entity_references, "xotime", 0x2a02); + nh_map_str_int32_set(_entity_references, "xrArr", 0x27f9); + nh_map_str_int32_set(_entity_references, "xrarr", 0x27f6); + nh_map_str_int32_set(_entity_references, "xscr", 0x1d4cd); + nh_map_str_int32_set(_entity_references, "xsqcup", 0x2a06); + nh_map_str_int32_set(_entity_references, "xuplus", 0x2a04); + nh_map_str_int32_set(_entity_references, "xutri", 0x25b3); + nh_map_str_int32_set(_entity_references, "xvee", 0x22c1); + nh_map_str_int32_set(_entity_references, "xwedge", 0x22c0); + nh_map_str_int32_set(_entity_references, "yacute", 0xfd); + nh_map_str_int32_set(_entity_references, "yacy", 0x44f); + nh_map_str_int32_set(_entity_references, "ycirc", 0x177); + nh_map_str_int32_set(_entity_references, "ycy", 0x44b); + nh_map_str_int32_set(_entity_references, "yen", 0xa5); + nh_map_str_int32_set(_entity_references, "yfr", 0x1d536); + nh_map_str_int32_set(_entity_references, "yicy", 0x457); + nh_map_str_int32_set(_entity_references, "yopf", 0x1d56a); + nh_map_str_int32_set(_entity_references, "yscr", 0x1d4ce); + nh_map_str_int32_set(_entity_references, "yucy", 0x44e); + nh_map_str_int32_set(_entity_references, "yuml", 0xff); + nh_map_str_int32_set(_entity_references, "zacute", 0x17a); + nh_map_str_int32_set(_entity_references, "zcaron", 0x17e); + nh_map_str_int32_set(_entity_references, "zcy", 0x437); + nh_map_str_int32_set(_entity_references, "zdot", 0x17c); + nh_map_str_int32_set(_entity_references, "zeetrf", 0x2128); + nh_map_str_int32_set(_entity_references, "zeta", 0x3b6); + nh_map_str_int32_set(_entity_references, "zfr", 0x1d537); + nh_map_str_int32_set(_entity_references, "zhcy", 0x436); + nh_map_str_int32_set(_entity_references, "zigrarr", 0x21dd); + nh_map_str_int32_set(_entity_references, "zopf", 0x1d56b); + nh_map_str_int32_set(_entity_references, "zscr", 0x1d4cf); + nh_map_str_int32_set(_entity_references, "zwj", 0x200d); + nh_map_str_int32_set(_entity_references, "zwnj", 0x200c); } -int hbr_entityrefs_check(hb_char_t *ref) { - return nh_map_str_int32_has(hbr_entityrefs_map, (char *) ref); +int hb_rule_entity_references_check(hb_proc_char_t* ref) +{ + return nh_map_str_int32_has(_entity_references, ref); } -uint32_t hbr_entityrefs_get(hb_char_t *ref) { - return nh_map_str_int32_get(hbr_entityrefs_map, (char *) ref, 0); +uint32_t hb_rule_entity_references_get(hb_proc_char_t* ref) +{ + return nh_map_str_int32_get(_entity_references, ref, 0); } diff --git a/src/rule/relation/blacklistchildren.c b/src/rule/relation/blacklistchildren.c index d282c53..f63aff8 100644 --- a/src/rule/relation/blacklistchildren.c +++ b/src/rule/relation/blacklistchildren.c @@ -2,80 +2,80 @@ #include "../tag/mediatags.c" #include "../tag/sectioningtags.c" -static nh_map_str_strset_t hbr_blacklistchildren_map; +static nh_map_str_strset_t hb_rule_blacklistchildren_map; -void hbr_blacklistchildren_init(void) { - hbr_blacklistchildren_map = nh_map_str_strset_create(); +void hb_rule_blacklistchildren_init(void) { + hb_rule_blacklistchildren_map = nh_map_str_strset_create(); //
nh_set_str_t address = nh_set_str_create(); - hbr_headingtags_add_elems(address); - hbr_sectioningtags_add_elems(address); + hb_rule_headingtags_add_elems(address); + hb_rule_sectioningtags_add_elems(address); nh_set_str_add(address, "address"); nh_set_str_add(address, "header"); nh_set_str_add(address, "footer"); - nh_map_str_strset_set(hbr_blacklistchildren_map, "address", address); + nh_map_str_strset_set(hb_rule_blacklistchildren_map, "address", address); //