X-Git-Url: http://nitlanguage.org diff --git a/c_src/nitg.types.3.c b/c_src/nitg.types.3.c new file mode 100644 index 0000000..2e77e02 --- /dev/null +++ b/c_src/nitg.types.3.c @@ -0,0 +1,9989 @@ +#include "nitg.types.0.h" +const struct types resolution_table_parser__ReduceAction695 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction696 */ +const struct type type_parser__ReduceAction696 = { +1251, +"ReduceAction696", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction696, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1251, /* ReduceAction696 */ +}, +}; +const struct types resolution_table_parser__ReduceAction696 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction697 */ +const struct type type_parser__ReduceAction697 = { +1252, +"ReduceAction697", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction697, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1252, /* ReduceAction697 */ +}, +}; +const struct types resolution_table_parser__ReduceAction697 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction698 */ +const struct type type_parser__ReduceAction698 = { +1253, +"ReduceAction698", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction698, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1253, /* ReduceAction698 */ +}, +}; +const struct types resolution_table_parser__ReduceAction698 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction699 */ +const struct type type_parser__ReduceAction699 = { +1254, +"ReduceAction699", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction699, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1254, /* ReduceAction699 */ +}, +}; +const struct types resolution_table_parser__ReduceAction699 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction701 */ +const struct type type_parser__ReduceAction701 = { +1255, +"ReduceAction701", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction701, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1255, /* ReduceAction701 */ +}, +}; +const struct types resolution_table_parser__ReduceAction701 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction702 */ +const struct type type_parser__ReduceAction702 = { +1256, +"ReduceAction702", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction702, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1256, /* ReduceAction702 */ +}, +}; +const struct types resolution_table_parser__ReduceAction702 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction704 */ +const struct type type_parser__ReduceAction704 = { +1257, +"ReduceAction704", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction704, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1257, /* ReduceAction704 */ +}, +}; +const struct types resolution_table_parser__ReduceAction704 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction705 */ +const struct type type_parser__ReduceAction705 = { +1258, +"ReduceAction705", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction705, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1258, /* ReduceAction705 */ +}, +}; +const struct types resolution_table_parser__ReduceAction705 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction706 */ +const struct type type_parser__ReduceAction706 = { +1259, +"ReduceAction706", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction706, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1259, /* ReduceAction706 */ +}, +}; +const struct types resolution_table_parser__ReduceAction706 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction707 */ +const struct type type_parser__ReduceAction707 = { +1260, +"ReduceAction707", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction707, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1260, /* ReduceAction707 */ +}, +}; +const struct types resolution_table_parser__ReduceAction707 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction709 */ +const struct type type_parser__ReduceAction709 = { +1261, +"ReduceAction709", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction709, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1261, /* ReduceAction709 */ +}, +}; +const struct types resolution_table_parser__ReduceAction709 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction710 */ +const struct type type_parser__ReduceAction710 = { +1262, +"ReduceAction710", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction710, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1262, /* ReduceAction710 */ +}, +}; +const struct types resolution_table_parser__ReduceAction710 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction712 */ +const struct type type_parser__ReduceAction712 = { +1263, +"ReduceAction712", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction712, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1263, /* ReduceAction712 */ +}, +}; +const struct types resolution_table_parser__ReduceAction712 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction713 */ +const struct type type_parser__ReduceAction713 = { +1264, +"ReduceAction713", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction713, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1264, /* ReduceAction713 */ +}, +}; +const struct types resolution_table_parser__ReduceAction713 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction714 */ +const struct type type_parser__ReduceAction714 = { +1265, +"ReduceAction714", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction714, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1265, /* ReduceAction714 */ +}, +}; +const struct types resolution_table_parser__ReduceAction714 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction715 */ +const struct type type_parser__ReduceAction715 = { +1266, +"ReduceAction715", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction715, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1266, /* ReduceAction715 */ +}, +}; +const struct types resolution_table_parser__ReduceAction715 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction716 */ +const struct type type_parser__ReduceAction716 = { +1267, +"ReduceAction716", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction716, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1267, /* ReduceAction716 */ +}, +}; +const struct types resolution_table_parser__ReduceAction716 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction718 */ +const struct type type_parser__ReduceAction718 = { +1268, +"ReduceAction718", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction718, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1268, /* ReduceAction718 */ +}, +}; +const struct types resolution_table_parser__ReduceAction718 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction719 */ +const struct type type_parser__ReduceAction719 = { +1269, +"ReduceAction719", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction719, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1269, /* ReduceAction719 */ +}, +}; +const struct types resolution_table_parser__ReduceAction719 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction721 */ +const struct type type_parser__ReduceAction721 = { +1270, +"ReduceAction721", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction721, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1270, /* ReduceAction721 */ +}, +}; +const struct types resolution_table_parser__ReduceAction721 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction722 */ +const struct type type_parser__ReduceAction722 = { +1271, +"ReduceAction722", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction722, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1271, /* ReduceAction722 */ +}, +}; +const struct types resolution_table_parser__ReduceAction722 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction723 */ +const struct type type_parser__ReduceAction723 = { +1272, +"ReduceAction723", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction723, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1272, /* ReduceAction723 */ +}, +}; +const struct types resolution_table_parser__ReduceAction723 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction724 */ +const struct type type_parser__ReduceAction724 = { +1273, +"ReduceAction724", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction724, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1273, /* ReduceAction724 */ +}, +}; +const struct types resolution_table_parser__ReduceAction724 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction726 */ +const struct type type_parser__ReduceAction726 = { +1274, +"ReduceAction726", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction726, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1274, /* ReduceAction726 */ +}, +}; +const struct types resolution_table_parser__ReduceAction726 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction727 */ +const struct type type_parser__ReduceAction727 = { +1275, +"ReduceAction727", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction727, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1275, /* ReduceAction727 */ +}, +}; +const struct types resolution_table_parser__ReduceAction727 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction729 */ +const struct type type_parser__ReduceAction729 = { +1276, +"ReduceAction729", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction729, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1276, /* ReduceAction729 */ +}, +}; +const struct types resolution_table_parser__ReduceAction729 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction730 */ +const struct type type_parser__ReduceAction730 = { +1277, +"ReduceAction730", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction730, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1277, /* ReduceAction730 */ +}, +}; +const struct types resolution_table_parser__ReduceAction730 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction731 */ +const struct type type_parser__ReduceAction731 = { +1278, +"ReduceAction731", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction731, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1278, /* ReduceAction731 */ +}, +}; +const struct types resolution_table_parser__ReduceAction731 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction732 */ +const struct type type_parser__ReduceAction732 = { +1279, +"ReduceAction732", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction732, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1279, /* ReduceAction732 */ +}, +}; +const struct types resolution_table_parser__ReduceAction732 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction733 */ +const struct type type_parser__ReduceAction733 = { +1280, +"ReduceAction733", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction733, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1280, /* ReduceAction733 */ +}, +}; +const struct types resolution_table_parser__ReduceAction733 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction734 */ +const struct type type_parser__ReduceAction734 = { +1281, +"ReduceAction734", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction734, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1281, /* ReduceAction734 */ +}, +}; +const struct types resolution_table_parser__ReduceAction734 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction735 */ +const struct type type_parser__ReduceAction735 = { +1282, +"ReduceAction735", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction735, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1282, /* ReduceAction735 */ +}, +}; +const struct types resolution_table_parser__ReduceAction735 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction736 */ +const struct type type_parser__ReduceAction736 = { +1283, +"ReduceAction736", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction736, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1283, /* ReduceAction736 */ +}, +}; +const struct types resolution_table_parser__ReduceAction736 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction737 */ +const struct type type_parser__ReduceAction737 = { +1284, +"ReduceAction737", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction737, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1284, /* ReduceAction737 */ +}, +}; +const struct types resolution_table_parser__ReduceAction737 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction738 */ +const struct type type_parser__ReduceAction738 = { +1285, +"ReduceAction738", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction738, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1285, /* ReduceAction738 */ +}, +}; +const struct types resolution_table_parser__ReduceAction738 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction741 */ +const struct type type_parser__ReduceAction741 = { +1286, +"ReduceAction741", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction741, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1286, /* ReduceAction741 */ +}, +}; +const struct types resolution_table_parser__ReduceAction741 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction742 */ +const struct type type_parser__ReduceAction742 = { +1287, +"ReduceAction742", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction742, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1287, /* ReduceAction742 */ +}, +}; +const struct types resolution_table_parser__ReduceAction742 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction743 */ +const struct type type_parser__ReduceAction743 = { +1288, +"ReduceAction743", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction743, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1288, /* ReduceAction743 */ +}, +}; +const struct types resolution_table_parser__ReduceAction743 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction744 */ +const struct type type_parser__ReduceAction744 = { +1289, +"ReduceAction744", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction744, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1289, /* ReduceAction744 */ +}, +}; +const struct types resolution_table_parser__ReduceAction744 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction745 */ +const struct type type_parser__ReduceAction745 = { +1290, +"ReduceAction745", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction745, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1290, /* ReduceAction745 */ +}, +}; +const struct types resolution_table_parser__ReduceAction745 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction746 */ +const struct type type_parser__ReduceAction746 = { +1291, +"ReduceAction746", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction746, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1291, /* ReduceAction746 */ +}, +}; +const struct types resolution_table_parser__ReduceAction746 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction747 */ +const struct type type_parser__ReduceAction747 = { +1292, +"ReduceAction747", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction747, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1292, /* ReduceAction747 */ +}, +}; +const struct types resolution_table_parser__ReduceAction747 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction748 */ +const struct type type_parser__ReduceAction748 = { +1293, +"ReduceAction748", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction748, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1293, /* ReduceAction748 */ +}, +}; +const struct types resolution_table_parser__ReduceAction748 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction749 */ +const struct type type_parser__ReduceAction749 = { +1294, +"ReduceAction749", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction749, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1294, /* ReduceAction749 */ +}, +}; +const struct types resolution_table_parser__ReduceAction749 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction750 */ +const struct type type_parser__ReduceAction750 = { +1295, +"ReduceAction750", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction750, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1295, /* ReduceAction750 */ +}, +}; +const struct types resolution_table_parser__ReduceAction750 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction751 */ +const struct type type_parser__ReduceAction751 = { +1296, +"ReduceAction751", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction751, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1296, /* ReduceAction751 */ +}, +}; +const struct types resolution_table_parser__ReduceAction751 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction752 */ +const struct type type_parser__ReduceAction752 = { +1297, +"ReduceAction752", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction752, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1297, /* ReduceAction752 */ +}, +}; +const struct types resolution_table_parser__ReduceAction752 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction753 */ +const struct type type_parser__ReduceAction753 = { +1298, +"ReduceAction753", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction753, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1298, /* ReduceAction753 */ +}, +}; +const struct types resolution_table_parser__ReduceAction753 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction763 */ +const struct type type_parser__ReduceAction763 = { +1299, +"ReduceAction763", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction763, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1299, /* ReduceAction763 */ +}, +}; +const struct types resolution_table_parser__ReduceAction763 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction765 */ +const struct type type_parser__ReduceAction765 = { +1300, +"ReduceAction765", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction765, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1300, /* ReduceAction765 */ +}, +}; +const struct types resolution_table_parser__ReduceAction765 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction767 */ +const struct type type_parser__ReduceAction767 = { +1301, +"ReduceAction767", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction767, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1301, /* ReduceAction767 */ +}, +}; +const struct types resolution_table_parser__ReduceAction767 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction768 */ +const struct type type_parser__ReduceAction768 = { +1302, +"ReduceAction768", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction768, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1302, /* ReduceAction768 */ +}, +}; +const struct types resolution_table_parser__ReduceAction768 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction769 */ +const struct type type_parser__ReduceAction769 = { +1303, +"ReduceAction769", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction769, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1303, /* ReduceAction769 */ +}, +}; +const struct types resolution_table_parser__ReduceAction769 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction770 */ +const struct type type_parser__ReduceAction770 = { +1304, +"ReduceAction770", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction770, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1304, /* ReduceAction770 */ +}, +}; +const struct types resolution_table_parser__ReduceAction770 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction772 */ +const struct type type_parser__ReduceAction772 = { +1305, +"ReduceAction772", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction772, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1305, /* ReduceAction772 */ +}, +}; +const struct types resolution_table_parser__ReduceAction772 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction774 */ +const struct type type_parser__ReduceAction774 = { +1306, +"ReduceAction774", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction774, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1306, /* ReduceAction774 */ +}, +}; +const struct types resolution_table_parser__ReduceAction774 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction775 */ +const struct type type_parser__ReduceAction775 = { +1307, +"ReduceAction775", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction775, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1307, /* ReduceAction775 */ +}, +}; +const struct types resolution_table_parser__ReduceAction775 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction776 */ +const struct type type_parser__ReduceAction776 = { +1308, +"ReduceAction776", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction776, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1308, /* ReduceAction776 */ +}, +}; +const struct types resolution_table_parser__ReduceAction776 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction777 */ +const struct type type_parser__ReduceAction777 = { +1309, +"ReduceAction777", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction777, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1309, /* ReduceAction777 */ +}, +}; +const struct types resolution_table_parser__ReduceAction777 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction778 */ +const struct type type_parser__ReduceAction778 = { +1310, +"ReduceAction778", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction778, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1310, /* ReduceAction778 */ +}, +}; +const struct types resolution_table_parser__ReduceAction778 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction779 */ +const struct type type_parser__ReduceAction779 = { +1311, +"ReduceAction779", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction779, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1311, /* ReduceAction779 */ +}, +}; +const struct types resolution_table_parser__ReduceAction779 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction780 */ +const struct type type_parser__ReduceAction780 = { +1312, +"ReduceAction780", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction780, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1312, /* ReduceAction780 */ +}, +}; +const struct types resolution_table_parser__ReduceAction780 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction781 */ +const struct type type_parser__ReduceAction781 = { +1313, +"ReduceAction781", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction781, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1313, /* ReduceAction781 */ +}, +}; +const struct types resolution_table_parser__ReduceAction781 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction782 */ +const struct type type_parser__ReduceAction782 = { +1314, +"ReduceAction782", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction782, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1314, /* ReduceAction782 */ +}, +}; +const struct types resolution_table_parser__ReduceAction782 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction783 */ +const struct type type_parser__ReduceAction783 = { +1315, +"ReduceAction783", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction783, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1315, /* ReduceAction783 */ +}, +}; +const struct types resolution_table_parser__ReduceAction783 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction784 */ +const struct type type_parser__ReduceAction784 = { +1316, +"ReduceAction784", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction784, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1316, /* ReduceAction784 */ +}, +}; +const struct types resolution_table_parser__ReduceAction784 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction786 */ +const struct type type_parser__ReduceAction786 = { +1317, +"ReduceAction786", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction786, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1317, /* ReduceAction786 */ +}, +}; +const struct types resolution_table_parser__ReduceAction786 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction787 */ +const struct type type_parser__ReduceAction787 = { +1318, +"ReduceAction787", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction787, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1318, /* ReduceAction787 */ +}, +}; +const struct types resolution_table_parser__ReduceAction787 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction789 */ +const struct type type_parser__ReduceAction789 = { +1319, +"ReduceAction789", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction789, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1319, /* ReduceAction789 */ +}, +}; +const struct types resolution_table_parser__ReduceAction789 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction790 */ +const struct type type_parser__ReduceAction790 = { +1320, +"ReduceAction790", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction790, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1320, /* ReduceAction790 */ +}, +}; +const struct types resolution_table_parser__ReduceAction790 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction791 */ +const struct type type_parser__ReduceAction791 = { +1321, +"ReduceAction791", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction791, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1321, /* ReduceAction791 */ +}, +}; +const struct types resolution_table_parser__ReduceAction791 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction793 */ +const struct type type_parser__ReduceAction793 = { +1322, +"ReduceAction793", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction793, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1322, /* ReduceAction793 */ +}, +}; +const struct types resolution_table_parser__ReduceAction793 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction794 */ +const struct type type_parser__ReduceAction794 = { +1323, +"ReduceAction794", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction794, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1323, /* ReduceAction794 */ +}, +}; +const struct types resolution_table_parser__ReduceAction794 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction796 */ +const struct type type_parser__ReduceAction796 = { +1324, +"ReduceAction796", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction796, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1324, /* ReduceAction796 */ +}, +}; +const struct types resolution_table_parser__ReduceAction796 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction797 */ +const struct type type_parser__ReduceAction797 = { +1325, +"ReduceAction797", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction797, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1325, /* ReduceAction797 */ +}, +}; +const struct types resolution_table_parser__ReduceAction797 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction798 */ +const struct type type_parser__ReduceAction798 = { +1326, +"ReduceAction798", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction798, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1326, /* ReduceAction798 */ +}, +}; +const struct types resolution_table_parser__ReduceAction798 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction799 */ +const struct type type_parser__ReduceAction799 = { +1327, +"ReduceAction799", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction799, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1327, /* ReduceAction799 */ +}, +}; +const struct types resolution_table_parser__ReduceAction799 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction800 */ +const struct type type_parser__ReduceAction800 = { +1328, +"ReduceAction800", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction800, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1328, /* ReduceAction800 */ +}, +}; +const struct types resolution_table_parser__ReduceAction800 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction802 */ +const struct type type_parser__ReduceAction802 = { +1329, +"ReduceAction802", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction802, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1329, /* ReduceAction802 */ +}, +}; +const struct types resolution_table_parser__ReduceAction802 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction803 */ +const struct type type_parser__ReduceAction803 = { +1330, +"ReduceAction803", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction803, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1330, /* ReduceAction803 */ +}, +}; +const struct types resolution_table_parser__ReduceAction803 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction805 */ +const struct type type_parser__ReduceAction805 = { +1331, +"ReduceAction805", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction805, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1331, /* ReduceAction805 */ +}, +}; +const struct types resolution_table_parser__ReduceAction805 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction806 */ +const struct type type_parser__ReduceAction806 = { +1332, +"ReduceAction806", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction806, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1332, /* ReduceAction806 */ +}, +}; +const struct types resolution_table_parser__ReduceAction806 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction807 */ +const struct type type_parser__ReduceAction807 = { +1333, +"ReduceAction807", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction807, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1333, /* ReduceAction807 */ +}, +}; +const struct types resolution_table_parser__ReduceAction807 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction808 */ +const struct type type_parser__ReduceAction808 = { +1334, +"ReduceAction808", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction808, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1334, /* ReduceAction808 */ +}, +}; +const struct types resolution_table_parser__ReduceAction808 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction810 */ +const struct type type_parser__ReduceAction810 = { +1335, +"ReduceAction810", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction810, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1335, /* ReduceAction810 */ +}, +}; +const struct types resolution_table_parser__ReduceAction810 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction811 */ +const struct type type_parser__ReduceAction811 = { +1336, +"ReduceAction811", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction811, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1336, /* ReduceAction811 */ +}, +}; +const struct types resolution_table_parser__ReduceAction811 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction827 */ +const struct type type_parser__ReduceAction827 = { +1337, +"ReduceAction827", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction827, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1337, /* ReduceAction827 */ +}, +}; +const struct types resolution_table_parser__ReduceAction827 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction828 */ +const struct type type_parser__ReduceAction828 = { +1338, +"ReduceAction828", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction828, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1338, /* ReduceAction828 */ +}, +}; +const struct types resolution_table_parser__ReduceAction828 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction829 */ +const struct type type_parser__ReduceAction829 = { +1339, +"ReduceAction829", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction829, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1339, /* ReduceAction829 */ +}, +}; +const struct types resolution_table_parser__ReduceAction829 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction830 */ +const struct type type_parser__ReduceAction830 = { +1340, +"ReduceAction830", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction830, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1340, /* ReduceAction830 */ +}, +}; +const struct types resolution_table_parser__ReduceAction830 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction832 */ +const struct type type_parser__ReduceAction832 = { +1341, +"ReduceAction832", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction832, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1341, /* ReduceAction832 */ +}, +}; +const struct types resolution_table_parser__ReduceAction832 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction833 */ +const struct type type_parser__ReduceAction833 = { +1342, +"ReduceAction833", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction833, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1342, /* ReduceAction833 */ +}, +}; +const struct types resolution_table_parser__ReduceAction833 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction834 */ +const struct type type_parser__ReduceAction834 = { +1343, +"ReduceAction834", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction834, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1343, /* ReduceAction834 */ +}, +}; +const struct types resolution_table_parser__ReduceAction834 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction835 */ +const struct type type_parser__ReduceAction835 = { +1344, +"ReduceAction835", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction835, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1344, /* ReduceAction835 */ +}, +}; +const struct types resolution_table_parser__ReduceAction835 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction836 */ +const struct type type_parser__ReduceAction836 = { +1345, +"ReduceAction836", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction836, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1345, /* ReduceAction836 */ +}, +}; +const struct types resolution_table_parser__ReduceAction836 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction837 */ +const struct type type_parser__ReduceAction837 = { +1346, +"ReduceAction837", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction837, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1346, /* ReduceAction837 */ +}, +}; +const struct types resolution_table_parser__ReduceAction837 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction838 */ +const struct type type_parser__ReduceAction838 = { +1347, +"ReduceAction838", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction838, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1347, /* ReduceAction838 */ +}, +}; +const struct types resolution_table_parser__ReduceAction838 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction839 */ +const struct type type_parser__ReduceAction839 = { +1348, +"ReduceAction839", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction839, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1348, /* ReduceAction839 */ +}, +}; +const struct types resolution_table_parser__ReduceAction839 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction840 */ +const struct type type_parser__ReduceAction840 = { +1349, +"ReduceAction840", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction840, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1349, /* ReduceAction840 */ +}, +}; +const struct types resolution_table_parser__ReduceAction840 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction841 */ +const struct type type_parser__ReduceAction841 = { +1350, +"ReduceAction841", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction841, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1350, /* ReduceAction841 */ +}, +}; +const struct types resolution_table_parser__ReduceAction841 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction842 */ +const struct type type_parser__ReduceAction842 = { +1351, +"ReduceAction842", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction842, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1351, /* ReduceAction842 */ +}, +}; +const struct types resolution_table_parser__ReduceAction842 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction843 */ +const struct type type_parser__ReduceAction843 = { +1352, +"ReduceAction843", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction843, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1352, /* ReduceAction843 */ +}, +}; +const struct types resolution_table_parser__ReduceAction843 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction844 */ +const struct type type_parser__ReduceAction844 = { +1353, +"ReduceAction844", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction844, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1353, /* ReduceAction844 */ +}, +}; +const struct types resolution_table_parser__ReduceAction844 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction845 */ +const struct type type_parser__ReduceAction845 = { +1354, +"ReduceAction845", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction845, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1354, /* ReduceAction845 */ +}, +}; +const struct types resolution_table_parser__ReduceAction845 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction846 */ +const struct type type_parser__ReduceAction846 = { +1355, +"ReduceAction846", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction846, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1355, /* ReduceAction846 */ +}, +}; +const struct types resolution_table_parser__ReduceAction846 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction847 */ +const struct type type_parser__ReduceAction847 = { +1356, +"ReduceAction847", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction847, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1356, /* ReduceAction847 */ +}, +}; +const struct types resolution_table_parser__ReduceAction847 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction848 */ +const struct type type_parser__ReduceAction848 = { +1357, +"ReduceAction848", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction848, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1357, /* ReduceAction848 */ +}, +}; +const struct types resolution_table_parser__ReduceAction848 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction849 */ +const struct type type_parser__ReduceAction849 = { +1358, +"ReduceAction849", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction849, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1358, /* ReduceAction849 */ +}, +}; +const struct types resolution_table_parser__ReduceAction849 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction850 */ +const struct type type_parser__ReduceAction850 = { +1359, +"ReduceAction850", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction850, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1359, /* ReduceAction850 */ +}, +}; +const struct types resolution_table_parser__ReduceAction850 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction851 */ +const struct type type_parser__ReduceAction851 = { +1360, +"ReduceAction851", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction851, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1360, /* ReduceAction851 */ +}, +}; +const struct types resolution_table_parser__ReduceAction851 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction852 */ +const struct type type_parser__ReduceAction852 = { +1361, +"ReduceAction852", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction852, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1361, /* ReduceAction852 */ +}, +}; +const struct types resolution_table_parser__ReduceAction852 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction853 */ +const struct type type_parser__ReduceAction853 = { +1362, +"ReduceAction853", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction853, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1362, /* ReduceAction853 */ +}, +}; +const struct types resolution_table_parser__ReduceAction853 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction855 */ +const struct type type_parser__ReduceAction855 = { +1363, +"ReduceAction855", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction855, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1363, /* ReduceAction855 */ +}, +}; +const struct types resolution_table_parser__ReduceAction855 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction856 */ +const struct type type_parser__ReduceAction856 = { +1364, +"ReduceAction856", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction856, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1364, /* ReduceAction856 */ +}, +}; +const struct types resolution_table_parser__ReduceAction856 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction857 */ +const struct type type_parser__ReduceAction857 = { +1365, +"ReduceAction857", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction857, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1365, /* ReduceAction857 */ +}, +}; +const struct types resolution_table_parser__ReduceAction857 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction858 */ +const struct type type_parser__ReduceAction858 = { +1366, +"ReduceAction858", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction858, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1366, /* ReduceAction858 */ +}, +}; +const struct types resolution_table_parser__ReduceAction858 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction859 */ +const struct type type_parser__ReduceAction859 = { +1367, +"ReduceAction859", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction859, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1367, /* ReduceAction859 */ +}, +}; +const struct types resolution_table_parser__ReduceAction859 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction860 */ +const struct type type_parser__ReduceAction860 = { +1368, +"ReduceAction860", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction860, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1368, /* ReduceAction860 */ +}, +}; +const struct types resolution_table_parser__ReduceAction860 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction861 */ +const struct type type_parser__ReduceAction861 = { +1369, +"ReduceAction861", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction861, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1369, /* ReduceAction861 */ +}, +}; +const struct types resolution_table_parser__ReduceAction861 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction862 */ +const struct type type_parser__ReduceAction862 = { +1370, +"ReduceAction862", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction862, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1370, /* ReduceAction862 */ +}, +}; +const struct types resolution_table_parser__ReduceAction862 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction863 */ +const struct type type_parser__ReduceAction863 = { +1371, +"ReduceAction863", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction863, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1371, /* ReduceAction863 */ +}, +}; +const struct types resolution_table_parser__ReduceAction863 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction864 */ +const struct type type_parser__ReduceAction864 = { +1372, +"ReduceAction864", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction864, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1372, /* ReduceAction864 */ +}, +}; +const struct types resolution_table_parser__ReduceAction864 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction866 */ +const struct type type_parser__ReduceAction866 = { +1373, +"ReduceAction866", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction866, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1373, /* ReduceAction866 */ +}, +}; +const struct types resolution_table_parser__ReduceAction866 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction867 */ +const struct type type_parser__ReduceAction867 = { +1374, +"ReduceAction867", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction867, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1374, /* ReduceAction867 */ +}, +}; +const struct types resolution_table_parser__ReduceAction867 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction868 */ +const struct type type_parser__ReduceAction868 = { +1375, +"ReduceAction868", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction868, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1375, /* ReduceAction868 */ +}, +}; +const struct types resolution_table_parser__ReduceAction868 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction869 */ +const struct type type_parser__ReduceAction869 = { +1376, +"ReduceAction869", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction869, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1376, /* ReduceAction869 */ +}, +}; +const struct types resolution_table_parser__ReduceAction869 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction870 */ +const struct type type_parser__ReduceAction870 = { +1377, +"ReduceAction870", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction870, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1377, /* ReduceAction870 */ +}, +}; +const struct types resolution_table_parser__ReduceAction870 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction871 */ +const struct type type_parser__ReduceAction871 = { +1378, +"ReduceAction871", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction871, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1378, /* ReduceAction871 */ +}, +}; +const struct types resolution_table_parser__ReduceAction871 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction872 */ +const struct type type_parser__ReduceAction872 = { +1379, +"ReduceAction872", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction872, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1379, /* ReduceAction872 */ +}, +}; +const struct types resolution_table_parser__ReduceAction872 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction873 */ +const struct type type_parser__ReduceAction873 = { +1380, +"ReduceAction873", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction873, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1380, /* ReduceAction873 */ +}, +}; +const struct types resolution_table_parser__ReduceAction873 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction874 */ +const struct type type_parser__ReduceAction874 = { +1381, +"ReduceAction874", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction874, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1381, /* ReduceAction874 */ +}, +}; +const struct types resolution_table_parser__ReduceAction874 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction875 */ +const struct type type_parser__ReduceAction875 = { +1382, +"ReduceAction875", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction875, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1382, /* ReduceAction875 */ +}, +}; +const struct types resolution_table_parser__ReduceAction875 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction876 */ +const struct type type_parser__ReduceAction876 = { +1383, +"ReduceAction876", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction876, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1383, /* ReduceAction876 */ +}, +}; +const struct types resolution_table_parser__ReduceAction876 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction878 */ +const struct type type_parser__ReduceAction878 = { +1384, +"ReduceAction878", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction878, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1384, /* ReduceAction878 */ +}, +}; +const struct types resolution_table_parser__ReduceAction878 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction879 */ +const struct type type_parser__ReduceAction879 = { +1385, +"ReduceAction879", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction879, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1385, /* ReduceAction879 */ +}, +}; +const struct types resolution_table_parser__ReduceAction879 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction880 */ +const struct type type_parser__ReduceAction880 = { +1386, +"ReduceAction880", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction880, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1386, /* ReduceAction880 */ +}, +}; +const struct types resolution_table_parser__ReduceAction880 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction881 */ +const struct type type_parser__ReduceAction881 = { +1387, +"ReduceAction881", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction881, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1387, /* ReduceAction881 */ +}, +}; +const struct types resolution_table_parser__ReduceAction881 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction882 */ +const struct type type_parser__ReduceAction882 = { +1388, +"ReduceAction882", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction882, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1388, /* ReduceAction882 */ +}, +}; +const struct types resolution_table_parser__ReduceAction882 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction883 */ +const struct type type_parser__ReduceAction883 = { +1389, +"ReduceAction883", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction883, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1389, /* ReduceAction883 */ +}, +}; +const struct types resolution_table_parser__ReduceAction883 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction884 */ +const struct type type_parser__ReduceAction884 = { +1390, +"ReduceAction884", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction884, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1390, /* ReduceAction884 */ +}, +}; +const struct types resolution_table_parser__ReduceAction884 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction885 */ +const struct type type_parser__ReduceAction885 = { +1391, +"ReduceAction885", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction885, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1391, /* ReduceAction885 */ +}, +}; +const struct types resolution_table_parser__ReduceAction885 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction886 */ +const struct type type_parser__ReduceAction886 = { +1392, +"ReduceAction886", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction886, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1392, /* ReduceAction886 */ +}, +}; +const struct types resolution_table_parser__ReduceAction886 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction887 */ +const struct type type_parser__ReduceAction887 = { +1393, +"ReduceAction887", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction887, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1393, /* ReduceAction887 */ +}, +}; +const struct types resolution_table_parser__ReduceAction887 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction888 */ +const struct type type_parser__ReduceAction888 = { +1394, +"ReduceAction888", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction888, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1394, /* ReduceAction888 */ +}, +}; +const struct types resolution_table_parser__ReduceAction888 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction890 */ +const struct type type_parser__ReduceAction890 = { +1395, +"ReduceAction890", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction890, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1395, /* ReduceAction890 */ +}, +}; +const struct types resolution_table_parser__ReduceAction890 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction891 */ +const struct type type_parser__ReduceAction891 = { +1396, +"ReduceAction891", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction891, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1396, /* ReduceAction891 */ +}, +}; +const struct types resolution_table_parser__ReduceAction891 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction892 */ +const struct type type_parser__ReduceAction892 = { +1397, +"ReduceAction892", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction892, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1397, /* ReduceAction892 */ +}, +}; +const struct types resolution_table_parser__ReduceAction892 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction893 */ +const struct type type_parser__ReduceAction893 = { +1398, +"ReduceAction893", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction893, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1398, /* ReduceAction893 */ +}, +}; +const struct types resolution_table_parser__ReduceAction893 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction895 */ +const struct type type_parser__ReduceAction895 = { +1399, +"ReduceAction895", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction895, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1399, /* ReduceAction895 */ +}, +}; +const struct types resolution_table_parser__ReduceAction895 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction896 */ +const struct type type_parser__ReduceAction896 = { +1400, +"ReduceAction896", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction896, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1400, /* ReduceAction896 */ +}, +}; +const struct types resolution_table_parser__ReduceAction896 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction897 */ +const struct type type_parser__ReduceAction897 = { +1401, +"ReduceAction897", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction897, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1401, /* ReduceAction897 */ +}, +}; +const struct types resolution_table_parser__ReduceAction897 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction899 */ +const struct type type_parser__ReduceAction899 = { +1402, +"ReduceAction899", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction899, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1402, /* ReduceAction899 */ +}, +}; +const struct types resolution_table_parser__ReduceAction899 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction900 */ +const struct type type_parser__ReduceAction900 = { +1403, +"ReduceAction900", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction900, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1403, /* ReduceAction900 */ +}, +}; +const struct types resolution_table_parser__ReduceAction900 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction901 */ +const struct type type_parser__ReduceAction901 = { +1404, +"ReduceAction901", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction901, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1404, /* ReduceAction901 */ +}, +}; +const struct types resolution_table_parser__ReduceAction901 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction903 */ +const struct type type_parser__ReduceAction903 = { +1405, +"ReduceAction903", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction903, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1405, /* ReduceAction903 */ +}, +}; +const struct types resolution_table_parser__ReduceAction903 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction904 */ +const struct type type_parser__ReduceAction904 = { +1406, +"ReduceAction904", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction904, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1406, /* ReduceAction904 */ +}, +}; +const struct types resolution_table_parser__ReduceAction904 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction905 */ +const struct type type_parser__ReduceAction905 = { +1407, +"ReduceAction905", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction905, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1407, /* ReduceAction905 */ +}, +}; +const struct types resolution_table_parser__ReduceAction905 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction907 */ +const struct type type_parser__ReduceAction907 = { +1408, +"ReduceAction907", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction907, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1408, /* ReduceAction907 */ +}, +}; +const struct types resolution_table_parser__ReduceAction907 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction908 */ +const struct type type_parser__ReduceAction908 = { +1409, +"ReduceAction908", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction908, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1409, /* ReduceAction908 */ +}, +}; +const struct types resolution_table_parser__ReduceAction908 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction909 */ +const struct type type_parser__ReduceAction909 = { +1410, +"ReduceAction909", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction909, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1410, /* ReduceAction909 */ +}, +}; +const struct types resolution_table_parser__ReduceAction909 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction911 */ +const struct type type_parser__ReduceAction911 = { +1411, +"ReduceAction911", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction911, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1411, /* ReduceAction911 */ +}, +}; +const struct types resolution_table_parser__ReduceAction911 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction914 */ +const struct type type_parser__ReduceAction914 = { +1412, +"ReduceAction914", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction914, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1412, /* ReduceAction914 */ +}, +}; +const struct types resolution_table_parser__ReduceAction914 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction915 */ +const struct type type_parser__ReduceAction915 = { +1413, +"ReduceAction915", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction915, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1413, /* ReduceAction915 */ +}, +}; +const struct types resolution_table_parser__ReduceAction915 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction916 */ +const struct type type_parser__ReduceAction916 = { +1414, +"ReduceAction916", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction916, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1414, /* ReduceAction916 */ +}, +}; +const struct types resolution_table_parser__ReduceAction916 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction917 */ +const struct type type_parser__ReduceAction917 = { +1415, +"ReduceAction917", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction917, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1415, /* ReduceAction917 */ +}, +}; +const struct types resolution_table_parser__ReduceAction917 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction918 */ +const struct type type_parser__ReduceAction918 = { +1416, +"ReduceAction918", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction918, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1416, /* ReduceAction918 */ +}, +}; +const struct types resolution_table_parser__ReduceAction918 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction919 */ +const struct type type_parser__ReduceAction919 = { +1417, +"ReduceAction919", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction919, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1417, /* ReduceAction919 */ +}, +}; +const struct types resolution_table_parser__ReduceAction919 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction920 */ +const struct type type_parser__ReduceAction920 = { +1418, +"ReduceAction920", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction920, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1418, /* ReduceAction920 */ +}, +}; +const struct types resolution_table_parser__ReduceAction920 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction921 */ +const struct type type_parser__ReduceAction921 = { +1419, +"ReduceAction921", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction921, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1419, /* ReduceAction921 */ +}, +}; +const struct types resolution_table_parser__ReduceAction921 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction922 */ +const struct type type_parser__ReduceAction922 = { +1420, +"ReduceAction922", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction922, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1420, /* ReduceAction922 */ +}, +}; +const struct types resolution_table_parser__ReduceAction922 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction923 */ +const struct type type_parser__ReduceAction923 = { +1421, +"ReduceAction923", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction923, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1421, /* ReduceAction923 */ +}, +}; +const struct types resolution_table_parser__ReduceAction923 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction924 */ +const struct type type_parser__ReduceAction924 = { +1422, +"ReduceAction924", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction924, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1422, /* ReduceAction924 */ +}, +}; +const struct types resolution_table_parser__ReduceAction924 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction925 */ +const struct type type_parser__ReduceAction925 = { +1423, +"ReduceAction925", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction925, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1423, /* ReduceAction925 */ +}, +}; +const struct types resolution_table_parser__ReduceAction925 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction926 */ +const struct type type_parser__ReduceAction926 = { +1424, +"ReduceAction926", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction926, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1424, /* ReduceAction926 */ +}, +}; +const struct types resolution_table_parser__ReduceAction926 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction928 */ +const struct type type_parser__ReduceAction928 = { +1425, +"ReduceAction928", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction928, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1425, /* ReduceAction928 */ +}, +}; +const struct types resolution_table_parser__ReduceAction928 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction929 */ +const struct type type_parser__ReduceAction929 = { +1426, +"ReduceAction929", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction929, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1426, /* ReduceAction929 */ +}, +}; +const struct types resolution_table_parser__ReduceAction929 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction931 */ +const struct type type_parser__ReduceAction931 = { +1427, +"ReduceAction931", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction931, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1427, /* ReduceAction931 */ +}, +}; +const struct types resolution_table_parser__ReduceAction931 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction932 */ +const struct type type_parser__ReduceAction932 = { +1428, +"ReduceAction932", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction932, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1428, /* ReduceAction932 */ +}, +}; +const struct types resolution_table_parser__ReduceAction932 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction933 */ +const struct type type_parser__ReduceAction933 = { +1429, +"ReduceAction933", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction933, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1429, /* ReduceAction933 */ +}, +}; +const struct types resolution_table_parser__ReduceAction933 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction934 */ +const struct type type_parser__ReduceAction934 = { +1430, +"ReduceAction934", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction934, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1430, /* ReduceAction934 */ +}, +}; +const struct types resolution_table_parser__ReduceAction934 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1317 */ +const struct type type_parser__ReduceAction1317 = { +1431, +"ReduceAction1317", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1317, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1431, /* ReduceAction1317 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1317 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1318 */ +const struct type type_parser__ReduceAction1318 = { +1432, +"ReduceAction1318", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1318, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1432, /* ReduceAction1318 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1318 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1321 */ +const struct type type_parser__ReduceAction1321 = { +1433, +"ReduceAction1321", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1321, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1433, /* ReduceAction1321 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1321 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1322 */ +const struct type type_parser__ReduceAction1322 = { +1434, +"ReduceAction1322", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1322, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1434, /* ReduceAction1322 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1322 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1325 */ +const struct type type_parser__ReduceAction1325 = { +1435, +"ReduceAction1325", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1325, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1435, /* ReduceAction1325 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1325 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1326 */ +const struct type type_parser__ReduceAction1326 = { +1436, +"ReduceAction1326", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1326, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1436, /* ReduceAction1326 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1326 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1333 */ +const struct type type_parser__ReduceAction1333 = { +1437, +"ReduceAction1333", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1333, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1437, /* ReduceAction1333 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1333 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1357 */ +const struct type type_parser__ReduceAction1357 = { +1438, +"ReduceAction1357", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1357, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1438, /* ReduceAction1357 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1357 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1358 */ +const struct type type_parser__ReduceAction1358 = { +1439, +"ReduceAction1358", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1358, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1439, /* ReduceAction1358 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1358 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1772 */ +const struct type type_parser__ReduceAction1772 = { +1440, +"ReduceAction1772", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1772, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1440, /* ReduceAction1772 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1772 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1773 */ +const struct type type_parser__ReduceAction1773 = { +1441, +"ReduceAction1773", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1773, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1441, /* ReduceAction1773 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1773 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1774 */ +const struct type type_parser__ReduceAction1774 = { +1442, +"ReduceAction1774", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1774, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1442, /* ReduceAction1774 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1774 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1775 */ +const struct type type_parser__ReduceAction1775 = { +1443, +"ReduceAction1775", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1775, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1443, /* ReduceAction1775 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1775 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1776 */ +const struct type type_parser__ReduceAction1776 = { +1444, +"ReduceAction1776", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1776, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1444, /* ReduceAction1776 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1776 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1777 */ +const struct type type_parser__ReduceAction1777 = { +1445, +"ReduceAction1777", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1777, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1445, /* ReduceAction1777 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1777 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1778 */ +const struct type type_parser__ReduceAction1778 = { +1446, +"ReduceAction1778", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1778, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1446, /* ReduceAction1778 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1778 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1779 */ +const struct type type_parser__ReduceAction1779 = { +1447, +"ReduceAction1779", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1779, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1447, /* ReduceAction1779 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1779 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1780 */ +const struct type type_parser__ReduceAction1780 = { +1448, +"ReduceAction1780", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1780, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1448, /* ReduceAction1780 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1780 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1781 */ +const struct type type_parser__ReduceAction1781 = { +1449, +"ReduceAction1781", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1781, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1449, /* ReduceAction1781 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1781 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1784 */ +const struct type type_parser__ReduceAction1784 = { +1450, +"ReduceAction1784", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1784, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1450, /* ReduceAction1784 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1784 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1785 */ +const struct type type_parser__ReduceAction1785 = { +1451, +"ReduceAction1785", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1785, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1451, /* ReduceAction1785 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1785 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1786 */ +const struct type type_parser__ReduceAction1786 = { +1452, +"ReduceAction1786", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1786, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1452, /* ReduceAction1786 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1786 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1787 */ +const struct type type_parser__ReduceAction1787 = { +1453, +"ReduceAction1787", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1787, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1453, /* ReduceAction1787 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1787 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1788 */ +const struct type type_parser__ReduceAction1788 = { +1454, +"ReduceAction1788", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1788, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1454, /* ReduceAction1788 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1788 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1789 */ +const struct type type_parser__ReduceAction1789 = { +1455, +"ReduceAction1789", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1789, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1455, /* ReduceAction1789 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1789 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1790 */ +const struct type type_parser__ReduceAction1790 = { +1456, +"ReduceAction1790", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1790, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1456, /* ReduceAction1790 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1790 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1791 */ +const struct type type_parser__ReduceAction1791 = { +1457, +"ReduceAction1791", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1791, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1457, /* ReduceAction1791 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1791 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1793 */ +const struct type type_parser__ReduceAction1793 = { +1458, +"ReduceAction1793", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1793, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1458, /* ReduceAction1793 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1793 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1794 */ +const struct type type_parser__ReduceAction1794 = { +1459, +"ReduceAction1794", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1794, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1459, /* ReduceAction1794 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1794 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1795 */ +const struct type type_parser__ReduceAction1795 = { +1460, +"ReduceAction1795", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1795, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1460, /* ReduceAction1795 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1795 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1797 */ +const struct type type_parser__ReduceAction1797 = { +1461, +"ReduceAction1797", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1797, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1461, /* ReduceAction1797 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1797 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1799 */ +const struct type type_parser__ReduceAction1799 = { +1462, +"ReduceAction1799", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1799, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1462, /* ReduceAction1799 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1799 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1803 */ +const struct type type_parser__ReduceAction1803 = { +1463, +"ReduceAction1803", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1803, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1463, /* ReduceAction1803 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1803 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1807 */ +const struct type type_parser__ReduceAction1807 = { +1464, +"ReduceAction1807", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1807, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1464, /* ReduceAction1807 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1807 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1808 */ +const struct type type_parser__ReduceAction1808 = { +1465, +"ReduceAction1808", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1808, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1465, /* ReduceAction1808 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1808 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1809 */ +const struct type type_parser__ReduceAction1809 = { +1466, +"ReduceAction1809", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1809, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1466, /* ReduceAction1809 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1809 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1810 */ +const struct type type_parser__ReduceAction1810 = { +1467, +"ReduceAction1810", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1810, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1467, /* ReduceAction1810 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1810 = { +0, /* dummy */ +{ +} +}; +/* runtime type ReduceAction1811 */ +const struct type type_parser__ReduceAction1811 = { +1468, +"ReduceAction1811", /* class_name_string */ +3, +0, +&resolution_table_parser__ReduceAction1811, +4, +{ +0, /* nullable Object */ +1, /* Object */ +246, /* ReduceAction */ +1468, /* ReduceAction1811 */ +}, +}; +const struct types resolution_table_parser__ReduceAction1811 = { +0, /* dummy */ +{ +} +}; +/* runtime type State */ +const struct type type_parser__State = { +247, +"State", /* class_name_string */ +2, +0, +&resolution_table_parser__State, +3, +{ +0, /* nullable Object */ +1, /* Object */ +247, /* State */ +}, +}; +const struct types resolution_table_parser__State = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AImport] */ +const struct type type_parser_nodes__ANodesparser_nodes__AImport = { +2470, +"ANodes[AImport]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AImport, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2470, /* ANodes[AImport] */ +1984, /* Collection[AImport] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AImport = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AImport, /* Array[ANodes#0]: Array[AImport] */ +&type_parser_nodes__AImport, /* ANodes#0: AImport */ +&type_parser_nodes__AImport, /* Sequence#0: AImport */ +&type_parser_nodes__AImport, /* SimpleCollection#0: AImport */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AImport, /* RemovableCollection#0: AImport */ +&type_abstract_collection__Collectionparser_nodes__AImport, /* Collection[Sequence#0]: Collection[AImport] */ +&type_array__Arrayparser_nodes__AImport, /* Array[Sequence#0]: Array[AImport] */ +&type_abstract_collection__Collectionparser_nodes__AImport, /* Collection[SimpleCollection#0]: Collection[AImport] */ +&type_parser_nodes__AImport, /* Collection#0: AImport */ +&type_abstract_collection__Collectionparser_nodes__AImport, /* Collection[Collection#0]: Collection[AImport] */ +&type_parser_nodes__AImport, /* SequenceRead#0: AImport */ +} +}; +/* runtime type Collection[AImport] */ +const struct type type_abstract_collection__Collectionparser_nodes__AImport = { +1984, +"Collection[AImport]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +1984, /* Collection[AImport] */ +}, +}; +/* runtime type MVisibility */ +const struct type type_model_base__MVisibility = { +248, +"MVisibility", /* class_name_string */ +2, +0, +&resolution_table_model_base__MVisibility, +3, +{ +0, /* nullable Object */ +1, /* Object */ +248, /* MVisibility */ +}, +}; +const struct types resolution_table_model_base__MVisibility = { +0, /* dummy */ +{ +&type_model_base__MVisibility, /* OTHER: MVisibility */ +} +}; +/* runtime type SimpleMiscVisitor */ +const struct type type_simple_misc_analysis__SimpleMiscVisitor = { +249, +"SimpleMiscVisitor", /* class_name_string */ +2, +0, +&resolution_table_simple_misc_analysis__SimpleMiscVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +249, /* SimpleMiscVisitor */ +}, +}; +const struct types resolution_table_simple_misc_analysis__SimpleMiscVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type LiteralVisitor */ +const struct type type_literal__LiteralVisitor = { +250, +"LiteralVisitor", /* class_name_string */ +2, +0, +&resolution_table_literal__LiteralVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +250, /* LiteralVisitor */ +}, +}; +const struct types resolution_table_literal__LiteralVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type HashMap[MClass, MClassType] */ +const struct type type_hash_collection__HashMapmodel__MClassmodel__MClassType = { +251, +"HashMap[MClass, MClassType]", /* class_name_string */ +2, +0, +&resolution_table_hash_collection__HashMapmodel__MClassmodel__MClassType, +3, +{ +0, /* nullable Object */ +1, /* Object */ +251, /* HashMap[MClass, MClassType] */ +}, +}; +const struct types resolution_table_hash_collection__HashMapmodel__MClassmodel__MClassType = { +0, /* dummy */ +{ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_hash_collection__HashMapKeysmodel__MClassmodel__MClassType, /* HashMapKeys[HashMap#0, HashMap#1]: HashMapKeys[MClass, MClassType] */ +&type_hash_collection__HashMapValuesmodel__MClassmodel__MClassType, /* HashMapValues[HashMap#0, HashMap#1]: HashMapValues[MClass, MClassType] */ +&type_array__NativeArraynullable_hash_collection__HashMapNodemodel__MClassmodel__MClassType, /* NativeArray[ArrayCapable#0]: NativeArray[nullable HashMapNode[MClass, MClassType]] */ +&type_model__MClass, /* MapRead#0: MClass */ +&type_hash_collection__HashMapIteratormodel__MClassmodel__MClassType, /* HashMapIterator[HashMap#0, HashMap#1]: HashMapIterator[MClass, MClassType] */ +&type_model__MClass, /* Map#0: MClass */ +&type_model__MClassType, /* Map#1: MClassType */ +&type_hash_collection__HashMapNodemodel__MClassmodel__MClassType, /* HashMapNode[HashMap#0, HashMap#1]: HashMapNode[MClass, MClassType] */ +NULL, /* empty (Map[Map#0, Map#1]: Map[MClass, MClassType] not a live type) */ +&type_model__MClassType, /* MapRead#1: MClassType */ +&type_model__MClass, /* HashCollection#0: MClass */ +&type_hash_collection__HashMapNodemodel__MClassmodel__MClassType, /* HashCollection#1: HashMapNode[MClass, MClassType] */ +} +}; +/* runtime type ArrayMap[MClass, AType] */ +const struct type type_array__ArrayMapmodel__MClassparser_nodes__AType = { +252, +"ArrayMap[MClass, AType]", /* class_name_string */ +2, +0, +&resolution_table_array__ArrayMapmodel__MClassparser_nodes__AType, +3, +{ +0, /* nullable Object */ +1, /* Object */ +252, /* ArrayMap[MClass, AType] */ +}, +}; +const struct types resolution_table_array__ArrayMapmodel__MClassparser_nodes__AType = { +0, /* dummy */ +{ +&type_array__ArrayMapKeysmodel__MClassparser_nodes__AType, /* ArrayMapKeys[ArrayMap#0, ArrayMap#1]: ArrayMapKeys[MClass, AType] */ +&type_array__ArrayMapValuesmodel__MClassparser_nodes__AType, /* ArrayMapValues[ArrayMap#0, ArrayMap#1]: ArrayMapValues[MClass, AType] */ +&type_abstract_collection__Couplemodel__MClassparser_nodes__AType, /* Couple[ArrayMap#0, ArrayMap#1]: Couple[MClass, AType] */ +&type_abstract_collection__CoupleMapIteratormodel__MClassparser_nodes__AType, /* CoupleMapIterator[ArrayMap#0, ArrayMap#1]: CoupleMapIterator[MClass, AType] */ +&type_model__MClass, /* CoupleMap#0: MClass */ +&type_model__MClass, /* ArrayMap#0: MClass */ +&type_array__Arrayabstract_collection__Couplemodel__MClassparser_nodes__AType, /* Array[Couple[ArrayMap#0, ArrayMap#1]]: Array[Couple[MClass, AType]] */ +&type_model__MClass, /* MapRead#0: MClass */ +NULL, /* empty */ +&type_model__MClass, /* Map#0: MClass */ +&type_parser_nodes__AType, /* Map#1: AType */ +NULL, /* empty */ +NULL, /* empty (Map[Map#0, Map#1]: Map[MClass, AType] not a live type) */ +&type_parser_nodes__AType, /* MapRead#1: AType */ +} +}; +/* runtime type ScopeVisitor */ +const struct type type_scope__ScopeVisitor = { +253, +"ScopeVisitor", /* class_name_string */ +2, +0, +&resolution_table_scope__ScopeVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +253, /* ScopeVisitor */ +}, +}; +const struct types resolution_table_scope__ScopeVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type Variable */ +const struct type type_scope__Variable = { +254, +"Variable", /* class_name_string */ +2, +0, +&resolution_table_scope__Variable, +3, +{ +0, /* nullable Object */ +1, /* Object */ +254, /* Variable */ +}, +}; +const struct types resolution_table_scope__Variable = { +0, /* dummy */ +{ +} +}; +/* runtime type List[Scope] */ +const struct type type_list__Listscope__Scope = { +1985, +"List[Scope]", /* class_name_string */ +5, +0, +&resolution_table_list__Listscope__Scope, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1469, /* Collection[Scope] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1985, /* List[Scope] */ +}, +}; +const struct types resolution_table_list__Listscope__Scope = { +0, /* dummy */ +{ +&type_list__Listscope__Scope, /* List[List#0]: List[Scope] */ +&type_list__ListNodescope__Scope, /* ListNode[List#0]: ListNode[Scope] */ +&type_scope__Scope, /* Sequence#0: Scope */ +&type_scope__Scope, /* SimpleCollection#0: Scope */ +&type_list__ListIteratorscope__Scope, /* ListIterator[List#0]: ListIterator[Scope] */ +&type_abstract_collection__Collectionscope__Scope, /* Collection[List#0]: Collection[Scope] */ +&type_scope__Scope, /* List#0: Scope */ +NULL, /* empty */ +&type_scope__Scope, /* RemovableCollection#0: Scope */ +&type_abstract_collection__Collectionscope__Scope, /* Collection[Sequence#0]: Collection[Scope] */ +&type_array__Arrayscope__Scope, /* Array[Sequence#0]: Array[Scope] */ +&type_abstract_collection__Collectionscope__Scope, /* Collection[SimpleCollection#0]: Collection[Scope] */ +&type_scope__Scope, /* Collection#0: Scope */ +&type_abstract_collection__Collectionscope__Scope, /* Collection[Collection#0]: Collection[Scope] */ +&type_scope__Scope, /* SequenceRead#0: Scope */ +} +}; +/* runtime type Collection[Scope] */ +const struct type type_abstract_collection__Collectionscope__Scope = { +1469, +"Collection[Scope]", /* class_name_string */ +2, +0, +NULL, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1469, /* Collection[Scope] */ +-1, /* empty */ +166, /* Collection[Object] */ +}, +}; +/* runtime type FlowVisitor */ +const struct type type_flow__FlowVisitor = { +255, +"FlowVisitor", /* class_name_string */ +2, +0, +&resolution_table_flow__FlowVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +255, /* FlowVisitor */ +}, +}; +const struct types resolution_table_flow__FlowVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type Array[FlowContext] */ +const struct type type_array__Arrayflow__FlowContext = { +2567, +"Array[FlowContext]", /* class_name_string */ +7, +0, +&resolution_table_array__Arrayflow__FlowContext, +10, +{ +0, /* nullable Object */ +1, /* Object */ +1470, /* Collection[FlowContext] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +2280, /* AbstractArrayRead[FlowContext] */ +1778, /* AbstractArrayRead[Object] */ +2567, /* Array[FlowContext] */ +-1, /* empty */ +1962, /* Array[Object] */ +}, +}; +const struct types resolution_table_array__Arrayflow__FlowContext = { +0, /* dummy */ +{ +&type_array__Arrayflow__FlowContext, /* Array[Array#0]: Array[FlowContext] */ +&type_array__NativeArrayflow__FlowContext, /* NativeArray[Array#0]: NativeArray[FlowContext] */ +&type_flow__FlowContext, /* Sequence#0: FlowContext */ +&type_flow__FlowContext, /* SimpleCollection#0: FlowContext */ +&type_abstract_collection__Collectionflow__FlowContext, /* Collection[Array#0]: Collection[FlowContext] */ +&type_flow__FlowContext, /* Array#0: FlowContext */ +&type_array__NativeArrayflow__FlowContext, /* NativeArray[ArrayCapable#0]: NativeArray[FlowContext] */ +&type_flow__FlowContext, /* AbstractArray#0: FlowContext */ +&type_flow__FlowContext, /* RemovableCollection#0: FlowContext */ +&type_abstract_collection__Collectionflow__FlowContext, /* Collection[Sequence#0]: Collection[FlowContext] */ +&type_array__Arrayflow__FlowContext, /* Array[Sequence#0]: Array[FlowContext] */ +&type_abstract_collection__Collectionflow__FlowContext, /* Collection[SimpleCollection#0]: Collection[FlowContext] */ +&type_flow__FlowContext, /* Collection#0: FlowContext */ +&type_abstract_collection__Collectionflow__FlowContext, /* Collection[Collection#0]: Collection[FlowContext] */ +&type_flow__FlowContext, /* SequenceRead#0: FlowContext */ +&type_flow__FlowContext, /* AbstractArrayRead#0: FlowContext */ +&type_array__Arrayflow__FlowContext, /* Array[AbstractArrayRead#0]: Array[FlowContext] */ +NULL, /* empty (AbstractArray[AbstractArrayRead#0]: AbstractArray[FlowContext] not a live type) */ +&type_array__ArrayIteratorflow__FlowContext, /* ArrayIterator[AbstractArrayRead#0]: ArrayIterator[FlowContext] */ +} +}; +/* runtime type Collection[FlowContext] */ +const struct type type_abstract_collection__Collectionflow__FlowContext = { +1470, +"Collection[FlowContext]", /* class_name_string */ +2, +0, +NULL, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1470, /* Collection[FlowContext] */ +-1, /* empty */ +166, /* Collection[Object] */ +}, +}; +/* runtime type AbstractArrayRead[FlowContext] */ +const struct type type_array__AbstractArrayReadflow__FlowContext = { +2280, +"AbstractArrayRead[FlowContext]", /* class_name_string */ +5, +0, +NULL, +7, +{ +0, /* nullable Object */ +1, /* Object */ +1470, /* Collection[FlowContext] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +2280, /* AbstractArrayRead[FlowContext] */ +1778, /* AbstractArrayRead[Object] */ +}, +}; +/* runtime type LocalVarInitVisitor */ +const struct type type_local_var_init__LocalVarInitVisitor = { +256, +"LocalVarInitVisitor", /* class_name_string */ +2, +0, +&resolution_table_local_var_init__LocalVarInitVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +256, /* LocalVarInitVisitor */ +}, +}; +const struct types resolution_table_local_var_init__LocalVarInitVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type HashSet[Variable] */ +const struct type type_hash_collection__HashSetscope__Variable = { +2281, +"HashSet[Variable]", /* class_name_string */ +5, +0, +&resolution_table_hash_collection__HashSetscope__Variable, +7, +{ +0, /* nullable Object */ +1, /* Object */ +1471, /* Collection[Variable] */ +599, /* Set[Object] */ +166, /* Collection[Object] */ +2281, /* HashSet[Variable] */ +1790, /* HashSet[Object] */ +}, +}; +const struct types resolution_table_hash_collection__HashSetscope__Variable = { +0, /* dummy */ +{ +&type_hash_collection__HashSetNodescope__Variable, /* HashSetNode[HashSet#0]: HashSetNode[Variable] */ +&type_hash_collection__HashSetIteratorscope__Variable, /* HashSetIterator[HashSet#0]: HashSetIterator[Variable] */ +&type_abstract_collection__Collectionscope__Variable, /* Collection[HashSet#0]: Collection[Variable] */ +&type_scope__Variable, /* SimpleCollection#0: Variable */ +&type_abstract_collection__Collectionscope__Variable, /* Collection[Set#0]: Collection[Variable] */ +NULL, /* empty */ +&type_array__NativeArraynullable_hash_collection__HashSetNodescope__Variable, /* NativeArray[ArrayCapable#0]: NativeArray[nullable HashSetNode[Variable]] */ +NULL, /* empty */ +&type_scope__Variable, /* RemovableCollection#0: Variable */ +NULL, /* empty */ +NULL, /* empty */ +&type_abstract_collection__Collectionscope__Variable, /* Collection[SimpleCollection#0]: Collection[Variable] */ +&type_scope__Variable, /* Collection#0: Variable */ +&type_abstract_collection__Collectionscope__Variable, /* Collection[Collection#0]: Collection[Variable] */ +&type_scope__Variable, /* HashCollection#0: Variable */ +&type_hash_collection__HashSetNodescope__Variable, /* HashCollection#1: HashSetNode[Variable] */ +} +}; +/* runtime type Collection[Variable] */ +const struct type type_abstract_collection__Collectionscope__Variable = { +1471, +"Collection[Variable]", /* class_name_string */ +2, +0, +NULL, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1471, /* Collection[Variable] */ +-1, /* empty */ +166, /* Collection[Object] */ +}, +}; +/* runtime type AutoSuperInitVisitor */ +const struct type type_auto_super_init__AutoSuperInitVisitor = { +257, +"AutoSuperInitVisitor", /* class_name_string */ +2, +0, +&resolution_table_auto_super_init__AutoSuperInitVisitor, +3, +{ +0, /* nullable Object */ +1, /* Object */ +257, /* AutoSuperInitVisitor */ +}, +}; +const struct types resolution_table_auto_super_init__AutoSuperInitVisitor = { +0, /* dummy */ +{ +} +}; +/* runtime type Array[MMethod] */ +const struct type type_array__Arraymodel__MMethod = { +2702, +"Array[MMethod]", /* class_name_string */ +17, +0, +&resolution_table_array__Arraymodel__MMethod, +18, +{ +0, /* nullable Object */ +1, /* Object */ +174, /* Collection[nullable MProperty] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +592, /* Collection[PropertyLayoutElement] */ +1778, /* AbstractArrayRead[Object] */ +1785, /* AbstractArrayRead[nullable MProperty] */ +1964, /* Array[nullable MProperty] */ +1962, /* Array[Object] */ +1965, /* Collection[MProperty] */ +2253, /* AbstractArrayRead[PropertyLayoutElement] */ +2262, /* Collection[MMethod] */ +2547, /* Array[PropertyLayoutElement] */ +2618, /* AbstractArrayRead[MProperty] */ +2664, /* AbstractArrayRead[MMethod] */ +2675, /* Array[MProperty] */ +2702, /* Array[MMethod] */ +}, +}; +const struct types resolution_table_array__Arraymodel__MMethod = { +0, /* dummy */ +{ +&type_array__Arraymodel__MMethod, /* Array[Array#0]: Array[MMethod] */ +&type_array__NativeArraymodel__MMethod, /* NativeArray[Array#0]: NativeArray[MMethod] */ +&type_model__MMethod, /* Sequence#0: MMethod */ +&type_model__MMethod, /* SimpleCollection#0: MMethod */ +&type_abstract_collection__Collectionmodel__MMethod, /* Collection[Array#0]: Collection[MMethod] */ +&type_model__MMethod, /* Array#0: MMethod */ +&type_array__NativeArraymodel__MMethod, /* NativeArray[ArrayCapable#0]: NativeArray[MMethod] */ +&type_model__MMethod, /* AbstractArray#0: MMethod */ +&type_model__MMethod, /* RemovableCollection#0: MMethod */ +&type_abstract_collection__Collectionmodel__MMethod, /* Collection[Sequence#0]: Collection[MMethod] */ +&type_array__Arraymodel__MMethod, /* Array[Sequence#0]: Array[MMethod] */ +&type_abstract_collection__Collectionmodel__MMethod, /* Collection[SimpleCollection#0]: Collection[MMethod] */ +&type_model__MMethod, /* Collection#0: MMethod */ +&type_abstract_collection__Collectionmodel__MMethod, /* Collection[Collection#0]: Collection[MMethod] */ +&type_model__MMethod, /* SequenceRead#0: MMethod */ +&type_model__MMethod, /* AbstractArrayRead#0: MMethod */ +&type_array__Arraymodel__MMethod, /* Array[AbstractArrayRead#0]: Array[MMethod] */ +NULL, /* empty (AbstractArray[AbstractArrayRead#0]: AbstractArray[MMethod] not a live type) */ +&type_array__ArrayIteratormodel__MMethod, /* ArrayIterator[AbstractArrayRead#0]: ArrayIterator[MMethod] */ +} +}; +/* runtime type AbstractArrayRead[MMethod] */ +const struct type type_array__AbstractArrayReadmodel__MMethod = { +2664, +"AbstractArrayRead[MMethod]", /* class_name_string */ +15, +0, +NULL, +16, +{ +0, /* nullable Object */ +1, /* Object */ +174, /* Collection[nullable MProperty] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +592, /* Collection[PropertyLayoutElement] */ +1778, /* AbstractArrayRead[Object] */ +1785, /* AbstractArrayRead[nullable MProperty] */ +-1, /* empty */ +-1, /* empty */ +1965, /* Collection[MProperty] */ +2253, /* AbstractArrayRead[PropertyLayoutElement] */ +2262, /* Collection[MMethod] */ +-1, /* empty */ +2618, /* AbstractArrayRead[MProperty] */ +2664, /* AbstractArrayRead[MMethod] */ +}, +}; +/* runtime type ASTBuilder */ +const struct type type_astbuilder__ASTBuilder = { +258, +"ASTBuilder", /* class_name_string */ +2, +0, +&resolution_table_astbuilder__ASTBuilder, +3, +{ +0, /* nullable Object */ +1, /* Object */ +258, /* ASTBuilder */ +}, +}; +const struct types resolution_table_astbuilder__ASTBuilder = { +0, /* dummy */ +{ +} +}; +/* runtime type Array[MParameterType] */ +const struct type type_array__Arraymodel__MParameterType = { +2700, +"Array[MParameterType]", /* class_name_string */ +14, +0, +&resolution_table_array__Arraymodel__MParameterType, +16, +{ +0, /* nullable Object */ +1, /* Object */ +4, /* nullable Array[nullable MType] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +175, /* Collection[nullable MType] */ +1778, /* AbstractArrayRead[Object] */ +1787, /* Collection[MType] */ +1794, /* AbstractArrayRead[nullable MType] */ +1962, /* Array[Object] */ +1986, /* Collection[MParameterType] */ +2266, /* Array[nullable MType] */ +2625, /* AbstractArrayRead[MParameterType] */ +2561, /* AbstractArrayRead[MType] */ +2700, /* Array[MParameterType] */ +2662, /* Array[MType] */ +}, +}; +const struct types resolution_table_array__Arraymodel__MParameterType = { +0, /* dummy */ +{ +&type_array__Arraymodel__MParameterType, /* Array[Array#0]: Array[MParameterType] */ +&type_array__NativeArraymodel__MParameterType, /* NativeArray[Array#0]: NativeArray[MParameterType] */ +&type_model__MParameterType, /* Sequence#0: MParameterType */ +&type_model__MParameterType, /* SimpleCollection#0: MParameterType */ +&type_abstract_collection__Collectionmodel__MParameterType, /* Collection[Array#0]: Collection[MParameterType] */ +&type_model__MParameterType, /* Array#0: MParameterType */ +&type_array__NativeArraymodel__MParameterType, /* NativeArray[ArrayCapable#0]: NativeArray[MParameterType] */ +&type_model__MParameterType, /* AbstractArray#0: MParameterType */ +&type_model__MParameterType, /* RemovableCollection#0: MParameterType */ +&type_abstract_collection__Collectionmodel__MParameterType, /* Collection[Sequence#0]: Collection[MParameterType] */ +&type_array__Arraymodel__MParameterType, /* Array[Sequence#0]: Array[MParameterType] */ +&type_abstract_collection__Collectionmodel__MParameterType, /* Collection[SimpleCollection#0]: Collection[MParameterType] */ +&type_model__MParameterType, /* Collection#0: MParameterType */ +&type_abstract_collection__Collectionmodel__MParameterType, /* Collection[Collection#0]: Collection[MParameterType] */ +&type_model__MParameterType, /* SequenceRead#0: MParameterType */ +&type_model__MParameterType, /* AbstractArrayRead#0: MParameterType */ +&type_array__Arraymodel__MParameterType, /* Array[AbstractArrayRead#0]: Array[MParameterType] */ +NULL, /* empty (AbstractArray[AbstractArrayRead#0]: AbstractArray[MParameterType] not a live type) */ +&type_array__ArrayIteratormodel__MParameterType, /* ArrayIterator[AbstractArrayRead#0]: ArrayIterator[MParameterType] */ +} +}; +/* runtime type Collection[MParameterType] */ +const struct type type_abstract_collection__Collectionmodel__MParameterType = { +1986, +"Collection[MParameterType]", /* class_name_string */ +10, +0, +NULL, +11, +{ +0, /* nullable Object */ +1, /* Object */ +-1, /* empty */ +-1, /* empty */ +166, /* Collection[Object] */ +175, /* Collection[nullable MType] */ +-1, /* empty */ +1787, /* Collection[MType] */ +-1, /* empty */ +-1, /* empty */ +1986, /* Collection[MParameterType] */ +}, +}; +/* runtime type AbstractArrayRead[MParameterType] */ +const struct type type_array__AbstractArrayReadmodel__MParameterType = { +2625, +"AbstractArrayRead[MParameterType]", /* class_name_string */ +12, +0, +NULL, +14, +{ +0, /* nullable Object */ +1, /* Object */ +-1, /* empty */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +175, /* Collection[nullable MType] */ +1778, /* AbstractArrayRead[Object] */ +1787, /* Collection[MType] */ +1794, /* AbstractArrayRead[nullable MType] */ +-1, /* empty */ +1986, /* Collection[MParameterType] */ +-1, /* empty */ +2625, /* AbstractArrayRead[MParameterType] */ +2561, /* AbstractArrayRead[MType] */ +}, +}; +/* runtime type MParameterType */ +const struct type type_model__MParameterType = { +1801, +"MParameterType", /* class_name_string */ +4, +0, +&resolution_table_model__MParameterType, +5, +{ +0, /* nullable Object */ +1, /* Object */ +2, /* nullable MType */ +596, /* MType */ +1801, /* MParameterType */ +}, +}; +const struct types resolution_table_model__MParameterType = { +0, /* dummy */ +{ +} +}; +/* runtime type POSet[MClass] */ +const struct type type_poset__POSetmodel__MClass = { +1987, +"POSet[MClass]", /* class_name_string */ +3, +0, +&resolution_table_poset__POSetmodel__MClass, +6, +{ +0, /* nullable Object */ +1, /* Object */ +173, /* Collection[nullable MClass] */ +1987, /* POSet[MClass] */ +166, /* Collection[Object] */ +1783, /* Collection[MClass] */ +}, +}; +const struct types resolution_table_poset__POSetmodel__MClass = { +0, /* dummy */ +{ +&type_model__MClass, /* AbstractSorter#0: MClass */ +&type_array__Arraymodel__MClass, /* Array[AbstractSorter#0]: Array[MClass] */ +&type_hash_collection__HashMapmodel__MClassposet__POSetElementmodel__MClass, /* HashMap[POSet#0, POSetElement[POSet#0]]: HashMap[MClass, POSetElement[MClass]] */ +&type_model__MClass, /* POSet#0: MClass */ +&type_poset__POSetElementmodel__MClass, /* POSetElement[POSet#0]: POSetElement[MClass] */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_model__MClass, /* Collection#0: MClass */ +&type_abstract_collection__Collectionmodel__MClass, /* Collection[Collection#0]: Collection[MClass] */ +} +}; +/* runtime type MClassDefSorter */ +const struct type type_model__MClassDefSorter = { +259, +"MClassDefSorter", /* class_name_string */ +2, +0, +&resolution_table_model__MClassDefSorter, +3, +{ +0, /* nullable Object */ +1, /* Object */ +259, /* MClassDefSorter */ +}, +}; +const struct types resolution_table_model__MClassDefSorter = { +0, /* dummy */ +{ +&type_model__MClassDef, /* AbstractSorter#0: MClassDef */ +&type_array__Arraymodel__MClassDef, /* Array[AbstractSorter#0]: Array[MClassDef] */ +} +}; +/* runtime type Frame */ +const struct type type_abstract_compiler__Frame = { +260, +"Frame", /* class_name_string */ +2, +0, +&resolution_table_abstract_compiler__Frame, +3, +{ +0, /* nullable Object */ +1, /* Object */ +260, /* Frame */ +}, +}; +const struct types resolution_table_abstract_compiler__Frame = { +0, /* dummy */ +{ +&type_abstract_compiler__AbstractCompilerVisitor, /* VISITOR: AbstractCompilerVisitor */ +} +}; +/* runtime type ArraySet[MType] */ +const struct type type_array__ArraySetmodel__MType = { +2471, +"ArraySet[MType]", /* class_name_string */ +6, +0, +&resolution_table_array__ArraySetmodel__MType, +8, +{ +0, /* nullable Object */ +1, /* Object */ +2259, /* Set[MType] */ +599, /* Set[Object] */ +166, /* Collection[Object] */ +175, /* Collection[nullable MType] */ +2471, /* ArraySet[MType] */ +1787, /* Collection[MType] */ +}, +}; +const struct types resolution_table_array__ArraySetmodel__MType = { +0, /* dummy */ +{ +&type_array__ArraySetIteratormodel__MType, /* ArraySetIterator[ArraySet#0]: ArraySetIterator[MType] */ +&type_array__Arraymodel__MType, /* Array[ArraySet#0]: Array[MType] */ +NULL, /* empty */ +&type_model__MType, /* SimpleCollection#0: MType */ +&type_abstract_collection__Collectionmodel__MType, /* Collection[Set#0]: Collection[MType] */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_model__MType, /* RemovableCollection#0: MType */ +NULL, /* empty */ +NULL, /* empty */ +&type_abstract_collection__Collectionmodel__MType, /* Collection[SimpleCollection#0]: Collection[MType] */ +&type_model__MType, /* Collection#0: MType */ +&type_abstract_collection__Collectionmodel__MType, /* Collection[Collection#0]: Collection[MType] */ +} +}; +/* runtime type MVirtualType */ +const struct type type_model__MVirtualType = { +1802, +"MVirtualType", /* class_name_string */ +4, +0, +&resolution_table_model__MVirtualType, +5, +{ +0, /* nullable Object */ +1, /* Object */ +2, /* nullable MType */ +596, /* MType */ +1802, /* MVirtualType */ +}, +}; +const struct types resolution_table_model__MVirtualType = { +0, /* dummy */ +{ +} +}; +/* runtime type Layout[MType] */ +const struct type type_layout_builders__Layoutmodel__MType = { +261, +"Layout[MType]", /* class_name_string */ +2, +0, +&resolution_table_layout_builders__Layoutmodel__MType, +3, +{ +0, /* nullable Object */ +1, /* Object */ +261, /* Layout[MType] */ +}, +}; +const struct types resolution_table_layout_builders__Layoutmodel__MType = { +0, /* dummy */ +{ +&type_hash_collection__HashMapmodel__MTypekernel__Int, /* HashMap[Layout#0, Int]: HashMap[MType, Int] */ +&type_abstract_collection__Mapmodel__MTypekernel__Int, /* Map[Layout#0, Int]: Map[MType, Int] */ +} +}; +/* runtime type PHLayout[MClassType, MType] */ +const struct type type_layout_builders__PHLayoutmodel__MClassTypemodel__MType = { +1803, +"PHLayout[MClassType, MType]", /* class_name_string */ +4, +0, +&resolution_table_layout_builders__PHLayoutmodel__MClassTypemodel__MType, +5, +{ +0, /* nullable Object */ +1, /* Object */ +261, /* Layout[MType] */ +1472, /* PHLayout[MType, MType] */ +1803, /* PHLayout[MClassType, MType] */ +}, +}; +const struct types resolution_table_layout_builders__PHLayoutmodel__MClassTypemodel__MType = { +0, /* dummy */ +{ +&type_hash_collection__HashMapmodel__MTypekernel__Int, /* HashMap[Layout#0, Int]: HashMap[MType, Int] */ +&type_abstract_collection__Mapmodel__MTypekernel__Int, /* Map[Layout#0, Int]: Map[MType, Int] */ +&type_hash_collection__HashMapmodel__MClassTypekernel__Int, /* HashMap[PHLayout#0, Int]: HashMap[MClassType, Int] */ +&type_hash_collection__HashMapmodel__MClassTypeabstract_collection__Mapmodel__MTypekernel__Int, /* HashMap[PHLayout#0, Map[PHLayout#1, Int]]: HashMap[MClassType, Map[MType, Int]] */ +&type_abstract_collection__Mapmodel__MClassTypekernel__Int, /* Map[PHLayout#0, Int]: Map[MClassType, Int] */ +&type_abstract_collection__Mapmodel__MClassTypeabstract_collection__Mapmodel__MTypekernel__Int, /* Map[PHLayout#0, Map[PHLayout#1, Int]]: Map[MClassType, Map[MType, Int]] */ +} +}; +/* runtime type PHLayout[MType, MType] */ +const struct type type_layout_builders__PHLayoutmodel__MTypemodel__MType = { +1472, +"PHLayout[MType, MType]", /* class_name_string */ +3, +0, +&resolution_table_layout_builders__PHLayoutmodel__MTypemodel__MType, +4, +{ +0, /* nullable Object */ +1, /* Object */ +261, /* Layout[MType] */ +1472, /* PHLayout[MType, MType] */ +}, +}; +const struct types resolution_table_layout_builders__PHLayoutmodel__MTypemodel__MType = { +0, /* dummy */ +{ +&type_hash_collection__HashMapmodel__MTypekernel__Int, /* HashMap[Layout#0, Int]: HashMap[MType, Int] */ +&type_abstract_collection__Mapmodel__MTypekernel__Int, /* Map[Layout#0, Int]: Map[MType, Int] */ +&type_hash_collection__HashMapmodel__MTypekernel__Int, /* HashMap[PHLayout#0, Int]: HashMap[MType, Int] */ +&type_hash_collection__HashMapmodel__MTypeabstract_collection__Mapmodel__MTypekernel__Int, /* HashMap[PHLayout#0, Map[PHLayout#1, Int]]: HashMap[MType, Map[MType, Int]] */ +&type_abstract_collection__Mapmodel__MTypekernel__Int, /* Map[PHLayout#0, Int]: Map[MType, Int] */ +&type_abstract_collection__Mapmodel__MTypeabstract_collection__Mapmodel__MTypekernel__Int, /* Map[PHLayout#0, Map[PHLayout#1, Int]]: Map[MType, Map[MType, Int]] */ +} +}; +/* runtime type AModule */ +const struct type type_parser_nodes__AModule = { +1804, +"AModule", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AModule, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1804, /* AModule */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AModule = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AExternCodeBlock] */ +const struct type type_parser_nodes__ANodesparser_nodes__AExternCodeBlock = { +2472, +"ANodes[AExternCodeBlock]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AExternCodeBlock, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2472, /* ANodes[AExternCodeBlock] */ +1988, /* Collection[AExternCodeBlock] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AExternCodeBlock = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AExternCodeBlock, /* Array[ANodes#0]: Array[AExternCodeBlock] */ +&type_parser_nodes__AExternCodeBlock, /* ANodes#0: AExternCodeBlock */ +&type_parser_nodes__AExternCodeBlock, /* Sequence#0: AExternCodeBlock */ +&type_parser_nodes__AExternCodeBlock, /* SimpleCollection#0: AExternCodeBlock */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AExternCodeBlock, /* RemovableCollection#0: AExternCodeBlock */ +&type_abstract_collection__Collectionparser_nodes__AExternCodeBlock, /* Collection[Sequence#0]: Collection[AExternCodeBlock] */ +&type_array__Arrayparser_nodes__AExternCodeBlock, /* Array[Sequence#0]: Array[AExternCodeBlock] */ +&type_abstract_collection__Collectionparser_nodes__AExternCodeBlock, /* Collection[SimpleCollection#0]: Collection[AExternCodeBlock] */ +&type_parser_nodes__AExternCodeBlock, /* Collection#0: AExternCodeBlock */ +&type_abstract_collection__Collectionparser_nodes__AExternCodeBlock, /* Collection[Collection#0]: Collection[AExternCodeBlock] */ +&type_parser_nodes__AExternCodeBlock, /* SequenceRead#0: AExternCodeBlock */ +} +}; +/* runtime type Collection[AExternCodeBlock] */ +const struct type type_abstract_collection__Collectionparser_nodes__AExternCodeBlock = { +1988, +"Collection[AExternCodeBlock]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +1988, /* Collection[AExternCodeBlock] */ +}, +}; +/* runtime type HashMap[MClass, AClassdef] */ +const struct type type_hash_collection__HashMapmodel__MClassparser_nodes__AClassdef = { +262, +"HashMap[MClass, AClassdef]", /* class_name_string */ +2, +0, +&resolution_table_hash_collection__HashMapmodel__MClassparser_nodes__AClassdef, +3, +{ +0, /* nullable Object */ +1, /* Object */ +262, /* HashMap[MClass, AClassdef] */ +}, +}; +const struct types resolution_table_hash_collection__HashMapmodel__MClassparser_nodes__AClassdef = { +0, /* dummy */ +{ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_hash_collection__HashMapKeysmodel__MClassparser_nodes__AClassdef, /* HashMapKeys[HashMap#0, HashMap#1]: HashMapKeys[MClass, AClassdef] */ +&type_hash_collection__HashMapValuesmodel__MClassparser_nodes__AClassdef, /* HashMapValues[HashMap#0, HashMap#1]: HashMapValues[MClass, AClassdef] */ +&type_array__NativeArraynullable_hash_collection__HashMapNodemodel__MClassparser_nodes__AClassdef, /* NativeArray[ArrayCapable#0]: NativeArray[nullable HashMapNode[MClass, AClassdef]] */ +&type_model__MClass, /* MapRead#0: MClass */ +&type_hash_collection__HashMapIteratormodel__MClassparser_nodes__AClassdef, /* HashMapIterator[HashMap#0, HashMap#1]: HashMapIterator[MClass, AClassdef] */ +&type_model__MClass, /* Map#0: MClass */ +&type_parser_nodes__AClassdef, /* Map#1: AClassdef */ +&type_hash_collection__HashMapNodemodel__MClassparser_nodes__AClassdef, /* HashMapNode[HashMap#0, HashMap#1]: HashMapNode[MClass, AClassdef] */ +NULL, /* empty (Map[Map#0, Map#1]: Map[MClass, AClassdef] not a live type) */ +&type_parser_nodes__AClassdef, /* MapRead#1: AClassdef */ +&type_model__MClass, /* HashCollection#0: MClass */ +&type_hash_collection__HashMapNodemodel__MClassparser_nodes__AClassdef, /* HashCollection#1: HashMapNode[MClass, AClassdef] */ +} +}; +/* runtime type ATopClassdef */ +const struct type type_parser_nodes__ATopClassdef = { +2282, +"ATopClassdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ATopClassdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +6, /* nullable AClassdef */ +225, /* ANode */ +624, /* Prod */ +1989, /* AClassdef */ +2282, /* ATopClassdef */ +}, +}; +const struct types resolution_table_parser_nodes__ATopClassdef = { +0, /* dummy */ +{ +} +}; +/* runtime type AClassdef */ +const struct type type_parser_nodes__AClassdef = { +1989, +"AClassdef", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +6, /* nullable AClassdef */ +225, /* ANode */ +624, /* Prod */ +1989, /* AClassdef */ +}, +}; +/* runtime type nullable AClassdef */ +const struct type type_nullable_parser_nodes__AClassdef = { +6, +"nullable AClassdef", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +6, /* nullable AClassdef */ +}, +}; +/* runtime type HashMap[MProperty, APropdef] */ +const struct type type_hash_collection__HashMapmodel__MPropertyparser_nodes__APropdef = { +263, +"HashMap[MProperty, APropdef]", /* class_name_string */ +2, +0, +&resolution_table_hash_collection__HashMapmodel__MPropertyparser_nodes__APropdef, +3, +{ +0, /* nullable Object */ +1, /* Object */ +263, /* HashMap[MProperty, APropdef] */ +}, +}; +const struct types resolution_table_hash_collection__HashMapmodel__MPropertyparser_nodes__APropdef = { +0, /* dummy */ +{ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_hash_collection__HashMapKeysmodel__MPropertyparser_nodes__APropdef, /* HashMapKeys[HashMap#0, HashMap#1]: HashMapKeys[MProperty, APropdef] */ +&type_hash_collection__HashMapValuesmodel__MPropertyparser_nodes__APropdef, /* HashMapValues[HashMap#0, HashMap#1]: HashMapValues[MProperty, APropdef] */ +&type_array__NativeArraynullable_hash_collection__HashMapNodemodel__MPropertyparser_nodes__APropdef, /* NativeArray[ArrayCapable#0]: NativeArray[nullable HashMapNode[MProperty, APropdef]] */ +&type_model__MProperty, /* MapRead#0: MProperty */ +&type_hash_collection__HashMapIteratormodel__MPropertyparser_nodes__APropdef, /* HashMapIterator[HashMap#0, HashMap#1]: HashMapIterator[MProperty, APropdef] */ +&type_model__MProperty, /* Map#0: MProperty */ +&type_parser_nodes__APropdef, /* Map#1: APropdef */ +&type_hash_collection__HashMapNodemodel__MPropertyparser_nodes__APropdef, /* HashMapNode[HashMap#0, HashMap#1]: HashMapNode[MProperty, APropdef] */ +NULL, /* empty (Map[Map#0, Map#1]: Map[MProperty, APropdef] not a live type) */ +&type_parser_nodes__APropdef, /* MapRead#1: APropdef */ +&type_model__MProperty, /* HashCollection#0: MProperty */ +&type_hash_collection__HashMapNodemodel__MPropertyparser_nodes__APropdef, /* HashCollection#1: HashMapNode[MProperty, APropdef] */ +} +}; +/* runtime type AModuledecl */ +const struct type type_parser_nodes__AModuledecl = { +1990, +"AModuledecl", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AModuledecl, +6, +{ +0, /* nullable Object */ +1, /* Object */ +7, /* nullable AModuledecl */ +225, /* ANode */ +624, /* Prod */ +1990, /* AModuledecl */ +}, +}; +const struct types resolution_table_parser_nodes__AModuledecl = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AModuledecl */ +const struct type type_nullable_parser_nodes__AModuledecl = { +7, +"nullable AModuledecl", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AModuledecl, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +7, /* nullable AModuledecl */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AModuledecl = { +0, /* dummy */ +{ +} +}; +/* runtime type AStdImport */ +const struct type type_parser_nodes__AStdImport = { +1991, +"AStdImport", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AStdImport, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1805, /* AImport */ +225, /* ANode */ +624, /* Prod */ +1991, /* AStdImport */ +}, +}; +const struct types resolution_table_parser_nodes__AStdImport = { +0, /* dummy */ +{ +} +}; +/* runtime type AImport */ +const struct type type_parser_nodes__AImport = { +1805, +"AImport", /* class_name_string */ +2, +0, +NULL, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1805, /* AImport */ +225, /* ANode */ +624, /* Prod */ +}, +}; +/* runtime type ANoImport */ +const struct type type_parser_nodes__ANoImport = { +1992, +"ANoImport", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__ANoImport, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1805, /* AImport */ +225, /* ANode */ +624, /* Prod */ +1992, /* ANoImport */ +}, +}; +const struct types resolution_table_parser_nodes__ANoImport = { +0, /* dummy */ +{ +} +}; +/* runtime type AMainClassdef */ +const struct type type_parser_nodes__AMainClassdef = { +2283, +"AMainClassdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AMainClassdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +6, /* nullable AClassdef */ +225, /* ANode */ +624, /* Prod */ +1989, /* AClassdef */ +2283, /* AMainClassdef */ +}, +}; +const struct types resolution_table_parser_nodes__AMainClassdef = { +0, /* dummy */ +{ +} +}; +/* runtime type AMainMethPropdef */ +const struct type type_parser_nodes__AMainMethPropdef = { +2473, +"AMainMethPropdef", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AMainMethPropdef, +8, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2284, /* AConcreteMethPropdef */ +2473, /* AMainMethPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AMainMethPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AConcreteMethPropdef */ +const struct type type_parser_nodes__AConcreteMethPropdef = { +2284, +"AConcreteMethPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AConcreteMethPropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2284, /* AConcreteMethPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AConcreteMethPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type APropdef */ +const struct type type_parser_nodes__APropdef = { +1993, +"APropdef", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +}, +}; +/* runtime type nullable APropdef */ +const struct type type_nullable_parser_nodes__APropdef = { +8, +"nullable APropdef", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +8, /* nullable APropdef */ +}, +}; +/* runtime type AStdClassdef */ +const struct type type_parser_nodes__AStdClassdef = { +2285, +"AStdClassdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AStdClassdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +6, /* nullable AClassdef */ +225, /* ANode */ +624, /* Prod */ +1989, /* AClassdef */ +2285, /* AStdClassdef */ +}, +}; +const struct types resolution_table_parser_nodes__AStdClassdef = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AFormaldef] */ +const struct type type_parser_nodes__ANodesparser_nodes__AFormaldef = { +2474, +"ANodes[AFormaldef]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AFormaldef, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2474, /* ANodes[AFormaldef] */ +1994, /* Collection[AFormaldef] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AFormaldef = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AFormaldef, /* Array[ANodes#0]: Array[AFormaldef] */ +&type_parser_nodes__AFormaldef, /* ANodes#0: AFormaldef */ +&type_parser_nodes__AFormaldef, /* Sequence#0: AFormaldef */ +&type_parser_nodes__AFormaldef, /* SimpleCollection#0: AFormaldef */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AFormaldef, /* RemovableCollection#0: AFormaldef */ +&type_abstract_collection__Collectionparser_nodes__AFormaldef, /* Collection[Sequence#0]: Collection[AFormaldef] */ +&type_array__Arrayparser_nodes__AFormaldef, /* Array[Sequence#0]: Array[AFormaldef] */ +&type_abstract_collection__Collectionparser_nodes__AFormaldef, /* Collection[SimpleCollection#0]: Collection[AFormaldef] */ +&type_parser_nodes__AFormaldef, /* Collection#0: AFormaldef */ +&type_abstract_collection__Collectionparser_nodes__AFormaldef, /* Collection[Collection#0]: Collection[AFormaldef] */ +&type_parser_nodes__AFormaldef, /* SequenceRead#0: AFormaldef */ +} +}; +/* runtime type Collection[AFormaldef] */ +const struct type type_abstract_collection__Collectionparser_nodes__AFormaldef = { +1994, +"Collection[AFormaldef]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +1994, /* Collection[AFormaldef] */ +}, +}; +/* runtime type ANodes[ASuperclass] */ +const struct type type_parser_nodes__ANodesparser_nodes__ASuperclass = { +2475, +"ANodes[ASuperclass]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__ASuperclass, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2475, /* ANodes[ASuperclass] */ +1995, /* Collection[ASuperclass] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__ASuperclass = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__ASuperclass, /* Array[ANodes#0]: Array[ASuperclass] */ +&type_parser_nodes__ASuperclass, /* ANodes#0: ASuperclass */ +&type_parser_nodes__ASuperclass, /* Sequence#0: ASuperclass */ +&type_parser_nodes__ASuperclass, /* SimpleCollection#0: ASuperclass */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__ASuperclass, /* RemovableCollection#0: ASuperclass */ +&type_abstract_collection__Collectionparser_nodes__ASuperclass, /* Collection[Sequence#0]: Collection[ASuperclass] */ +&type_array__Arrayparser_nodes__ASuperclass, /* Array[Sequence#0]: Array[ASuperclass] */ +&type_abstract_collection__Collectionparser_nodes__ASuperclass, /* Collection[SimpleCollection#0]: Collection[ASuperclass] */ +&type_parser_nodes__ASuperclass, /* Collection#0: ASuperclass */ +&type_abstract_collection__Collectionparser_nodes__ASuperclass, /* Collection[Collection#0]: Collection[ASuperclass] */ +&type_parser_nodes__ASuperclass, /* SequenceRead#0: ASuperclass */ +} +}; +/* runtime type Collection[ASuperclass] */ +const struct type type_abstract_collection__Collectionparser_nodes__ASuperclass = { +1995, +"Collection[ASuperclass]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +1995, /* Collection[ASuperclass] */ +}, +}; +/* runtime type AAnnotations */ +const struct type type_parser_nodes__AAnnotations = { +1996, +"AAnnotations", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AAnnotations, +6, +{ +0, /* nullable Object */ +1, /* Object */ +9, /* nullable AAnnotations */ +225, /* ANode */ +624, /* Prod */ +1996, /* AAnnotations */ +}, +}; +const struct types resolution_table_parser_nodes__AAnnotations = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AAnnotations */ +const struct type type_nullable_parser_nodes__AAnnotations = { +9, +"nullable AAnnotations", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AAnnotations, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +9, /* nullable AAnnotations */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AAnnotations = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AAnnotation] */ +const struct type type_parser_nodes__ANodesparser_nodes__AAnnotation = { +2476, +"ANodes[AAnnotation]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AAnnotation, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2476, /* ANodes[AAnnotation] */ +1997, /* Collection[AAnnotation] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AAnnotation = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AAnnotation, /* Array[ANodes#0]: Array[AAnnotation] */ +&type_parser_nodes__AAnnotation, /* ANodes#0: AAnnotation */ +&type_parser_nodes__AAnnotation, /* Sequence#0: AAnnotation */ +&type_parser_nodes__AAnnotation, /* SimpleCollection#0: AAnnotation */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AAnnotation, /* RemovableCollection#0: AAnnotation */ +&type_abstract_collection__Collectionparser_nodes__AAnnotation, /* Collection[Sequence#0]: Collection[AAnnotation] */ +&type_array__Arrayparser_nodes__AAnnotation, /* Array[Sequence#0]: Array[AAnnotation] */ +&type_abstract_collection__Collectionparser_nodes__AAnnotation, /* Collection[SimpleCollection#0]: Collection[AAnnotation] */ +&type_parser_nodes__AAnnotation, /* Collection#0: AAnnotation */ +&type_abstract_collection__Collectionparser_nodes__AAnnotation, /* Collection[Collection#0]: Collection[AAnnotation] */ +&type_parser_nodes__AAnnotation, /* SequenceRead#0: AAnnotation */ +} +}; +/* runtime type Collection[AAnnotation] */ +const struct type type_abstract_collection__Collectionparser_nodes__AAnnotation = { +1997, +"Collection[AAnnotation]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +1997, /* Collection[AAnnotation] */ +}, +}; +/* runtime type AConcreteClasskind */ +const struct type type_parser_nodes__AConcreteClasskind = { +2286, +"AConcreteClasskind", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AConcreteClasskind, +7, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +2286, /* AConcreteClasskind */ +}, +}; +const struct types resolution_table_parser_nodes__AConcreteClasskind = { +0, /* dummy */ +{ +} +}; +/* runtime type AClasskind */ +const struct type type_parser_nodes__AClasskind = { +1998, +"AClasskind", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +}, +}; +/* runtime type nullable AClasskind */ +const struct type type_nullable_parser_nodes__AClasskind = { +10, +"nullable AClasskind", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +10, /* nullable AClasskind */ +}, +}; +/* runtime type AAbstractClasskind */ +const struct type type_parser_nodes__AAbstractClasskind = { +2287, +"AAbstractClasskind", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAbstractClasskind, +7, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +2287, /* AAbstractClasskind */ +}, +}; +const struct types resolution_table_parser_nodes__AAbstractClasskind = { +0, /* dummy */ +{ +} +}; +/* runtime type AInterfaceClasskind */ +const struct type type_parser_nodes__AInterfaceClasskind = { +2288, +"AInterfaceClasskind", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AInterfaceClasskind, +7, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +2288, /* AInterfaceClasskind */ +}, +}; +const struct types resolution_table_parser_nodes__AInterfaceClasskind = { +0, /* dummy */ +{ +} +}; +/* runtime type AEnumClasskind */ +const struct type type_parser_nodes__AEnumClasskind = { +2289, +"AEnumClasskind", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AEnumClasskind, +7, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +2289, /* AEnumClasskind */ +}, +}; +const struct types resolution_table_parser_nodes__AEnumClasskind = { +0, /* dummy */ +{ +} +}; +/* runtime type AExternClasskind */ +const struct type type_parser_nodes__AExternClasskind = { +2290, +"AExternClasskind", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AExternClasskind, +7, +{ +0, /* nullable Object */ +1, /* Object */ +10, /* nullable AClasskind */ +225, /* ANode */ +624, /* Prod */ +1998, /* AClasskind */ +2290, /* AExternClasskind */ +}, +}; +const struct types resolution_table_parser_nodes__AExternClasskind = { +0, /* dummy */ +{ +} +}; +/* runtime type AFormaldef */ +const struct type type_parser_nodes__AFormaldef = { +1806, +"AFormaldef", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AFormaldef, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1806, /* AFormaldef */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AFormaldef = { +0, /* dummy */ +{ +} +}; +/* runtime type ASuperclass */ +const struct type type_parser_nodes__ASuperclass = { +1807, +"ASuperclass", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__ASuperclass, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1807, /* ASuperclass */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__ASuperclass = { +0, /* dummy */ +{ +} +}; +/* runtime type ADeferredMethPropdef */ +const struct type type_parser_nodes__ADeferredMethPropdef = { +2291, +"ADeferredMethPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ADeferredMethPropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2291, /* ADeferredMethPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__ADeferredMethPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AInternMethPropdef */ +const struct type type_parser_nodes__AInternMethPropdef = { +2292, +"AInternMethPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AInternMethPropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2292, /* AInternMethPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AInternMethPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AExternMethPropdef */ +const struct type type_parser_nodes__AExternMethPropdef = { +2293, +"AExternMethPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AExternMethPropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2293, /* AExternMethPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AExternMethPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AAttrPropdef */ +const struct type type_parser_nodes__AAttrPropdef = { +2294, +"AAttrPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAttrPropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2294, /* AAttrPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AAttrPropdef = { +0, /* dummy */ +{ +&type_model__MAttributeDef, /* MPROPDEF: MAttributeDef */ +} +}; +/* runtime type AConcreteInitPropdef */ +const struct type type_parser_nodes__AConcreteInitPropdef = { +2568, +"AConcreteInitPropdef", /* class_name_string */ +8, +0, +&resolution_table_parser_nodes__AConcreteInitPropdef, +9, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2284, /* AConcreteMethPropdef */ +2295, /* AInitPropdef */ +2568, /* AConcreteInitPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AConcreteInitPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AInitPropdef */ +const struct type type_parser_nodes__AInitPropdef = { +2295, +"AInitPropdef", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +-1, /* empty */ +2295, /* AInitPropdef */ +}, +}; +/* runtime type ATypePropdef */ +const struct type type_parser_nodes__ATypePropdef = { +2296, +"ATypePropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ATypePropdef, +7, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2296, /* ATypePropdef */ +}, +}; +const struct types resolution_table_parser_nodes__ATypePropdef = { +0, /* dummy */ +{ +&type_model__MVirtualTypeDef, /* MPROPDEF: MVirtualTypeDef */ +} +}; +/* runtime type AExternInitPropdef */ +const struct type type_parser_nodes__AExternInitPropdef = { +2477, +"AExternInitPropdef", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AExternInitPropdef, +8, +{ +0, /* nullable Object */ +1, /* Object */ +8, /* nullable APropdef */ +225, /* ANode */ +624, /* Prod */ +1993, /* APropdef */ +2477, /* AExternInitPropdef */ +2295, /* AInitPropdef */ +}, +}; +const struct types resolution_table_parser_nodes__AExternInitPropdef = { +0, /* dummy */ +{ +&type_model__MMethodDef, /* MPROPDEF: MMethodDef */ +} +}; +/* runtime type AReadAble */ +const struct type type_parser_nodes__AReadAble = { +2297, +"AReadAble", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AReadAble, +7, +{ +0, /* nullable Object */ +1, /* Object */ +11, /* nullable AAble */ +225, /* ANode */ +624, /* Prod */ +1999, /* AAble */ +2297, /* AReadAble */ +}, +}; +const struct types resolution_table_parser_nodes__AReadAble = { +0, /* dummy */ +{ +} +}; +/* runtime type AAble */ +const struct type type_parser_nodes__AAble = { +1999, +"AAble", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +11, /* nullable AAble */ +225, /* ANode */ +624, /* Prod */ +1999, /* AAble */ +}, +}; +/* runtime type nullable AAble */ +const struct type type_nullable_parser_nodes__AAble = { +11, +"nullable AAble", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +11, /* nullable AAble */ +}, +}; +/* runtime type AWriteAble */ +const struct type type_parser_nodes__AWriteAble = { +2298, +"AWriteAble", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AWriteAble, +7, +{ +0, /* nullable Object */ +1, /* Object */ +11, /* nullable AAble */ +225, /* ANode */ +624, /* Prod */ +1999, /* AAble */ +2298, /* AWriteAble */ +}, +}; +const struct types resolution_table_parser_nodes__AWriteAble = { +0, /* dummy */ +{ +} +}; +/* runtime type APublicVisibility */ +const struct type type_parser_nodes__APublicVisibility = { +2299, +"APublicVisibility", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__APublicVisibility, +7, +{ +0, /* nullable Object */ +1, /* Object */ +12, /* nullable AVisibility */ +225, /* ANode */ +624, /* Prod */ +2000, /* AVisibility */ +2299, /* APublicVisibility */ +}, +}; +const struct types resolution_table_parser_nodes__APublicVisibility = { +0, /* dummy */ +{ +} +}; +/* runtime type AVisibility */ +const struct type type_parser_nodes__AVisibility = { +2000, +"AVisibility", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +12, /* nullable AVisibility */ +225, /* ANode */ +624, /* Prod */ +2000, /* AVisibility */ +}, +}; +/* runtime type nullable AVisibility */ +const struct type type_nullable_parser_nodes__AVisibility = { +12, +"nullable AVisibility", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +12, /* nullable AVisibility */ +}, +}; +/* runtime type APrivateVisibility */ +const struct type type_parser_nodes__APrivateVisibility = { +2300, +"APrivateVisibility", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__APrivateVisibility, +7, +{ +0, /* nullable Object */ +1, /* Object */ +12, /* nullable AVisibility */ +225, /* ANode */ +624, /* Prod */ +2000, /* AVisibility */ +2300, /* APrivateVisibility */ +}, +}; +const struct types resolution_table_parser_nodes__APrivateVisibility = { +0, /* dummy */ +{ +} +}; +/* runtime type AProtectedVisibility */ +const struct type type_parser_nodes__AProtectedVisibility = { +2301, +"AProtectedVisibility", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AProtectedVisibility, +7, +{ +0, /* nullable Object */ +1, /* Object */ +12, /* nullable AVisibility */ +225, /* ANode */ +624, /* Prod */ +2000, /* AVisibility */ +2301, /* AProtectedVisibility */ +}, +}; +const struct types resolution_table_parser_nodes__AProtectedVisibility = { +0, /* dummy */ +{ +} +}; +/* runtime type AIntrudeVisibility */ +const struct type type_parser_nodes__AIntrudeVisibility = { +2302, +"AIntrudeVisibility", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIntrudeVisibility, +7, +{ +0, /* nullable Object */ +1, /* Object */ +12, /* nullable AVisibility */ +225, /* ANode */ +624, /* Prod */ +2000, /* AVisibility */ +2302, /* AIntrudeVisibility */ +}, +}; +const struct types resolution_table_parser_nodes__AIntrudeVisibility = { +0, /* dummy */ +{ +} +}; +/* runtime type AIdMethid */ +const struct type type_parser_nodes__AIdMethid = { +2303, +"AIdMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIdMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2303, /* AIdMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AIdMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AMethid */ +const struct type type_parser_nodes__AMethid = { +2001, +"AMethid", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +}, +}; +/* runtime type nullable AMethid */ +const struct type type_nullable_parser_nodes__AMethid = { +13, +"nullable AMethid", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +13, /* nullable AMethid */ +}, +}; +/* runtime type APlusMethid */ +const struct type type_parser_nodes__APlusMethid = { +2304, +"APlusMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__APlusMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2304, /* APlusMethid */ +}, +}; +const struct types resolution_table_parser_nodes__APlusMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AMinusMethid */ +const struct type type_parser_nodes__AMinusMethid = { +2305, +"AMinusMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AMinusMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2305, /* AMinusMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AMinusMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AStarMethid */ +const struct type type_parser_nodes__AStarMethid = { +2306, +"AStarMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AStarMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2306, /* AStarMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AStarMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ASlashMethid */ +const struct type type_parser_nodes__ASlashMethid = { +2307, +"ASlashMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASlashMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2307, /* ASlashMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ASlashMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type APercentMethid */ +const struct type type_parser_nodes__APercentMethid = { +2308, +"APercentMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__APercentMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2308, /* APercentMethid */ +}, +}; +const struct types resolution_table_parser_nodes__APercentMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AEqMethid */ +const struct type type_parser_nodes__AEqMethid = { +2309, +"AEqMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AEqMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2309, /* AEqMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AEqMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ANeMethid */ +const struct type type_parser_nodes__ANeMethid = { +2310, +"ANeMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANeMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2310, /* ANeMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ANeMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ALeMethid */ +const struct type type_parser_nodes__ALeMethid = { +2311, +"ALeMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ALeMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2311, /* ALeMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ALeMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AGeMethid */ +const struct type type_parser_nodes__AGeMethid = { +2312, +"AGeMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AGeMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2312, /* AGeMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AGeMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ALtMethid */ +const struct type type_parser_nodes__ALtMethid = { +2313, +"ALtMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ALtMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2313, /* ALtMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ALtMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AGtMethid */ +const struct type type_parser_nodes__AGtMethid = { +2314, +"AGtMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AGtMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2314, /* AGtMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AGtMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ALlMethid */ +const struct type type_parser_nodes__ALlMethid = { +2315, +"ALlMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ALlMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2315, /* ALlMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ALlMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AGgMethid */ +const struct type type_parser_nodes__AGgMethid = { +2316, +"AGgMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AGgMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2316, /* AGgMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AGgMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ABraMethid */ +const struct type type_parser_nodes__ABraMethid = { +2317, +"ABraMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ABraMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2317, /* ABraMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ABraMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AStarshipMethid */ +const struct type type_parser_nodes__AStarshipMethid = { +2318, +"AStarshipMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AStarshipMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2318, /* AStarshipMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AStarshipMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type AAssignMethid */ +const struct type type_parser_nodes__AAssignMethid = { +2319, +"AAssignMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAssignMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2319, /* AAssignMethid */ +}, +}; +const struct types resolution_table_parser_nodes__AAssignMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ABraassignMethid */ +const struct type type_parser_nodes__ABraassignMethid = { +2320, +"ABraassignMethid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ABraassignMethid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +13, /* nullable AMethid */ +225, /* ANode */ +624, /* Prod */ +2001, /* AMethid */ +2320, /* ABraassignMethid */ +}, +}; +const struct types resolution_table_parser_nodes__ABraassignMethid = { +0, /* dummy */ +{ +} +}; +/* runtime type ASignature */ +const struct type type_parser_nodes__ASignature = { +2002, +"ASignature", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__ASignature, +6, +{ +0, /* nullable Object */ +1, /* Object */ +14, /* nullable ASignature */ +225, /* ANode */ +624, /* Prod */ +2002, /* ASignature */ +}, +}; +const struct types resolution_table_parser_nodes__ASignature = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable ASignature */ +const struct type type_nullable_parser_nodes__ASignature = { +14, +"nullable ASignature", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__ASignature, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +14, /* nullable ASignature */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__ASignature = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AParam] */ +const struct type type_parser_nodes__ANodesparser_nodes__AParam = { +2478, +"ANodes[AParam]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AParam, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2478, /* ANodes[AParam] */ +2003, /* Collection[AParam] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AParam = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AParam, /* Array[ANodes#0]: Array[AParam] */ +&type_parser_nodes__AParam, /* ANodes#0: AParam */ +&type_parser_nodes__AParam, /* Sequence#0: AParam */ +&type_parser_nodes__AParam, /* SimpleCollection#0: AParam */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AParam, /* RemovableCollection#0: AParam */ +&type_abstract_collection__Collectionparser_nodes__AParam, /* Collection[Sequence#0]: Collection[AParam] */ +&type_array__Arrayparser_nodes__AParam, /* Array[Sequence#0]: Array[AParam] */ +&type_abstract_collection__Collectionparser_nodes__AParam, /* Collection[SimpleCollection#0]: Collection[AParam] */ +&type_parser_nodes__AParam, /* Collection#0: AParam */ +&type_abstract_collection__Collectionparser_nodes__AParam, /* Collection[Collection#0]: Collection[AParam] */ +&type_parser_nodes__AParam, /* SequenceRead#0: AParam */ +} +}; +/* runtime type Collection[AParam] */ +const struct type type_abstract_collection__Collectionparser_nodes__AParam = { +2003, +"Collection[AParam]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2003, /* Collection[AParam] */ +}, +}; +/* runtime type ANodes[AClosureDecl] */ +const struct type type_parser_nodes__ANodesparser_nodes__AClosureDecl = { +2479, +"ANodes[AClosureDecl]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AClosureDecl, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2479, /* ANodes[AClosureDecl] */ +2004, /* Collection[AClosureDecl] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AClosureDecl = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AClosureDecl, /* Array[ANodes#0]: Array[AClosureDecl] */ +&type_parser_nodes__AClosureDecl, /* ANodes#0: AClosureDecl */ +&type_parser_nodes__AClosureDecl, /* Sequence#0: AClosureDecl */ +&type_parser_nodes__AClosureDecl, /* SimpleCollection#0: AClosureDecl */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AClosureDecl, /* RemovableCollection#0: AClosureDecl */ +&type_abstract_collection__Collectionparser_nodes__AClosureDecl, /* Collection[Sequence#0]: Collection[AClosureDecl] */ +&type_array__Arrayparser_nodes__AClosureDecl, /* Array[Sequence#0]: Array[AClosureDecl] */ +&type_abstract_collection__Collectionparser_nodes__AClosureDecl, /* Collection[SimpleCollection#0]: Collection[AClosureDecl] */ +&type_parser_nodes__AClosureDecl, /* Collection#0: AClosureDecl */ +&type_abstract_collection__Collectionparser_nodes__AClosureDecl, /* Collection[Collection#0]: Collection[AClosureDecl] */ +&type_parser_nodes__AClosureDecl, /* SequenceRead#0: AClosureDecl */ +} +}; +/* runtime type Collection[AClosureDecl] */ +const struct type type_abstract_collection__Collectionparser_nodes__AClosureDecl = { +2004, +"Collection[AClosureDecl]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2004, /* Collection[AClosureDecl] */ +}, +}; +/* runtime type AParam */ +const struct type type_parser_nodes__AParam = { +1808, +"AParam", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AParam, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1808, /* AParam */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AParam = { +0, /* dummy */ +{ +} +}; +/* runtime type AClosureDecl */ +const struct type type_parser_nodes__AClosureDecl = { +1809, +"AClosureDecl", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AClosureDecl, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1809, /* AClosureDecl */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AClosureDecl = { +0, /* dummy */ +{ +} +}; +/* runtime type AReturnExpr */ +const struct type type_parser_nodes__AReturnExpr = { +2321, +"AReturnExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AReturnExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2321, /* AReturnExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AReturnExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AExpr */ +const struct type type_parser_nodes__AExpr = { +2005, +"AExpr", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +}, +}; +/* runtime type nullable AExpr */ +const struct type type_nullable_parser_nodes__AExpr = { +15, +"nullable AExpr", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +15, /* nullable AExpr */ +}, +}; +/* runtime type AExternCalls */ +const struct type type_parser_nodes__AExternCalls = { +2006, +"AExternCalls", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AExternCalls, +6, +{ +0, /* nullable Object */ +1, /* Object */ +16, /* nullable AExternCalls */ +225, /* ANode */ +624, /* Prod */ +2006, /* AExternCalls */ +}, +}; +const struct types resolution_table_parser_nodes__AExternCalls = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AExternCalls */ +const struct type type_nullable_parser_nodes__AExternCalls = { +16, +"nullable AExternCalls", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AExternCalls, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +16, /* nullable AExternCalls */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AExternCalls = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AExternCall] */ +const struct type type_parser_nodes__ANodesparser_nodes__AExternCall = { +2480, +"ANodes[AExternCall]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AExternCall, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2480, /* ANodes[AExternCall] */ +2007, /* Collection[AExternCall] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AExternCall = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AExternCall, /* Array[ANodes#0]: Array[AExternCall] */ +&type_parser_nodes__AExternCall, /* ANodes#0: AExternCall */ +&type_parser_nodes__AExternCall, /* Sequence#0: AExternCall */ +&type_parser_nodes__AExternCall, /* SimpleCollection#0: AExternCall */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AExternCall, /* RemovableCollection#0: AExternCall */ +&type_abstract_collection__Collectionparser_nodes__AExternCall, /* Collection[Sequence#0]: Collection[AExternCall] */ +&type_array__Arrayparser_nodes__AExternCall, /* Array[Sequence#0]: Array[AExternCall] */ +&type_abstract_collection__Collectionparser_nodes__AExternCall, /* Collection[SimpleCollection#0]: Collection[AExternCall] */ +&type_parser_nodes__AExternCall, /* Collection#0: AExternCall */ +&type_abstract_collection__Collectionparser_nodes__AExternCall, /* Collection[Collection#0]: Collection[AExternCall] */ +&type_parser_nodes__AExternCall, /* SequenceRead#0: AExternCall */ +} +}; +/* runtime type Collection[AExternCall] */ +const struct type type_abstract_collection__Collectionparser_nodes__AExternCall = { +2007, +"Collection[AExternCall]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2007, /* Collection[AExternCall] */ +}, +}; +/* runtime type ASuperExternCall */ +const struct type type_parser_nodes__ASuperExternCall = { +2322, +"ASuperExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASuperExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2322, /* ASuperExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__ASuperExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AExternCall */ +const struct type type_parser_nodes__AExternCall = { +2008, +"AExternCall", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +}, +}; +/* runtime type nullable AExternCall */ +const struct type type_nullable_parser_nodes__AExternCall = { +17, +"nullable AExternCall", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +17, /* nullable AExternCall */ +}, +}; +/* runtime type ALocalPropExternCall */ +const struct type type_parser_nodes__ALocalPropExternCall = { +2323, +"ALocalPropExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ALocalPropExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2323, /* ALocalPropExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__ALocalPropExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AFullPropExternCall */ +const struct type type_parser_nodes__AFullPropExternCall = { +2324, +"AFullPropExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AFullPropExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2324, /* AFullPropExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__AFullPropExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AInitPropExternCall */ +const struct type type_parser_nodes__AInitPropExternCall = { +2325, +"AInitPropExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AInitPropExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2325, /* AInitPropExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__AInitPropExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type ACastAsExternCall */ +const struct type type_parser_nodes__ACastAsExternCall = { +2326, +"ACastAsExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ACastAsExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2326, /* ACastAsExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__ACastAsExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AAsNullableExternCall */ +const struct type type_parser_nodes__AAsNullableExternCall = { +2327, +"AAsNullableExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAsNullableExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2327, /* AAsNullableExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__AAsNullableExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AAsNotNullableExternCall */ +const struct type type_parser_nodes__AAsNotNullableExternCall = { +2328, +"AAsNotNullableExternCall", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAsNotNullableExternCall, +7, +{ +0, /* nullable Object */ +1, /* Object */ +17, /* nullable AExternCall */ +225, /* ANode */ +624, /* Prod */ +2008, /* AExternCall */ +2328, /* AAsNotNullableExternCall */ +}, +}; +const struct types resolution_table_parser_nodes__AAsNotNullableExternCall = { +0, /* dummy */ +{ +} +}; +/* runtime type AInLanguage */ +const struct type type_parser_nodes__AInLanguage = { +2009, +"AInLanguage", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AInLanguage, +6, +{ +0, /* nullable Object */ +1, /* Object */ +18, /* nullable AInLanguage */ +225, /* ANode */ +624, /* Prod */ +2009, /* AInLanguage */ +}, +}; +const struct types resolution_table_parser_nodes__AInLanguage = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AInLanguage */ +const struct type type_nullable_parser_nodes__AInLanguage = { +18, +"nullable AInLanguage", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AInLanguage, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +18, /* nullable AInLanguage */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AInLanguage = { +0, /* dummy */ +{ +} +}; +/* runtime type AExternCodeBlock */ +const struct type type_parser_nodes__AExternCodeBlock = { +2010, +"AExternCodeBlock", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AExternCodeBlock, +6, +{ +0, /* nullable Object */ +1, /* Object */ +19, /* nullable AExternCodeBlock */ +225, /* ANode */ +624, /* Prod */ +2010, /* AExternCodeBlock */ +}, +}; +const struct types resolution_table_parser_nodes__AExternCodeBlock = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AExternCodeBlock */ +const struct type type_nullable_parser_nodes__AExternCodeBlock = { +19, +"nullable AExternCodeBlock", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AExternCodeBlock, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +19, /* nullable AExternCodeBlock */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AExternCodeBlock = { +0, /* dummy */ +{ +} +}; +/* runtime type AType */ +const struct type type_parser_nodes__AType = { +2011, +"AType", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AType, +6, +{ +0, /* nullable Object */ +1, /* Object */ +20, /* nullable AType */ +225, /* ANode */ +624, /* Prod */ +2011, /* AType */ +}, +}; +const struct types resolution_table_parser_nodes__AType = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AType */ +const struct type type_nullable_parser_nodes__AType = { +20, +"nullable AType", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AType, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +20, /* nullable AType */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AType = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AType] */ +const struct type type_parser_nodes__ANodesparser_nodes__AType = { +2481, +"ANodes[AType]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AType, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2481, /* ANodes[AType] */ +2012, /* Collection[AType] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AType = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AType, /* Array[ANodes#0]: Array[AType] */ +&type_parser_nodes__AType, /* ANodes#0: AType */ +&type_parser_nodes__AType, /* Sequence#0: AType */ +&type_parser_nodes__AType, /* SimpleCollection#0: AType */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AType, /* RemovableCollection#0: AType */ +&type_abstract_collection__Collectionparser_nodes__AType, /* Collection[Sequence#0]: Collection[AType] */ +&type_array__Arrayparser_nodes__AType, /* Array[Sequence#0]: Array[AType] */ +&type_abstract_collection__Collectionparser_nodes__AType, /* Collection[SimpleCollection#0]: Collection[AType] */ +&type_parser_nodes__AType, /* Collection#0: AType */ +&type_abstract_collection__Collectionparser_nodes__AType, /* Collection[Collection#0]: Collection[AType] */ +&type_parser_nodes__AType, /* SequenceRead#0: AType */ +} +}; +/* runtime type Collection[AType] */ +const struct type type_abstract_collection__Collectionparser_nodes__AType = { +2012, +"Collection[AType]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2012, /* Collection[AType] */ +}, +}; +/* runtime type ABlockExpr */ +const struct type type_parser_nodes__ABlockExpr = { +2329, +"ABlockExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ABlockExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2329, /* ABlockExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ABlockExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AExpr] */ +const struct type type_parser_nodes__ANodesparser_nodes__AExpr = { +2482, +"ANodes[AExpr]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2482, /* ANodes[AExpr] */ +2013, /* Collection[AExpr] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AExpr = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AExpr, /* Array[ANodes#0]: Array[AExpr] */ +&type_parser_nodes__AExpr, /* ANodes#0: AExpr */ +&type_parser_nodes__AExpr, /* Sequence#0: AExpr */ +&type_parser_nodes__AExpr, /* SimpleCollection#0: AExpr */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AExpr, /* RemovableCollection#0: AExpr */ +&type_abstract_collection__Collectionparser_nodes__AExpr, /* Collection[Sequence#0]: Collection[AExpr] */ +&type_array__Arrayparser_nodes__AExpr, /* Array[Sequence#0]: Array[AExpr] */ +&type_abstract_collection__Collectionparser_nodes__AExpr, /* Collection[SimpleCollection#0]: Collection[AExpr] */ +&type_parser_nodes__AExpr, /* Collection#0: AExpr */ +&type_abstract_collection__Collectionparser_nodes__AExpr, /* Collection[Collection#0]: Collection[AExpr] */ +&type_parser_nodes__AExpr, /* SequenceRead#0: AExpr */ +} +}; +/* runtime type Collection[AExpr] */ +const struct type type_abstract_collection__Collectionparser_nodes__AExpr = { +2013, +"Collection[AExpr]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2013, /* Collection[AExpr] */ +}, +}; +/* runtime type ABreakExpr */ +const struct type type_parser_nodes__ABreakExpr = { +2330, +"ABreakExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ABreakExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2330, /* ABreakExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ABreakExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAbortExpr */ +const struct type type_parser_nodes__AAbortExpr = { +2331, +"AAbortExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAbortExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2331, /* AAbortExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAbortExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AContinueExpr */ +const struct type type_parser_nodes__AContinueExpr = { +2332, +"AContinueExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AContinueExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2332, /* AContinueExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AContinueExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ACallExpr */ +const struct type type_parser_nodes__ACallExpr = { +2483, +"ACallExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ACallExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2483, /* ACallExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ACallExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ASendExpr */ +const struct type type_parser_nodes__ASendExpr = { +2333, +"ASendExpr", /* class_name_string */ +6, +0, +NULL, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +}, +}; +/* runtime type ANodes[AClosureDef] */ +const struct type type_parser_nodes__ANodesparser_nodes__AClosureDef = { +2484, +"ANodes[AClosureDef]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AClosureDef, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2484, /* ANodes[AClosureDef] */ +2014, /* Collection[AClosureDef] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AClosureDef = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AClosureDef, /* Array[ANodes#0]: Array[AClosureDef] */ +&type_parser_nodes__AClosureDef, /* ANodes#0: AClosureDef */ +&type_parser_nodes__AClosureDef, /* Sequence#0: AClosureDef */ +&type_parser_nodes__AClosureDef, /* SimpleCollection#0: AClosureDef */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AClosureDef, /* RemovableCollection#0: AClosureDef */ +&type_abstract_collection__Collectionparser_nodes__AClosureDef, /* Collection[Sequence#0]: Collection[AClosureDef] */ +&type_array__Arrayparser_nodes__AClosureDef, /* Array[Sequence#0]: Array[AClosureDef] */ +&type_abstract_collection__Collectionparser_nodes__AClosureDef, /* Collection[SimpleCollection#0]: Collection[AClosureDef] */ +&type_parser_nodes__AClosureDef, /* Collection#0: AClosureDef */ +&type_abstract_collection__Collectionparser_nodes__AClosureDef, /* Collection[Collection#0]: Collection[AClosureDef] */ +&type_parser_nodes__AClosureDef, /* SequenceRead#0: AClosureDef */ +} +}; +/* runtime type Collection[AClosureDef] */ +const struct type type_abstract_collection__Collectionparser_nodes__AClosureDef = { +2014, +"Collection[AClosureDef]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2014, /* Collection[AClosureDef] */ +}, +}; +/* runtime type AImplicitSelfExpr */ +const struct type type_parser_nodes__AImplicitSelfExpr = { +2485, +"AImplicitSelfExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AImplicitSelfExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2334, /* ASelfExpr */ +2485, /* AImplicitSelfExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AImplicitSelfExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ASelfExpr */ +const struct type type_parser_nodes__ASelfExpr = { +2334, +"ASelfExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASelfExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2334, /* ASelfExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ASelfExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ASuperExpr */ +const struct type type_parser_nodes__ASuperExpr = { +2335, +"ASuperExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASuperExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2335, /* ASuperExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ASuperExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AQualified */ +const struct type type_parser_nodes__AQualified = { +1810, +"AQualified", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AQualified, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1810, /* AQualified */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AQualified = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[TId] */ +const struct type type_parser_nodes__ANodesparser_nodes__TId = { +2486, +"ANodes[TId]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__TId, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1811, /* Collection[Token] */ +2486, /* ANodes[TId] */ +2015, /* Collection[TId] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__TId = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__TId, /* Array[ANodes#0]: Array[TId] */ +&type_parser_nodes__TId, /* ANodes#0: TId */ +&type_parser_nodes__TId, /* Sequence#0: TId */ +&type_parser_nodes__TId, /* SimpleCollection#0: TId */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__TId, /* RemovableCollection#0: TId */ +&type_abstract_collection__Collectionparser_nodes__TId, /* Collection[Sequence#0]: Collection[TId] */ +&type_array__Arrayparser_nodes__TId, /* Array[Sequence#0]: Array[TId] */ +&type_abstract_collection__Collectionparser_nodes__TId, /* Collection[SimpleCollection#0]: Collection[TId] */ +&type_parser_nodes__TId, /* Collection#0: TId */ +&type_abstract_collection__Collectionparser_nodes__TId, /* Collection[Collection#0]: Collection[TId] */ +&type_parser_nodes__TId, /* SequenceRead#0: TId */ +} +}; +/* runtime type Collection[TId] */ +const struct type type_abstract_collection__Collectionparser_nodes__TId = { +2015, +"Collection[TId]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1811, /* Collection[Token] */ +-1, /* empty */ +2015, /* Collection[TId] */ +}, +}; +/* runtime type Collection[Token] */ +const struct type type_abstract_collection__Collectionparser_nodes__Token = { +1811, +"Collection[Token]", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1811, /* Collection[Token] */ +}, +}; +/* runtime type AInitExpr */ +const struct type type_parser_nodes__AInitExpr = { +2487, +"AInitExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AInitExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2487, /* AInitExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AInitExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ADebugTypeExpr */ +const struct type type_parser_nodes__ADebugTypeExpr = { +2336, +"ADebugTypeExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ADebugTypeExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2336, /* ADebugTypeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ADebugTypeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ALabel */ +const struct type type_parser_nodes__ALabel = { +2016, +"ALabel", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__ALabel, +6, +{ +0, /* nullable Object */ +1, /* Object */ +21, /* nullable ALabel */ +225, /* ANode */ +624, /* Prod */ +2016, /* ALabel */ +}, +}; +const struct types resolution_table_parser_nodes__ALabel = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable ALabel */ +const struct type type_nullable_parser_nodes__ALabel = { +21, +"nullable ALabel", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__ALabel, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +21, /* nullable ALabel */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__ALabel = { +0, /* dummy */ +{ +} +}; +/* runtime type AClosureDef */ +const struct type type_parser_nodes__AClosureDef = { +1812, +"AClosureDef", /* class_name_string */ +2, +0, +&resolution_table_parser_nodes__AClosureDef, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1812, /* AClosureDef */ +225, /* ANode */ +624, /* Prod */ +}, +}; +const struct types resolution_table_parser_nodes__AClosureDef = { +0, /* dummy */ +{ +} +}; +/* runtime type ASimpleClosureId */ +const struct type type_parser_nodes__ASimpleClosureId = { +2337, +"ASimpleClosureId", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASimpleClosureId, +7, +{ +0, /* nullable Object */ +1, /* Object */ +22, /* nullable AClosureId */ +225, /* ANode */ +624, /* Prod */ +2017, /* AClosureId */ +2337, /* ASimpleClosureId */ +}, +}; +const struct types resolution_table_parser_nodes__ASimpleClosureId = { +0, /* dummy */ +{ +} +}; +/* runtime type AClosureId */ +const struct type type_parser_nodes__AClosureId = { +2017, +"AClosureId", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +22, /* nullable AClosureId */ +225, /* ANode */ +624, /* Prod */ +2017, /* AClosureId */ +}, +}; +/* runtime type nullable AClosureId */ +const struct type type_nullable_parser_nodes__AClosureId = { +22, +"nullable AClosureId", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +22, /* nullable AClosureId */ +}, +}; +/* runtime type ABreakClosureId */ +const struct type type_parser_nodes__ABreakClosureId = { +2338, +"ABreakClosureId", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ABreakClosureId, +7, +{ +0, /* nullable Object */ +1, /* Object */ +22, /* nullable AClosureId */ +225, /* ANode */ +624, /* Prod */ +2017, /* AClosureId */ +2338, /* ABreakClosureId */ +}, +}; +const struct types resolution_table_parser_nodes__ABreakClosureId = { +0, /* dummy */ +{ +} +}; +/* runtime type AVardeclExpr */ +const struct type type_parser_nodes__AVardeclExpr = { +2339, +"AVardeclExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AVardeclExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2339, /* AVardeclExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AVardeclExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAttrAssignExpr */ +const struct type type_parser_nodes__AAttrAssignExpr = { +2340, +"AAttrAssignExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAttrAssignExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2340, /* AAttrAssignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAttrAssignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ACallAssignExpr */ +const struct type type_parser_nodes__ACallAssignExpr = { +2488, +"ACallAssignExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ACallAssignExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2488, /* ACallAssignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ACallAssignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ABraAssignExpr */ +const struct type type_parser_nodes__ABraAssignExpr = { +2489, +"ABraAssignExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ABraAssignExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2489, /* ABraAssignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ABraAssignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAttrReassignExpr */ +const struct type type_parser_nodes__AAttrReassignExpr = { +2341, +"AAttrReassignExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAttrReassignExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2341, /* AAttrReassignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAttrReassignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ACallReassignExpr */ +const struct type type_parser_nodes__ACallReassignExpr = { +2490, +"ACallReassignExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ACallReassignExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2490, /* ACallReassignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ACallReassignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ABraReassignExpr */ +const struct type type_parser_nodes__ABraReassignExpr = { +2491, +"ABraReassignExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ABraReassignExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2491, /* ABraReassignExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ABraReassignExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type APlusAssignOp */ +const struct type type_parser_nodes__APlusAssignOp = { +2342, +"APlusAssignOp", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__APlusAssignOp, +7, +{ +0, /* nullable Object */ +1, /* Object */ +23, /* nullable AAssignOp */ +225, /* ANode */ +624, /* Prod */ +2018, /* AAssignOp */ +2342, /* APlusAssignOp */ +}, +}; +const struct types resolution_table_parser_nodes__APlusAssignOp = { +0, /* dummy */ +{ +} +}; +/* runtime type AAssignOp */ +const struct type type_parser_nodes__AAssignOp = { +2018, +"AAssignOp", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +23, /* nullable AAssignOp */ +225, /* ANode */ +624, /* Prod */ +2018, /* AAssignOp */ +}, +}; +/* runtime type nullable AAssignOp */ +const struct type type_nullable_parser_nodes__AAssignOp = { +23, +"nullable AAssignOp", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +23, /* nullable AAssignOp */ +}, +}; +/* runtime type AMinusAssignOp */ +const struct type type_parser_nodes__AMinusAssignOp = { +2343, +"AMinusAssignOp", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AMinusAssignOp, +7, +{ +0, /* nullable Object */ +1, /* Object */ +23, /* nullable AAssignOp */ +225, /* ANode */ +624, /* Prod */ +2018, /* AAssignOp */ +2343, /* AMinusAssignOp */ +}, +}; +const struct types resolution_table_parser_nodes__AMinusAssignOp = { +0, /* dummy */ +{ +} +}; +/* runtime type ADoExpr */ +const struct type type_parser_nodes__ADoExpr = { +2344, +"ADoExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ADoExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2344, /* ADoExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ADoExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AIfExpr */ +const struct type type_parser_nodes__AIfExpr = { +2345, +"AIfExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIfExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2345, /* AIfExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AIfExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ALoopExpr */ +const struct type type_parser_nodes__ALoopExpr = { +2346, +"ALoopExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ALoopExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2346, /* ALoopExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ALoopExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AWhileExpr */ +const struct type type_parser_nodes__AWhileExpr = { +2347, +"AWhileExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AWhileExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2347, /* AWhileExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AWhileExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AForExpr */ +const struct type type_parser_nodes__AForExpr = { +2348, +"AForExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AForExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2348, /* AForExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AForExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAssertExpr */ +const struct type type_parser_nodes__AAssertExpr = { +2349, +"AAssertExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAssertExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2349, /* AAssertExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAssertExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ABraExpr */ +const struct type type_parser_nodes__ABraExpr = { +2492, +"ABraExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ABraExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2492, /* ABraExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ABraExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AIfexprExpr */ +const struct type type_parser_nodes__AIfexprExpr = { +2350, +"AIfexprExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIfexprExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2350, /* AIfexprExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AIfexprExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AOrExpr */ +const struct type type_parser_nodes__AOrExpr = { +2493, +"AOrExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AOrExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2493, /* AOrExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AOrExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ABoolExpr */ +const struct type type_parser_nodes__ABoolExpr = { +2351, +"ABoolExpr", /* class_name_string */ +6, +0, +NULL, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +}, +}; +/* runtime type AAndExpr */ +const struct type type_parser_nodes__AAndExpr = { +2494, +"AAndExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AAndExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2494, /* AAndExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAndExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AOrElseExpr */ +const struct type type_parser_nodes__AOrElseExpr = { +2495, +"AOrElseExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AOrElseExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2495, /* AOrElseExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AOrElseExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AImpliesExpr */ +const struct type type_parser_nodes__AImpliesExpr = { +2496, +"AImpliesExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AImpliesExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2496, /* AImpliesExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AImpliesExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ANotExpr */ +const struct type type_parser_nodes__ANotExpr = { +2497, +"ANotExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ANotExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2497, /* ANotExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ANotExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AEqExpr */ +const struct type type_parser_nodes__AEqExpr = { +2498, +"AEqExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AEqExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2498, /* AEqExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AEqExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AEeExpr */ +const struct type type_parser_nodes__AEeExpr = { +2499, +"AEeExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AEeExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2499, /* AEeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AEeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ANeExpr */ +const struct type type_parser_nodes__ANeExpr = { +2500, +"ANeExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ANeExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2500, /* ANeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ANeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ALtExpr */ +const struct type type_parser_nodes__ALtExpr = { +2501, +"ALtExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ALtExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2501, /* ALtExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ALtExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ALeExpr */ +const struct type type_parser_nodes__ALeExpr = { +2502, +"ALeExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ALeExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2502, /* ALeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ALeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ALlExpr */ +const struct type type_parser_nodes__ALlExpr = { +2503, +"ALlExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ALlExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2503, /* ALlExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ALlExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AGtExpr */ +const struct type type_parser_nodes__AGtExpr = { +2504, +"AGtExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AGtExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2504, /* AGtExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AGtExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AGeExpr */ +const struct type type_parser_nodes__AGeExpr = { +2505, +"AGeExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AGeExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2505, /* AGeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AGeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AGgExpr */ +const struct type type_parser_nodes__AGgExpr = { +2506, +"AGgExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AGgExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2506, /* AGgExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AGgExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AStarshipExpr */ +const struct type type_parser_nodes__AStarshipExpr = { +2507, +"AStarshipExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AStarshipExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2507, /* AStarshipExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AStarshipExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AIsaExpr */ +const struct type type_parser_nodes__AIsaExpr = { +2508, +"AIsaExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AIsaExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2508, /* AIsaExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AIsaExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type APlusExpr */ +const struct type type_parser_nodes__APlusExpr = { +2509, +"APlusExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__APlusExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2509, /* APlusExpr */ +}, +}; +const struct types resolution_table_parser_nodes__APlusExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AMinusExpr */ +const struct type type_parser_nodes__AMinusExpr = { +2510, +"AMinusExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AMinusExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2510, /* AMinusExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AMinusExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AStarExpr */ +const struct type type_parser_nodes__AStarExpr = { +2511, +"AStarExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AStarExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2511, /* AStarExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AStarExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ASlashExpr */ +const struct type type_parser_nodes__ASlashExpr = { +2512, +"ASlashExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ASlashExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2512, /* ASlashExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ASlashExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type APercentExpr */ +const struct type type_parser_nodes__APercentExpr = { +2513, +"APercentExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__APercentExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2513, /* APercentExpr */ +}, +}; +const struct types resolution_table_parser_nodes__APercentExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AUminusExpr */ +const struct type type_parser_nodes__AUminusExpr = { +2514, +"AUminusExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AUminusExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2333, /* ASendExpr */ +2514, /* AUminusExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AUminusExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AOnceExpr */ +const struct type type_parser_nodes__AOnceExpr = { +2352, +"AOnceExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AOnceExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2352, /* AOnceExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AOnceExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ANewExpr */ +const struct type type_parser_nodes__ANewExpr = { +2353, +"ANewExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANewExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2353, /* ANewExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ANewExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AIssetAttrExpr */ +const struct type type_parser_nodes__AIssetAttrExpr = { +2354, +"AIssetAttrExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIssetAttrExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2354, /* AIssetAttrExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AIssetAttrExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAttrExpr */ +const struct type type_parser_nodes__AAttrExpr = { +2355, +"AAttrExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAttrExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2355, /* AAttrExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAttrExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ACrangeExpr */ +const struct type type_parser_nodes__ACrangeExpr = { +2356, +"ACrangeExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ACrangeExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2356, /* ACrangeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ACrangeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AOrangeExpr */ +const struct type type_parser_nodes__AOrangeExpr = { +2357, +"AOrangeExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AOrangeExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2357, /* AOrangeExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AOrangeExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AArrayExpr */ +const struct type type_parser_nodes__AArrayExpr = { +2358, +"AArrayExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AArrayExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2358, /* AArrayExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AArrayExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ATrueExpr */ +const struct type type_parser_nodes__ATrueExpr = { +2515, +"ATrueExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__ATrueExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2515, /* ATrueExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ATrueExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AFalseExpr */ +const struct type type_parser_nodes__AFalseExpr = { +2516, +"AFalseExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AFalseExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2351, /* ABoolExpr */ +2516, /* AFalseExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AFalseExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ANullExpr */ +const struct type type_parser_nodes__ANullExpr = { +2359, +"ANullExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANullExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2359, /* ANullExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ANullExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AIntExpr */ +const struct type type_parser_nodes__AIntExpr = { +2360, +"AIntExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIntExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2360, /* AIntExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AIntExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AFloatExpr */ +const struct type type_parser_nodes__AFloatExpr = { +2361, +"AFloatExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AFloatExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2361, /* AFloatExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AFloatExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ACharExpr */ +const struct type type_parser_nodes__ACharExpr = { +2362, +"ACharExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ACharExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2362, /* ACharExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ACharExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AStringExpr */ +const struct type type_parser_nodes__AStringExpr = { +2517, +"AStringExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AStringExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2363, /* AStringFormExpr */ +2517, /* AStringExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AStringExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AStringFormExpr */ +const struct type type_parser_nodes__AStringFormExpr = { +2363, +"AStringFormExpr", /* class_name_string */ +6, +0, +NULL, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2363, /* AStringFormExpr */ +}, +}; +/* runtime type AParExpr */ +const struct type type_parser_nodes__AParExpr = { +2364, +"AParExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AParExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2364, /* AParExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AParExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAsCastExpr */ +const struct type type_parser_nodes__AAsCastExpr = { +2365, +"AAsCastExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAsCastExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2365, /* AAsCastExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAsCastExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAsNotnullExpr */ +const struct type type_parser_nodes__AAsNotnullExpr = { +2366, +"AAsNotnullExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AAsNotnullExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2366, /* AAsNotnullExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AAsNotnullExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type ASuperstringExpr */ +const struct type type_parser_nodes__ASuperstringExpr = { +2367, +"ASuperstringExpr", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ASuperstringExpr, +7, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2367, /* ASuperstringExpr */ +}, +}; +const struct types resolution_table_parser_nodes__ASuperstringExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AStartStringExpr */ +const struct type type_parser_nodes__AStartStringExpr = { +2518, +"AStartStringExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AStartStringExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2363, /* AStringFormExpr */ +2518, /* AStartStringExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AStartStringExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AMidStringExpr */ +const struct type type_parser_nodes__AMidStringExpr = { +2519, +"AMidStringExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AMidStringExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2363, /* AStringFormExpr */ +2519, /* AMidStringExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AMidStringExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AEndStringExpr */ +const struct type type_parser_nodes__AEndStringExpr = { +2520, +"AEndStringExpr", /* class_name_string */ +7, +0, +&resolution_table_parser_nodes__AEndStringExpr, +8, +{ +0, /* nullable Object */ +1, /* Object */ +15, /* nullable AExpr */ +225, /* ANode */ +624, /* Prod */ +2005, /* AExpr */ +2363, /* AStringFormExpr */ +2520, /* AEndStringExpr */ +}, +}; +const struct types resolution_table_parser_nodes__AEndStringExpr = { +0, /* dummy */ +{ +} +}; +/* runtime type AAnnotation */ +const struct type type_parser_nodes__AAnnotation = { +2019, +"AAnnotation", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AAnnotation, +6, +{ +0, /* nullable Object */ +1, /* Object */ +24, /* nullable AAnnotation */ +225, /* ANode */ +624, /* Prod */ +2019, /* AAnnotation */ +}, +}; +const struct types resolution_table_parser_nodes__AAnnotation = { +0, /* dummy */ +{ +} +}; +/* runtime type nullable AAnnotation */ +const struct type type_nullable_parser_nodes__AAnnotation = { +24, +"nullable AAnnotation", /* class_name_string */ +2, +1, +&resolution_table_nullable_parser_nodes__AAnnotation, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +24, /* nullable AAnnotation */ +}, +}; +const struct types resolution_table_nullable_parser_nodes__AAnnotation = { +0, /* dummy */ +{ +} +}; +/* runtime type ANodes[AAtArg] */ +const struct type type_parser_nodes__ANodesparser_nodes__AAtArg = { +2521, +"ANodes[AAtArg]", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__ANodesparser_nodes__AAtArg, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +165, /* SequenceRead[nullable Object] */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +2521, /* ANodes[AAtArg] */ +2020, /* Collection[AAtArg] */ +}, +}; +const struct types resolution_table_parser_nodes__ANodesparser_nodes__AAtArg = { +0, /* dummy */ +{ +&type_array__Arrayparser_nodes__AAtArg, /* Array[ANodes#0]: Array[AAtArg] */ +&type_parser_nodes__AAtArg, /* ANodes#0: AAtArg */ +&type_parser_nodes__AAtArg, /* Sequence#0: AAtArg */ +&type_parser_nodes__AAtArg, /* SimpleCollection#0: AAtArg */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +NULL, /* empty */ +&type_parser_nodes__AAtArg, /* RemovableCollection#0: AAtArg */ +&type_abstract_collection__Collectionparser_nodes__AAtArg, /* Collection[Sequence#0]: Collection[AAtArg] */ +&type_array__Arrayparser_nodes__AAtArg, /* Array[Sequence#0]: Array[AAtArg] */ +&type_abstract_collection__Collectionparser_nodes__AAtArg, /* Collection[SimpleCollection#0]: Collection[AAtArg] */ +&type_parser_nodes__AAtArg, /* Collection#0: AAtArg */ +&type_abstract_collection__Collectionparser_nodes__AAtArg, /* Collection[Collection#0]: Collection[AAtArg] */ +&type_parser_nodes__AAtArg, /* SequenceRead#0: AAtArg */ +} +}; +/* runtime type Collection[AAtArg] */ +const struct type type_abstract_collection__Collectionparser_nodes__AAtArg = { +2020, +"Collection[AAtArg]", /* class_name_string */ +7, +0, +NULL, +8, +{ +0, /* nullable Object */ +1, /* Object */ +598, /* Collection[ANode] */ +-1, /* empty */ +166, /* Collection[Object] */ +1789, /* Collection[Prod] */ +-1, /* empty */ +2020, /* Collection[AAtArg] */ +}, +}; +/* runtime type ATypeAtArg */ +const struct type type_parser_nodes__ATypeAtArg = { +2021, +"ATypeAtArg", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__ATypeAtArg, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1813, /* AAtArg */ +225, /* ANode */ +624, /* Prod */ +2021, /* ATypeAtArg */ +}, +}; +const struct types resolution_table_parser_nodes__ATypeAtArg = { +0, /* dummy */ +{ +} +}; +/* runtime type AAtArg */ +const struct type type_parser_nodes__AAtArg = { +1813, +"AAtArg", /* class_name_string */ +2, +0, +NULL, +5, +{ +0, /* nullable Object */ +1, /* Object */ +1813, /* AAtArg */ +225, /* ANode */ +624, /* Prod */ +}, +}; +/* runtime type AExprAtArg */ +const struct type type_parser_nodes__AExprAtArg = { +2022, +"AExprAtArg", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AExprAtArg, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1813, /* AAtArg */ +225, /* ANode */ +624, /* Prod */ +2022, /* AExprAtArg */ +}, +}; +const struct types resolution_table_parser_nodes__AExprAtArg = { +0, /* dummy */ +{ +} +}; +/* runtime type AAtAtArg */ +const struct type type_parser_nodes__AAtAtArg = { +2023, +"AAtAtArg", /* class_name_string */ +5, +0, +&resolution_table_parser_nodes__AAtAtArg, +6, +{ +0, /* nullable Object */ +1, /* Object */ +1813, /* AAtArg */ +225, /* ANode */ +624, /* Prod */ +2023, /* AAtAtArg */ +}, +}; +const struct types resolution_table_parser_nodes__AAtAtArg = { +0, /* dummy */ +{ +} +}; +/* runtime type AIdAtid */ +const struct type type_parser_nodes__AIdAtid = { +2368, +"AIdAtid", /* class_name_string */ +6, +0, +&resolution_table_parser_nodes__AIdAtid, +7, +{ +0, /* nullable Object */ +1, /* Object */ +25, /* nullable AAtid */ +225, /* ANode */ +624, /* Prod */ +2024, /* AAtid */ +2368, /* AIdAtid */ +}, +}; +const struct types resolution_table_parser_nodes__AIdAtid = { +0, /* dummy */ +{ +} +}; +/* runtime type AAtid */ +const struct type type_parser_nodes__AAtid = { +2024, +"AAtid", /* class_name_string */ +5, +0, +NULL, +6, +{ +0, /* nullable Object */ +1, /* Object */ +25, /* nullable AAtid */ +225, /* ANode */ +624, /* Prod */ +2024, /* AAtid */ +}, +}; +/* runtime type nullable AAtid */ +const struct type type_nullable_parser_nodes__AAtid = { +25, +"nullable AAtid", /* class_name_string */ +2, +1, +NULL, +3, +{ +0, /* nullable Object */ +-1, /* empty */ +25, /* nullable AAtid */ +}, +};