diff options
30 files changed, 3696 insertions, 2863 deletions
diff --git a/crawl-ref/source/AppHdr.h b/crawl-ref/source/AppHdr.h index 27594ac3a2..56ea84e0cd 100644 --- a/crawl-ref/source/AppHdr.h +++ b/crawl-ref/source/AppHdr.h @@ -270,12 +270,6 @@ // or just want fighter type wanderers. // #define USE_SPELLCASTER_AND_RANGER_WANDERER_TEMPLATES -//mv: (new 9 Aug 01) switches on new rivers & lakes code -#define USE_RIVERS - -//mv: (new 9 Aug 01) switches on new unrands -#define USE_NEW_UNRANDS - // mv: (new 9 Aug 01) turns off missile trails, might be slow on some computers // #define MISSILE_TRAILS_OFF diff --git a/crawl-ref/source/FixAry.h b/crawl-ref/source/FixAry.h index 4270949150..3db9d49abd 100644 --- a/crawl-ref/source/FixAry.h +++ b/crawl-ref/source/FixAry.h @@ -58,6 +58,16 @@ public: // ----- Access ----- Column& operator[](unsigned long index) {return mData[index];} const Column& operator[](unsigned long index) const {return mData[index];} + template<class Indexer> TYPE& operator () (const Indexer &i) + { + return mData[i.x][i.y]; + } + + template<class Indexer> const TYPE& operator () (const Indexer &i) + const + { + return mData[i.x][i.y]; + } //----------------------------------- // Member Data diff --git a/crawl-ref/source/acr.cc b/crawl-ref/source/acr.cc index 49b5c4dc50..210718e6b1 100644 --- a/crawl-ref/source/acr.cc +++ b/crawl-ref/source/acr.cc @@ -144,8 +144,8 @@ bool game_has_started = false; // Clockwise, around the compass from north (same order as enum RUN_DIR) const struct coord_def Compass[8] = { - { 0, -1 }, { 1, -1 }, { 1, 0 }, { 1, 1 }, - { 0, 1 }, { -1, 1 }, { -1, 0 }, { -1, -1 }, + coord_def(0, -1), coord_def(1, -1), coord_def(1, 0), coord_def(1, 1), + coord_def(0, 1), coord_def(-1, 1), coord_def(-1, 0), coord_def(-1, -1), }; // Functions in main module diff --git a/crawl-ref/source/dat/levdes.vim b/crawl-ref/source/dat/levdes.vim index fa693cc694..42dbdefad1 100644 --- a/crawl-ref/source/dat/levdes.vim +++ b/crawl-ref/source/dat/levdes.vim @@ -18,7 +18,7 @@ setlocal iskeyword+=: setlocal iskeyword+=- syn keyword desDeclarator NAME: ORIENT: DEPTH: PLACE: MONS: FLAGS: SYMBOL: default-depth: TAGS: CHANCE: -syn keyword desOrientation encompass north south east west northeast northwest southeast southwest +syn keyword desOrientation encompass north south east west northeast northwest southeast southwest float syn match desComment "^\s*#.*$" @@ -69,7 +69,7 @@ hi desMapTrap guifg=red gui=bold ctermfg=red hi desMapWater guifg=lightblue ctermfg=darkblue hi desMapGold guifg=#c09000 ctermfg=yellow hi desMapDoor guifg=brown gui=bold ctermfg=black ctermbg=brown -hi desMapEntry guifg=black guibg=white gui=bold ctermfg=white +hi desMapEntry guifg=black guibg=white gui=bold ctermfg=white ctermbg=black hi desMapValuable guifg=darkgreen gui=bold ctermfg=lightgreen hi desMapRune guifg=orange gui=bold ctermfg=white diff --git a/crawl-ref/source/debug.cc b/crawl-ref/source/debug.cc index 7db5242383..3b8bdf9cd3 100644 --- a/crawl-ref/source/debug.cc +++ b/crawl-ref/source/debug.cc @@ -1165,7 +1165,7 @@ void stethoscope(int mwh) mpr( info, MSGCH_DIAGNOSTICS ); // print stats and other info - snprintf( info, INFO_SIZE,"HD=%d HP=%d/%d AC=%d EV=%d MR=%d SP=%d energy=%d num=%d flags=%02x", + snprintf( info, INFO_SIZE,"HD=%d HP=%d/%d AC=%d EV=%d MR=%d SP=%d energy=%d num=%d flags=%04lx", menv[i].hit_dice, menv[i].hit_points, menv[i].max_hit_points, menv[i].armour_class, menv[i].evasion, diff --git a/crawl-ref/source/defines.h b/crawl-ref/source/defines.h index b36afc1ad3..eef208965d 100644 --- a/crawl-ref/source/defines.h +++ b/crawl-ref/source/defines.h @@ -75,6 +75,10 @@ // this is the size of the border around the playing area (see in_bounds()) #define BOUNDARY_BORDER 1 +// This is the border that must be left around the map. I'm not sure why it's +// necessary, beyond hysterical raisins. +#define MAPGEN_BORDER 6 + // Now some defines about the actual play area: // Note: these boundaries are exclusive for the zone the player can move/dig, // and are inclusive for the area that we display on the map. diff --git a/crawl-ref/source/dungeon.cc b/crawl-ref/source/dungeon.cc index 70f37d96c6..99ebaf73f9 100644 --- a/crawl-ref/source/dungeon.cc +++ b/crawl-ref/source/dungeon.cc @@ -28,6 +28,7 @@ #include <stdlib.h> #include <stdio.h> #include <time.h> +#include <algorithm> #include "AppHdr.h" #include "abyss.h" @@ -92,18 +93,17 @@ static void hide_doors(void); static void make_trail(int xs, int xr, int ys, int yr,int corrlength, int intersect_chance, int no_corr, unsigned char begin, unsigned char end=0); static bool make_room(int sx,int sy,int ex,int ey,int max_doors, int doorlevel); -static void join_the_dots(unsigned char dotx1, unsigned char doty1, - unsigned char dotx2, unsigned char doty2, char forbid_x1, char forbid_y1, - char forbid_x2, char forbid_y2); static void place_pool(unsigned char pool_type, unsigned char pool_x1, unsigned char pool_y1, unsigned char pool_x2, unsigned char pool_y2); static void many_pools(unsigned char pool_type); +static void join_the_dots( + const coord_def &from, + const coord_def &to, + const dgn_region_list &forbidden); -#ifdef USE_RIVERS static void build_river(unsigned char river_type); //mv static void build_lake(unsigned char lake_type); //mv -#endif // USE_RIVERS static void spotty_level(bool seeded, int iterations, bool boxy); static void bigger_room(void); @@ -148,7 +148,7 @@ static void build_minivaults(int level_number, int force_vault); static int vault_grid( int level_number, int vx, int vy, int altar_count, FixedVector < char, 7 > &acq_item_class, FixedVector < int, 7 > &mons_array, - char vgrid, int &initial_x, int &initial_y, + char vgrid, std::vector<coord_def> &targets, int force_vault, int &num_runes ); // ALTAR FUNCTIONS @@ -3738,7 +3738,9 @@ static int builder_by_type(int level_number, char level_type) you.unique_creatures[40 + which_demon] = 1; const int vault = - random_map_for_tag(pandemon_level_names[(int) which_demon]); + random_map_for_tag( + pandemon_level_names[(int) which_demon], + false); ASSERT(vault != -1); if (vault == -1) @@ -3753,7 +3755,7 @@ static int builder_by_type(int level_number, char level_type) else { plan_main(level_number, 0); - int vault = random_map_for_tag("pan"); + int vault = random_map_for_tag("pan", true); ASSERT( vault != -1 ); if (vault == -1) { @@ -3770,25 +3772,48 @@ static int builder_by_type(int level_number, char level_type) return 0; } -// returns 1 if we should skip further generation, -// -1 if we should immediately quit, and 0 otherwise. -static int builder_by_branch(int level_number) +static int random_map_for_dlevel(int level_number) { int subdepth = subdungeon_depth(you.where_are_you, level_number); const std::string name = level_name(subdepth); std::string altname; + // This dodge allows designers to specify PLACE: as Elf:$ or Slime:$ or + // whatever:$ to say "last level in branch 'whatever'". if (subdepth == branch_depth( branch_stair(you.where_are_you) )) altname = level_name(0); int vault = random_map_for_place(name); + if (vault == -1) vault = random_map_for_place(altname); + + if (vault == -1 + && you.where_are_you == BRANCH_MAIN_DUNGEON + && level_number == 0) + { + vault = random_map_for_tag("entry", false); + } + + return (vault); +} + +// returns 1 if we should skip further generation, +// -1 if we should immediately quit, and 0 otherwise. +static int builder_by_branch(int level_number) +{ + const int vault = random_map_for_dlevel(level_number); if (vault != -1) { build_vaults(level_number, vault); - // [dshaligram] XXX: Is link_items() needed for all vaults? + + // link_items() is only needed if we're going to bypass the + // rest of the dungeon generation process (previously done + // only for the Vestibule of Hell). We really don't need it + // any more since we use the regular generation process even + // for the Vestibule (the Vestibule now also gets random + // monsters in addition to the loser Geryon). link_items(); return 1; } @@ -3832,9 +3857,7 @@ static int builder_normal(int level_number, char level_type, spec_room &sr) bool skipped = false; bool done_city = false; - int vault = random_map_for_place( - level_name( - subdungeon_depth(you.where_are_you, level_number))); + int vault = random_map_for_dlevel(level_number); if (vault == -1 && player_in_branch( BRANCH_MAIN_DUNGEON ) @@ -4056,7 +4079,6 @@ static void builder_extras( int level_number, int level_type ) return; } -#ifdef USE_RIVERS //mv: it's better to be here so other dungeon features // are not overriden by water int river_type = one_chance_in( 5 + level_number ) ? DNGN_SHALLOW_WATER @@ -4095,7 +4117,6 @@ static void builder_extras( int level_number, int level_type ) build_lake( (river_type != DNGN_SHALLOW_WATER) ? river_type : DNGN_DEEP_WATER ); } -#endif // USE_RIVERS } static void place_traps(int level_number) @@ -5282,7 +5303,7 @@ static void build_minivaults(int level_number, int force_vault) } // these two are throwaways: - int initial_x, initial_y; + std::vector<coord_def> dummy; int num_runes = 0; // paint the minivault onto the grid @@ -5292,12 +5313,163 @@ static void build_minivaults(int level_number, int force_vault) { altar_count = vault_grid( level_number, vx, vy, altar_count, acq_item_class, mons_array, - grd[vx][vy], initial_x, initial_y, + grd[vx][vy], dummy, force_vault, num_runes ); } } } // end build_minivaults() +static void build_rooms(const dgn_region_list &excluded, + const std::vector<coord_def> &connections_needed, + int nrooms) +{ + int which_room = 0; + const bool exclusive = !one_chance_in(10); + + // Where did this magic number come from? + const int maxrooms = 30; + dgn_region rom[maxrooms]; + + std::vector<coord_def> connections = connections_needed; + + for (int i = 0; i < nrooms; i++) + { + dgn_region &myroom = rom[which_room]; + do + { + myroom.pos.set(10 + random2(50), 10 + random2(40)); + myroom.size.set(3 + random2(8), 3 + random2(8)); + } + while (myroom.overlaps_any(excluded)); + + if (connections.size()) + { + const coord_def c = connections[0]; + connections.erase( connections.begin() ); + coord_def edge = myroom.random_edge_point(); + join_the_dots(c, myroom.random_edge_point(), excluded); + } + else if (exclusive) + { + const coord_def end = myroom.end(); + bool found_collision = false; + for (int cnx = myroom.pos.x - 1; + cnx < end.x && !found_collision; + cnx++) + { + for (int cny = myroom.pos.y - 1; + cny < end.y; + cny++) + { + if (grd[cnx][cny] != DNGN_ROCK_WALL) + { + found_collision = true; + break; + } + } + } + + if (found_collision) + continue; + } + + const coord_def end = myroom.end(); + replace_area(myroom.pos.x, myroom.pos.y, end.x, end.y, + DNGN_ROCK_WALL, DNGN_FLOOR); + + if (which_room > 0) // && !exclusive2 + { + join_the_dots( + myroom.random_edge_point(), + rom[which_room - 1].random_edge_point(), + excluded ); + } + + which_room++; + + if (which_room >= maxrooms) + break; + } +} + +static void dig_away_from(const vault_placement &place, const coord_def &pos) +{ + // Figure out which way we need to go to dig our way out of the vault. + const bool x_edge = + pos.x == place.x || pos.x == place.x + place.width - 1; + const bool y_edge = + pos.y == place.y || pos.y == place.y + place.height - 1; + + coord_def dig_dir; + if (x_edge) + dig_dir.x = pos.x == place.x? -1 : 1; + + if (y_edge) + dig_dir.y = pos.y == place.y? -1 : 1; + + coord_def dig_at = pos; + bool dug = false; + for (int i = 0; i < GXM; i++) + { + dig_at += dig_dir; + + if (dig_at.x < 10 || dig_at.x > (GXM - 10) + || dig_at.y < 10 || dig_at.y > (GYM - 10)) + { + break; + } + + if (grd(dig_at) == DNGN_ROCK_WALL) + { + grd(dig_at) = DNGN_FLOOR; + dug = true; + } + else if (dug && grd(dig_at) == DNGN_FLOOR) + break; + } +} + +static void dig_vault_loose( + const vault_placement &place, + std::vector<coord_def> &targets) +{ + for (int i = 0, size = targets.size(); i < size; ++i) + dig_away_from(place, targets[i]); +} + +static void pick_float_exits(const vault_placement &place, + std::vector<coord_def> &targets) +{ + std::vector<coord_def> possible_exits; + for (int y = place.y; y < place.y + place.height; ++y) + { + if (!grid_is_solid(place.x, y)) + possible_exits.push_back( coord_def(place.x, y) ); + if (!grid_is_solid(place.x + place.width - 1, y)) + possible_exits.push_back( coord_def(place.x + place.width - 1, y) ); + } + + for (int x = place.x + 1; x < place.x + place.width - 1; ++x) + { + if (!grid_is_solid(x, place.y)) + possible_exits.push_back( coord_def(x, place.y) ); + if (!grid_is_solid(x, place.y + place.height - 1)) + possible_exits.push_back( + coord_def(x, place.y + place.height - 1) ); + } + + if (possible_exits.empty()) + return; + + int nexits = possible_exits.size() / 10 + 1; + while (nexits-- > 0) + { + int which_exit = random2( possible_exits.size() ); + targets.push_back( possible_exits[which_exit] ); + possible_exits.erase( possible_exits.begin() + which_exit ); + } +} + static void build_vaults(int level_number, int force_vault) { // for some weird reason can't put a vault on level 1, because monster equip @@ -5306,7 +5478,7 @@ static void build_vaults(int level_number, int force_vault) int altar_count = 0; FixedVector < char, 10 > stair_exist; char stx, sty; - int initial_x=0, initial_y=0; + std::vector<coord_def> target_connections; FixedVector < char, 7 > acq_item_class; // hack - passing chars through '...' promotes them to ints, which @@ -5327,13 +5499,6 @@ static void build_vaults(int level_number, int force_vault) RANDOM_MONSTER, RANDOM_MONSTER); - int roomsss = 10 + random2(90); - int which_room = 0; - - bool exclusive = (one_chance_in(10) ? false : true); - - //bool exclusive2 = coinflip(); // usage commented out below {dlb} - map_type vgrid; vault_placement place; @@ -5341,14 +5506,6 @@ static void build_vaults(int level_number, int force_vault) vault_main(vgrid, mons_array, place, force_vault, level_number); int vx, vy; - int v1x = 0, v1y = 0, v2x = 0, v2y = 0; - - //int item_made; - - char dig_dir_x = 0; - char dig_dir_y = 0; - char dig_place_x = 0; - char dig_place_y = 0; int num_runes = 0; // note: assumes *no* previous item (I think) or monster (definitely) @@ -5359,7 +5516,8 @@ static void build_vaults(int level_number, int force_vault) { altar_count = vault_grid( level_number, vx, vy, altar_count, acq_item_class, mons_array, - vgrid[vy][vx], initial_x, initial_y, + vgrid[vy][vx], + target_connections, force_vault, num_runes ); } } @@ -5368,135 +5526,47 @@ static void build_vaults(int level_number, int force_vault) if (gluggy == MAP_ENCOMPASS) return; - // Figure out which way we need to go to dig our way out of the vault. - const bool x_edge = - initial_x == place.x || initial_x == place.x + place.width - 1; - const bool y_edge = - initial_y == place.y || initial_y == place.y + place.height - 1; - - if (x_edge) - { - dig_dir_x = place.x == 0? 1 : -1; - initial_x += dig_dir_x; - } - - if (y_edge) - { - dig_dir_y = place.y == 0? 1 : -1; - initial_y += dig_dir_y; - } + if (gluggy == MAP_FLOAT && target_connections.empty()) + pick_float_exits(place, target_connections); // Does this level require Dis treatment (metal wallification)? // XXX: Change this so the level definition can explicitly state what // kind of wallification it wants. const bool dis_wallify = place.map->has_tag("dis"); - v1x = place.x + 1; - v1y = place.y + 1; - v2x = place.x + place.width; - v2y = place.y + place.height; + const int v1x = place.x + 1; + const int v1y = place.y + 1; + const int v2x = place.x + place.width; + const int v2y = place.y + place.height; #ifdef DEBUG_DIAGNOSTICS mprf(MSGCH_DIAGNOSTICS, - "Vault: (%d,%d)-(%d,%d), exit (%d,%d), dir (%d,%d); Dis: %s", - v1x, v1y, v2x, v2y, initial_x, initial_y, dig_dir_x, dig_dir_y, + "Vault: (%d,%d)-(%d,%d); Dis: %s", + v1x, v1y, v2x, v2y, dis_wallify? "yes" : "no"); #endif if (dis_wallify) { plan_4(v1x, v1y, v2x, v2y, DNGN_METAL_WALL); - goto vstair; - } - - char cnx, cny; - char romx1[30], romy1[30], romx2[30], romy2[30]; - - for (i = 0; i < roomsss; i++) - { - do - { - romx1[which_room] = 10 + random2(50); - romy1[which_room] = 10 + random2(40); - romx2[which_room] = romx1[which_room] + 2 + random2(8); - romy2[which_room] = romy1[which_room] + 2 + random2(8); - } - while ((romx1[which_room] >= v1x && romx1[which_room] <= v2x - && romy1[which_room] >= v1y && romy1[which_room] <= v2y) - || (romx2[which_room] >= v1x && romx2[which_room] <= v2x - && romy2[which_room] >= v1y && romy2[which_room] <= v2y)); - - if (i == 0) - { - join_the_dots(initial_x, initial_y, romx1[which_room], romy1[which_room], - v1x, v1y, v2x, v2y); - } - else if (exclusive) - { - for (cnx = romx1[which_room] - 1; cnx < romx2[which_room] + 1; - cnx++) - { - for (cny = romy1[which_room] - 1; cny < romy2[which_room] + 1; - cny++) - { - if (grd[cnx][cny] != DNGN_ROCK_WALL) - goto continuing; - } - } - } - - replace_area(romx1[which_room], romy1[which_room], romx2[which_room], - romy2[which_room], DNGN_ROCK_WALL, DNGN_FLOOR); - - if (which_room > 0) // && !exclusive2 - { - const int rx1 = romx1[which_room]; - const int rx2 = romx2[which_room]; - const int prev_rx1 = romx1[which_room - 1]; - const int prev_rx2 = romx2[which_room - 1]; - - const int ry1 = romy1[which_room]; - const int ry2 = romy2[which_room]; - const int prev_ry1 = romy1[which_room - 1]; - const int prev_ry2 = romy2[which_room - 1]; - - join_the_dots( rx1 + random2( rx2 - rx1 ), - ry1 + random2( ry2 - ry1 ), - prev_rx1 + random2( prev_rx2 - prev_rx1 ), - prev_ry1 + random2( prev_ry2 - prev_ry1 ), - v1x, v1y, v2x, v2y); - } - - which_room++; - - if (which_room >= 29) - break; - - continuing: - continue; // next i loop - } - - vstair: - dig_place_x = initial_x; - dig_place_y = initial_y; - - if (!dis_wallify) + else { - for (i = 0; i < 40; i++) - { - dig_place_x += dig_dir_x; - dig_place_y += dig_dir_y; + dgn_region_list excluded_regions; + excluded_regions.push_back( + dgn_region::absolute(v1x, v1y, v2x, v2y)); - if (dig_place_x < 10 || dig_place_x > (GXM - 10) - || dig_place_y < 10 || dig_place_y > (GYM - 10)) - { - break; - } + int nrooms = random_range(15, 90); + + // Try harder for floating vaults, which tend to complicate room + // building somewhat. + if (gluggy == MAP_FLOAT) + nrooms += 10; + + build_rooms(excluded_regions, target_connections, nrooms); - if (grd[dig_place_x][dig_place_y] == DNGN_ROCK_WALL) - grd[dig_place_x][dig_place_y] = DNGN_FLOOR; - } + // Excavate and connect the vault to the rest of the level. + dig_vault_loose(place, target_connections); } unsigned char pos_x, pos_y; @@ -5529,8 +5599,8 @@ static void build_vaults(int level_number, int force_vault) { for (i = 0; i < 2; i++) { - - if (stair_exist[(82 + j + (i * 4)) - 82] == 1) // does this look funny to *you*? {dlb} + // does this look funny to *you*? {dlb} + if (stair_exist[(82 + j + (i * 4)) - 82] == 1) continue; do @@ -5554,7 +5624,8 @@ static void build_vaults(int level_number, int force_vault) static int vault_grid( int level_number, int vx, int vy, int altar_count, FixedVector < char, 7 > &acq_item_class, FixedVector < int, 7 > &mons_array, - char vgrid, int &initial_x, int &initial_y, + char vgrid, + std::vector<coord_def> &targets, int force_vault, int &num_runes) { int not_used; @@ -5605,8 +5676,7 @@ static int vault_grid( int level_number, int vx, int vy, int altar_count, altar_count++; break; case '@': - initial_x = vx; - initial_y = vy; + targets.push_back( coord_def(vx, vy) ); break; case '^': place_specific_trap(vx, vy, TRAP_RANDOM); @@ -5747,68 +5817,74 @@ static void replace_area(int sx, int sy, int ex, int ey, unsigned char replace, grd[x][y] = feature; } -static void join_the_dots(unsigned char dotx1, unsigned char doty1, - unsigned char dotx2, unsigned char doty2, - char forbid_x1, char forbid_y1, char forbid_x2, - char forbid_y2) +// With apologies to Metallica. +static bool unforbidden(const coord_def &c, const dgn_region_list &forbidden) { - if (dotx1 == dotx2 && doty1 == doty2) - return; + for (dgn_region_list::const_iterator i = forbidden.begin(); + i != forbidden.end(); ++i) + { + if (i->contains(c)) + return (false); + } + + return (true); +} - char atx = dotx1, aty = doty1; +static void join_the_dots( + const coord_def &from, + const coord_def &to, + const dgn_region_list &forbidden) +{ + if (from == to) + return; int join_count = 0; - grd[atx][aty] = DNGN_FLOOR; - + coord_def at = from; do { join_count++; + grd(at) = DNGN_FLOOR; if (join_count > 10000) // just insurance return; - if (atx < dotx2 - && (forbid_x1 == 0 - || (atx + 1 < forbid_x1 || atx + 1 > forbid_x2 - || (aty > forbid_y2 || aty < forbid_y1)))) + if (at.x < to.x + && unforbidden(coord_def(at.x + 1, at.y), forbidden)) { - atx++; - goto continuing; + at.x++; + continue; } - if (atx > dotx2 - && (forbid_x2 == 0 - || (atx - 1 > forbid_x2 || atx - 1 < forbid_x1 - || (aty > forbid_y2 || aty < forbid_y1)))) + if (at.x > to.x + && unforbidden(coord_def(at.x - 1, at.y), forbidden)) { - atx--; - goto continuing; + at.x--; + continue; } - if (aty > doty2 - && (forbid_y2 == 0 - || (aty - 1 > forbid_y2 || aty - 1 < forbid_y1 - || (atx > forbid_x2 || atx < forbid_x1)))) + if (at.y > to.y + && unforbidden(coord_def(at.x, at.y - 1), forbidden)) { - aty--; - goto continuing; + at.y--; + continue; } - if (aty < doty2 - && (forbid_y1 == 0 - || (aty + 1 < forbid_y1 || aty + 1 > forbid_y2 - || (atx > forbid_x2 || atx < forbid_x1)))) + if (at.y < to.y + && unforbidden(coord_def(at.x, at.y + 1), forbidden)) { - aty++; - goto continuing; + at.y++; + continue; } - continuing: - grd[atx][aty] = DNGN_FLOOR; - + // If we get here, no progress can be made anyway. Why use the + // join_count insurance? + break; } - while (atx != dotx2 || aty != doty2); + while (at != to && in_bounds(at)); + + if (in_bounds(at)) + grd(at) = DNGN_FLOOR; } // end join_the_dots() static void place_pool(unsigned char pool_type, unsigned char pool_x1, @@ -7158,11 +7234,11 @@ static char plan_3(void) const int prev_ry1 = romy1[which_room - 1]; const int prev_ry2 = romy2[which_room - 1]; - join_the_dots( rx1 + random2( rx2 - rx1 ), - ry1 + random2( ry2 - ry1 ), - prev_rx1 + random2( prev_rx2 - prev_rx1 ), - prev_ry1 + random2( prev_ry2 - prev_ry1 ), - 0, 0, 0, 0 ); + join_the_dots( coord_def(rx1 + random2( rx2 - rx1 ), + ry1 + random2( ry2 - ry1 )), + coord_def(prev_rx1 + random2(prev_rx2 - prev_rx1), + prev_ry1 + random2(prev_ry2 - prev_ry1)), + dgn_region_list() ); } which_room++; @@ -7190,11 +7266,12 @@ static char plan_3(void) const int prev_ry1 = romy1[i - 1]; const int prev_ry2 = romy2[i - 1]; - join_the_dots( rx1 + random2( rx2 - rx1 ), - ry1 + random2( ry2 - ry1 ), - prev_rx1 + random2( prev_rx2 - prev_rx1 ), - prev_ry1 + random2( prev_ry2 - prev_ry1 ), - 0, 0, 0, 0 ); + join_the_dots( coord_def( rx1 + random2( rx2 - rx1 ), + ry1 + random2( ry2 - ry1 ) ), + coord_def( + prev_rx1 + random2( prev_rx2 - prev_rx1 ), + prev_ry1 + random2( prev_ry2 - prev_ry1 ) ), + dgn_region_list() ); } } } @@ -7321,9 +7398,10 @@ static char plan_5(void) for (unsigned char i = 0; i < imax; i++) { - join_the_dots( random2(GXM - 20) + 10, random2(GYM - 20) + 10, - random2(GXM - 20) + 10, random2(GYM - 20) + 10, - 0, 0, 0, 0 ); + join_the_dots( + coord_def( random2(GXM - 20) + 10, random2(GYM - 20) + 10 ), + coord_def( random2(GXM - 20) + 10, random2(GYM - 20) + 10 ), + dgn_region_list() ); } if (!one_chance_in(4)) @@ -8541,8 +8619,6 @@ void define_zombie( int mid, int ztype, int cs, int power ) menv[mid].colour = mons_class_colour(cs); } // end define_zombie() -#ifdef USE_RIVERS - static void build_river( unsigned char river_type ) //mv { int i,j; @@ -8651,4 +8727,40 @@ static void build_lake(unsigned char lake_type) //mv } } // end lake() -#endif // USE_RIVERS + +//////////////////////////////////////////////////////////////////// +// dgn_region + +bool dgn_region::overlaps(const dgn_region &other) const +{ + // The old overlap check checked only two corners - top-left and + // bottom-right. I'm hoping nothing actually *relied* on that stupid bug. + + return (between(pos.x, other.pos.x, other.pos.x + other.size.x - 1) + || between(pos.x + size.x - 1, other.pos.x, + other.pos.x + other.size.x - 1)) + && (between(pos.y, other.pos.y, other.pos.y + other.size.y - 1) + || between(pos.y + size.y - 1, other.pos.y, + other.pos.y + other.size.y - 1)); +} + +bool dgn_region::overlaps_any(const dgn_region_list ®ions) const +{ + for (dgn_region_list::const_iterator i = regions.begin(); + i != regions.end(); ++i) + { + if (overlaps(*i)) + return (true); + } + return (false); +} + +coord_def dgn_region::random_edge_point() const +{ + return random2(size.x + size.y) < size.x? + coord_def( random_range( pos.x, pos.x + size.x - 1 ), + coinflip()? pos.y : pos.y + size.y - 1 ) + : + coord_def( coinflip()? pos.x : pos.x + size.x - 1, + random_range( pos.y, pos.y + size.y - 1 ) ); +} diff --git a/crawl-ref/source/dungeon.h b/crawl-ref/source/dungeon.h index 4252b8f6cc..66b73d26ad 100644 --- a/crawl-ref/source/dungeon.h +++ b/crawl-ref/source/dungeon.h @@ -66,4 +66,54 @@ void place_spec_shop(int level_number, unsigned char shop_x, unsigned char shop_y, unsigned char force_s_type, bool representative = false ); +class dgn_region; +typedef std::vector<dgn_region> dgn_region_list; + +struct dgn_region +{ + // pos is top-left corner. + coord_def pos, size; + + dgn_region(int left, int top, int width, int height) + : pos(left, top), size(width, height) + { + } + + dgn_region() : pos(-1, -1), size() + { + } + + coord_def end() const + { + return pos + size - coord_def(1, 1); + } + + coord_def random_edge_point() const; + + static dgn_region absolute(int left, int top, int right, int bottom) + { + return dgn_region(left, top, right - left + 1, bottom - top + 1); + } + + static bool between(int val, int low, int high) + { + return (val >= low && val <= high); + } + + bool contains(const coord_def &p) const + { + return (p.x >= pos.x && p.x < pos.x + size.x + && p.y >= pos.y && p.y < pos.y + size.y); + } + + bool fully_contains(const coord_def &p) const + { + return (p.x > pos.x && p.x < pos.x + size.x - 1 + && p.y >= pos.y && p.y < pos.y + size.y - 1); + } + + bool overlaps(const dgn_region &other) const; + bool overlaps_any(const dgn_region_list &others) const; +}; + #endif diff --git a/crawl-ref/source/enum.h b/crawl-ref/source/enum.h index 62aa3bd18c..38fd6b3846 100644 --- a/crawl-ref/source/enum.h +++ b/crawl-ref/source/enum.h @@ -1176,10 +1176,10 @@ enum enchant_type ENCH_YOUR_POISON_II, ENCH_YOUR_POISON_III, ENCH_YOUR_POISON_IV, // 10 - ENCH_YOUR_SHUGGOTH_I, //jmf: Shuggothim! - ENCH_YOUR_SHUGGOTH_II, - ENCH_YOUR_SHUGGOTH_III, - ENCH_YOUR_SHUGGOTH_IV, + ENCH_BERSERK_I, + ENCH_BERSERK_II, + ENCH_BERSERK_III, + ENCH_BERSERK_IV, ENCH_YOUR_ROT_I, // 15 //jmf: rotting effect for monsters ENCH_YOUR_ROT_II, ENCH_YOUR_ROT_III, @@ -1698,7 +1698,13 @@ enum map_section_type // see maps.cc and dungeon.cc {dlb} MAP_NORTHEAST, MAP_SOUTHWEST, MAP_SOUTHEAST, - MAP_ENCOMPASS + MAP_ENCOMPASS, + + // A "floating" vault is placed somewhat like a minivault, away from + // the edges, although in other respects it behaves like a regular vault. + MAP_FLOAT, + + MAP_NUM_SECTION_TYPES }; enum menu_type @@ -2314,7 +2320,7 @@ enum monster_flag_type MF_INTERESTING = 0x20, // Player finds monster interesting MF_SEEN = 0x40, // Player already seen monster - MF_UNUSED_I = 0x80 + MF_DIVINE_PROTECTION = 0x80 // Monster has divine protection. }; enum mon_dam_level_type @@ -2436,6 +2442,12 @@ enum mon_spell_type MS_POISON_ARROW, // 60 MS_SUMMON_SMALL_MAMMALS, MS_SUMMON_MUSHROOMS, + + MS_BERSERK_RAGE, + MS_MIGHT, + MS_MAKHLEB_MINOR_DESTRUCTION, + MS_MAKHLEB_MAJOR_DESTRUCTION, + // XXX: before adding more monster versions of player spells we should // consider merging the two lists into one and just having monsters // fail to implement the ones that are impractical. diff --git a/crawl-ref/source/externs.h b/crawl-ref/source/externs.h index b6254e7e76..a502a47c46 100644 --- a/crawl-ref/source/externs.h +++ b/crawl-ref/source/externs.h @@ -109,7 +109,15 @@ struct coord_def int x; int y; - // coord_def( int x_in, int y_in ) : x(x_in), y(y_in) {}; + coord_def( int x_in, int y_in ) : x(x_in), y(y_in) { } + coord_def() : x(0), y(0) { } + + void set(int xi, int yi) + { + x = xi; + y = yi; + } + bool operator == (const coord_def &other) const { return x == other.x && y == other.y; } @@ -121,6 +129,30 @@ struct coord_def bool operator < (const coord_def &other) const { return (x < other.x) || (x == other.x && y < other.y); } + + const coord_def &operator += (const coord_def &other) { + x += other.x; + y += other.y; + return (*this); + } + + const coord_def &operator -= (const coord_def &other) { + x -= other.x; + y -= other.y; + return (*this); + } + + coord_def operator + (const coord_def &other) const { + coord_def copy = *this; + copy += other; + return (copy); + } + + coord_def operator - (const coord_def &other) const { + coord_def copy = *this; + copy -= other; + return (copy); + } }; struct dice_def @@ -570,13 +602,15 @@ struct monsters unsigned int behaviour; unsigned int foe; FixedVector<unsigned int, NUM_MON_ENCHANTS> enchantment; - unsigned char flags; // bitfield of boolean flags + unsigned long flags; // bitfield of boolean flags unsigned int number; // #heads (hydra), etc. int colour; int foe_memory; // how long to 'remember' foe x,y // once they go out of sight + + god_type god; // Usually GOD_NO_GOD. }; struct cloud_struct diff --git a/crawl-ref/source/items.cc b/crawl-ref/source/items.cc index e8863eefd1..8f7dbe944c 100644 --- a/crawl-ref/source/items.cc +++ b/crawl-ref/source/items.cc @@ -2086,13 +2086,6 @@ static void update_enchantments( struct monsters *mon, int levels ) remove_enchant_levels( mon, i, ENCH_YOUR_POISON_I, levels ); break; - case ENCH_YOUR_SHUGGOTH_I: - case ENCH_YOUR_SHUGGOTH_II: - case ENCH_YOUR_SHUGGOTH_III: - case ENCH_YOUR_SHUGGOTH_IV: - remove_enchant_levels( mon, i, ENCH_YOUR_SHUGGOTH_I, levels ); - break; - case ENCH_YOUR_ROT_I: case ENCH_YOUR_ROT_II: case ENCH_YOUR_ROT_III: @@ -2128,18 +2121,6 @@ static void update_enchantments( struct monsters *mon, int levels ) remove_enchant_levels( mon, i, ENCH_STICKY_FLAME_I, levels ); break; - case ENCH_FRIEND_ABJ_I: - case ENCH_FRIEND_ABJ_II: - case ENCH_FRIEND_ABJ_III: - case ENCH_FRIEND_ABJ_IV: - case ENCH_FRIEND_ABJ_V: - case ENCH_FRIEND_ABJ_VI: - if (remove_enchant_levels( mon, i, ENCH_FRIEND_ABJ_I, levels )) - { - monster_die( mon, KILL_RESET, 0 ); - } - break; - case ENCH_ABJ_I: case ENCH_ABJ_II: case ENCH_ABJ_III: @@ -2264,7 +2245,7 @@ void update_level( double elapsedTime ) #if DEBUG_DIAGNOSTICS // probably too annoying even for DEBUG_DIAGNOSTICS snprintf( info, INFO_SIZE, - "mon #%d: range %d; long %d; pos (%d,%d); targ %d(%d,%d); flags %d", + "mon #%d: range %d; long %d; pos (%d,%d); targ %d(%d,%d); flags %ld", m, range, long_time, mon->x, mon->y, mon->foe, mon->target_x, mon->target_y, mon->flags ); diff --git a/crawl-ref/source/mapdef.cc b/crawl-ref/source/mapdef.cc index 84e48329d6..a817cea5c8 100644 --- a/crawl-ref/source/mapdef.cc +++ b/crawl-ref/source/mapdef.cc @@ -8,6 +8,28 @@ #include "mon-util.h" #include "stuff.h" +static const char *map_section_names[] = { + "", + "north", + "south", + "east", + "west", + "northwest", + "northeast", + "southwest", + "southeast", + "encompass", + "float", +}; + +static const char *map_section_name(int msect) +{ + if (msect < 0 || msect >= MAP_NUM_SECTION_TYPES) + return ""; + + return map_section_names[msect]; +} + /////////////////////////////////////////////// // level_range // @@ -52,21 +74,12 @@ int level_range::span() const // map_lines // -map_lines::map_lines() : lines(), map_width(0) +map_lines::map_lines() + : lines(), map_width(0), solid_north(false), solid_east(false), + solid_south(false), solid_west(false), solid_checked(false) { } -map_lines::map_lines(int nlines, ...) : lines(), map_width(0) -{ - va_list args; - va_start(args, nlines); - - for (int i = 0; i < nlines; ++i) - add_line( va_arg(args, const char *) ); - - va_end(args); -} - const std::vector<std::string> &map_lines::get_lines() const { return (lines); @@ -89,6 +102,61 @@ int map_lines::height() const return lines.size(); } +int map_lines::glyph(int x, int y) const +{ + return lines[y][x]; +} + +bool map_lines::is_solid(int gly) const +{ + return (gly == 'x' || gly == 'c' || gly == 'b' || gly == 'v'); +} + +void map_lines::check_borders() +{ + if (solid_checked) + return; + + const int wide = width(), high = height(); + + solid_north = solid_south = true; + for (int x = 0; x < wide && (solid_north || solid_south); ++x) + { + if (solid_north && !is_solid(glyph(x, 0))) + solid_north = false; + if (solid_south && !is_solid(glyph(x, high - 1))) + solid_south = false; + } + + solid_east = solid_west = true; + for (int y = 0; y < high && (solid_east || solid_west); ++y) + { + if (solid_west && !is_solid(glyph(0, y))) + solid_west = false; + if (solid_east && !is_solid(glyph(wide - 1, y))) + solid_east = false; + } + + solid_checked = true; +} + +bool map_lines::solid_borders(map_section_type border) +{ + check_borders(); + switch (border) + { + case MAP_NORTH: return solid_north; + case MAP_SOUTH: return solid_south; + case MAP_EAST: return solid_east; + case MAP_WEST: return solid_west; + case MAP_NORTHEAST: return solid_north && solid_east; + case MAP_NORTHWEST: return solid_north && solid_west; + case MAP_SOUTHEAST: return solid_south && solid_east; + case MAP_SOUTHWEST: return solid_south && solid_west; + default: return (false); + } +} + void map_lines::clear() { lines.clear(); @@ -150,6 +218,8 @@ void map_lines::rotate(bool clockwise) map_width = lines.size(); lines = newlines; + + solid_checked = false; } void map_lines::vmirror() @@ -163,6 +233,8 @@ void map_lines::vmirror() lines[i] = lines[size - 1 - i]; lines[size - 1 - i] = temp; } + + solid_checked = false; } void map_lines::hmirror() @@ -178,6 +250,8 @@ void map_lines::hmirror() s[map_width - 1 - j] = c; } } + + solid_checked = false; } /////////////////////////////////////////////// @@ -210,6 +284,116 @@ bool map_def::is_minivault() const return (orient == MAP_NONE); } +// Tries to dock a floating vault - push it to one edge of the level. +// Docking will only succeed if two contiguous edges are all x/c/b/v +// (other walls prevent docking). If the vault's width is > GXM*2/3, +// it's also eligible for north/south docking, and if the height > +// GYM*2/3, it's eligible for east/west docking. Although docking is +// similar to setting the orientation, it doesn't affect 'orient'. +coord_def map_def::float_dock() +{ + const map_section_type orients[] = + { MAP_NORTH, MAP_SOUTH, MAP_EAST, MAP_WEST, + MAP_NORTHEAST, MAP_SOUTHEAST, MAP_NORTHWEST, MAP_SOUTHWEST }; + map_section_type which_orient = MAP_NONE; + int norients = 0; + + for (unsigned i = 0; i < sizeof(orients) / sizeof(*orients); ++i) + { + if (map.solid_borders(orients[i]) && can_dock(orients[i]) + && one_chance_in(++norients)) + { + which_orient = orients[i]; + } + } + + if (which_orient == MAP_NONE || which_orient == MAP_FLOAT) + return coord_def(-1, -1); + +#ifdef DEBUG_DIAGNOSTICS + mprf(MSGCH_DIAGNOSTICS, "Docking floating vault to %s", + map_section_name(which_orient)); +#endif + return dock_pos(which_orient); +} + +coord_def map_def::dock_pos(map_section_type norient) const +{ + const int minborder = 6; + + switch (norient) + { + case MAP_NORTH: + return coord_def( (GXM - map.width()) / 2, minborder ); + case MAP_SOUTH: + return coord_def( (GXM - map.width()) / 2, + GYM - minborder - map.height() ); + case MAP_EAST: + return coord_def( GXM - minborder - map.width(), + (GYM - map.height()) / 2 ); + case MAP_WEST: + return coord_def( minborder, + (GYM - map.height()) / 2 ); + case MAP_NORTHEAST: + return coord_def( GXM - minborder - map.width(), minborder ); + case MAP_NORTHWEST: + return coord_def( minborder, minborder ); + case MAP_SOUTHEAST: + return coord_def( GXM - minborder - map.width(), + GYM - minborder - map.height() ); + case MAP_SOUTHWEST: + return coord_def( minborder, + GYM - minborder - map.height() ); + default: + return coord_def(-1, -1); + } +} + +bool map_def::can_dock(map_section_type norient) const +{ + switch (norient) + { + case MAP_NORTH: case MAP_SOUTH: + return map.width() > GXM * 2 / 3; + case MAP_EAST: case MAP_WEST: + return map.height() > GYM * 2 / 3; + default: + return (true); + } +} + +coord_def map_def::float_random_place() const +{ + // Try to leave enough around the float for roomification. + int minhborder = MAPGEN_BORDER + 11, + minvborder = minhborder; + + if (GXM - 2 * minhborder < map.width()) + minhborder = (GXM - map.width()) / 2 - 1; + + if (GYM - 2 * minvborder < map.height()) + minvborder = (GYM - map.height()) / 2 - 1; + + return coord_def( + random_range(minhborder, GXM - minhborder - map.width()), + random_range(minvborder, GYM - minvborder - map.height())); +} + +coord_def map_def::float_place() +{ + ASSERT(orient == MAP_FLOAT); + + coord_def pos(-1, -1); + + if (coinflip()) + pos = float_dock(); + + if (pos.x == -1) + pos = float_random_place(); + + return (pos); +} + void map_def::hmirror() { if (!(flags & MAPF_MIRROR_HORIZONTAL)) diff --git a/crawl-ref/source/mapdef.h b/crawl-ref/source/mapdef.h index 9fc686ea94..1bb4650e1d 100644 --- a/crawl-ref/source/mapdef.h +++ b/crawl-ref/source/mapdef.h @@ -13,6 +13,7 @@ #include <vector> #include "enum.h" +#include "externs.h" enum map_flags { MAPF_PANDEMONIUM_VAULT = 0x01, // A pandemonium minivault. @@ -50,6 +51,11 @@ public: int width() const; int height() const; + int glyph(int x, int y) const; + bool is_solid(int gly) const; + + bool solid_borders(map_section_type border); + void resolve(const std::string &fillins); // Make all lines the same length. @@ -66,10 +72,13 @@ public: private: void resolve(std::string &s, const std::string &fill); + void check_borders(); private: std::vector<std::string> lines; int map_width; + bool solid_north, solid_east, solid_south, solid_west; + bool solid_checked; }; class mons_list { @@ -108,7 +117,6 @@ public: public: void init(); - void hmirror(); void vmirror(); void rotate(bool clockwise); @@ -116,6 +124,12 @@ public: void resolve(); void fixup(); + bool can_dock(map_section_type) const; + coord_def dock_pos(map_section_type) const; + coord_def float_dock(); + coord_def float_place(); + coord_def float_random_place() const; + bool is_minivault() const; bool has_tag(const std::string &tag) const; }; diff --git a/crawl-ref/source/maps.cc b/crawl-ref/source/maps.cc index 68d851c596..776049155f 100644 --- a/crawl-ref/source/maps.cc +++ b/crawl-ref/source/maps.cc @@ -32,7 +32,7 @@ static int write_vault(const map_def &mdef, map_type mt, FixedVector<int,7> &marray, vault_placement &); static int apply_vault_definition( - const map_def &def, + map_def &def, map_type map, FixedVector<int,7> &marray, vault_placement &); @@ -90,7 +90,7 @@ static int write_vault(const map_def &mdef, map_type map, map_def def = mdef; resolve_map(def); - return apply_vault_definition(def, map, marray, place); + return (place.orient = apply_vault_definition(def, map, marray, place)); } // Mirror the map if appropriate, resolve substitutable symbols (?), @@ -131,7 +131,7 @@ static void apply_monsters( } } -static void apply_vault_grid(const map_def &def, map_type map, +static void apply_vault_grid(map_def &def, map_type map, vault_placement &place) { const map_lines &ml = def.map; @@ -161,6 +161,16 @@ static void apply_vault_grid(const map_def &def, map_type map, && height < GYM) starty = (GYM - height) / 2; + // Floating maps can go anywhere, ask the map_def to suggest a place. + if (orient == MAP_FLOAT) + { + coord_def where = def.float_place(); + + // No further sanity checks. + startx = where.x; + starty = where.y; + } + const std::vector<std::string> &lines = ml.get_lines(); #ifdef DEBUG_DIAGNOSTICS mprf(MSGCH_DIAGNOSTICS, "Applying %s at (%d,%d), dimensions (%d,%d)", @@ -180,7 +190,7 @@ static void apply_vault_grid(const map_def &def, map_type map, } static int apply_vault_definition( - const map_def &def, + map_def &def, map_type map, FixedVector<int,7> &marray, vault_placement &place) @@ -265,14 +275,14 @@ int random_map_for_depth(int depth, bool want_minivault) return (mapindex); } -int random_map_for_tag(const std::string &tag) +int random_map_for_tag(const std::string &tag, bool want_minivault) { int mapindex = -1; int rollsize = 0; for (unsigned i = 0, size = vdefs.size(); i < size; ++i) { - if (vdefs[i].has_tag(tag)) + if (vdefs[i].has_tag(tag) && vdefs[i].is_minivault() == want_minivault) { rollsize += vdefs[i].chance; @@ -285,8 +295,6 @@ int random_map_for_tag(const std::string &tag) if (mapindex != -1) mprf(MSGCH_DIAGNOSTICS, "Found map %s tagged '%s'", vdefs[mapindex].name.c_str(), tag.c_str()); - else - mprf(MSGCH_DIAGNOSTICS, "No map for tag '%s'", tag.c_str()); #endif return (mapindex); diff --git a/crawl-ref/source/maps.h b/crawl-ref/source/maps.h index 7159448f85..b14ffcd004 100644 --- a/crawl-ref/source/maps.h +++ b/crawl-ref/source/maps.h @@ -20,6 +20,7 @@ struct vault_placement { int x, y; int width, height; + int orient; const map_def *map; vault_placement() @@ -37,7 +38,7 @@ int vault_main(map_type vgrid, int random_map_for_place(const std::string &place, bool mini = false); int find_map_named(const std::string &name); int random_map_for_depth(int depth, bool want_minivault = false); -int random_map_for_tag(const std::string &tag); +int random_map_for_tag(const std::string &tag, bool want_minivault); void add_parsed_map(const map_def &md); void read_maps(); diff --git a/crawl-ref/source/misc.cc b/crawl-ref/source/misc.cc index a30de8f852..7773ca2909 100644 --- a/crawl-ref/source/misc.cc +++ b/crawl-ref/source/misc.cc @@ -162,6 +162,16 @@ bool grid_is_solid( int grid ) return (grid < MINMOVE); } +bool grid_is_solid( int x, int y ) +{ + return (grid_is_solid(grd[x][y])); +} + +bool grid_is_solid(const coord_def &c) +{ + return (grid_is_solid(grd(c))); +} + bool grid_is_water( int grid ) { return (grid == DNGN_SHALLOW_WATER || grid == DNGN_DEEP_WATER); @@ -2178,7 +2188,7 @@ void setup_environment_effects() || (grid == DNGN_SHALLOW_WATER && you.where_are_you == BRANCH_SWAMP)) { - coord_def c = { x, y }; + const coord_def c(x, y); sfx_seeds.push_back(c); } } diff --git a/crawl-ref/source/misc.h b/crawl-ref/source/misc.h index 5e00b7f20a..efc5016a4b 100644 --- a/crawl-ref/source/misc.h +++ b/crawl-ref/source/misc.h @@ -131,6 +131,9 @@ unsigned char trap_category(unsigned char trap_type); bool grid_is_wall(int grid); bool grid_is_opaque(int grid); bool grid_is_solid(int grid); +bool grid_is_solid(int x, int y); +bool grid_is_solid(const coord_def &c); + bool grid_is_water(int grid); bool grid_is_watery( int grid ); god_type grid_altar_god( unsigned char grid ); diff --git a/crawl-ref/source/mon-util.cc b/crawl-ref/source/mon-util.cc index f7f1cb0bb4..9c21739029 100644 --- a/crawl-ref/source/mon-util.cc +++ b/crawl-ref/source/mon-util.cc @@ -285,6 +285,15 @@ unsigned long get_mons_resists(const monsters *mon) return (resists); } +int mons_piety(const monsters *mon) +{ + if (mon->god == GOD_NO_GOD) + return (0); + + // We're open to fine-tuning. + return (mon->hit_dice * 14); +} + unsigned long mons_resist(const monsters *mon, unsigned long flags) { return (get_mons_resists(mon) & flags); @@ -967,7 +976,6 @@ int exper_value( const struct monsters *monster ) case MS_HELLFIRE_BURST: case MS_HELLFIRE: case MS_TORMENT: - case MS_IRON_BOLT: diff += 25; break; @@ -979,6 +987,7 @@ int exper_value( const struct monsters *monster ) case MS_SUMMON_DEMON_GREATER: case MS_BANISHMENT: case MS_CRYSTAL_SPEAR: + case MS_IRON_BOLT: case MS_TELEPORT: case MS_TELEPORT_OTHER: diff += 10; @@ -1139,6 +1148,8 @@ void define_monster(int index) speed = m->speed; + mons.god = GOD_NO_GOD; + switch (mcls) { case MONS_ABOMINATION_SMALL: @@ -1306,7 +1317,7 @@ void define_monster(int index) mons.speed = speed; mons.speed_increment = 70; mons.number = monnumber; - mons.flags = 0; + mons.flags = 0L; mons.colour = col; mons_load_spells( &mons, spells ); diff --git a/crawl-ref/source/monplace.cc b/crawl-ref/source/monplace.cc index 1a601fb7c1..569181f0af 100644 --- a/crawl-ref/source/monplace.cc +++ b/crawl-ref/source/monplace.cc @@ -1271,7 +1271,7 @@ int mons_place( int mon_type, char behaviour, int target, bool summoned, coord_def find_newmons_square(int mons_class, int x, int y) { FixedVector < char, 2 > empty; - coord_def pos = { -1, -1 }; + coord_def pos(-1, -1); empty[0] = 0; empty[1] = 0; diff --git a/crawl-ref/source/overmap.cc b/crawl-ref/source/overmap.cc index 5e1360c427..9a55761e60 100644 --- a/crawl-ref/source/overmap.cc +++ b/crawl-ref/source/overmap.cc @@ -55,8 +55,7 @@ void seen_notable_thing( int which_thing, int x, int y ) if (you.level_type != LEVEL_DUNGEON) return; - coord_def pos = {x, y}; - + const coord_def pos(x, y); const god_type god = grid_altar_god(which_thing); if (god != GOD_NO_GOD) seen_altar( god, pos ); @@ -490,7 +489,7 @@ void seen_altar( god_type god, const coord_def& pos ) void unnotice_altar() { - const coord_def pos = { you.x_pos, you.y_pos }; + const coord_def pos(you.x_pos, you.y_pos); const level_pos curpos(level_id::get_current_level_id(), pos); // Hmm, what happens when erasing a nonexistent key directly? if (altars_present.find(curpos) != altars_present.end()) diff --git a/crawl-ref/source/prebuilt/levcomp.lex.cc b/crawl-ref/source/prebuilt/levcomp.lex.cc index 07ad28b7ac..8512950fbf 100644 --- a/crawl-ref/source/prebuilt/levcomp.lex.cc +++ b/crawl-ref/source/prebuilt/levcomp.lex.cc @@ -2,7 +2,7 @@ /* A lexical scanner generated by flex */ /* Scanner skeleton version: - * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ + * $Header: /cvs/root/flex/flex/skel.c,v 1.2 2004/05/07 00:28:17 jkh Exp $ */ #define FLEX_SCANNER @@ -10,7 +10,7 @@ #define YY_FLEX_MINOR_VERSION 5 #include <stdio.h> -#include <errno.h> + /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ #ifdef c_plusplus @@ -23,9 +23,7 @@ #ifdef __cplusplus #include <stdlib.h> -#ifndef _WIN32 #include <unistd.h> -#endif /* Use prototypes in function declarations. */ #define YY_USE_PROTOS @@ -65,7 +63,6 @@ #define YY_PROTO(proto) () #endif - /* Returned upon end-of-file. */ #define YY_NULL 0 @@ -290,206 +287,443 @@ static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); *yy_cp = '\0'; \ yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 43 -#define YY_END_OF_BUFFER 44 -static yyconst short int yy_acclist[944] = +#define YY_NUM_RULES 63 +#define YY_END_OF_BUFFER 64 +static yyconst short int yy_acclist[2559] = { 0, - 3, 3, 44, 42, 43, 41, 42, 43, 41, 43, - 37, 42, 43, 36, 42, 43, 38, 42, 43, 42, - 43, 42, 43, 42, 43, 42, 43, 42, 43, 42, - 43, 42, 43, 42, 43, 42, 43, 42, 43, 42, - 43, 42, 43, 42, 43, 42, 43, 42, 43, 5, - 42, 43, 42, 43, 42, 43, 3, 42, 43, 3, - 36, 42, 43, 3, 38, 42, 43, 3, 42, 43, - 3, 42, 43, 3, 42, 43, 3, 42, 43, 3, - 42, 43, 3, 42, 43, 3, 42, 43, 3, 42, - 43, 3, 42, 43, 3, 42, 43, 3, 42, 43, - - 3, 42, 43, 3, 42, 43, 3, 42, 43, 3, - 42, 43, 3, 42, 43, 3, 5, 42, 43, 3, - 42, 43, 3, 42, 43, 42, 43, 40, 41, 43, - 41, 42, 43, 37, 42, 43, 36, 42, 43, 38, - 42, 43, 42, 43, 42, 43, 42, 43, 42, 43, - 42, 43, 42, 43, 42, 43, 42, 43, 42, 43, - 42, 43, 42, 43, 42, 43, 42, 43, 42, 43, - 42, 43, 5, 42, 43, 42, 43, 42, 43, 42, - 43, 22, 41, 42, 43, 21, 41, 43, 41, 42, - 43, 20, 37, 42, 43, 36, 42, 43, 38, 42, - - 43, 42, 43, 42, 43, 42, 43, 42, 43, 42, - 43, 42, 43, 42, 43, 42, 43, 42, 43, 42, - 43, 42, 43, 42, 43, 42, 43, 42, 43, 42, - 43, 5, 42, 43, 42, 43, 42, 43, 17, 41, - 42, 43, 18, 41, 43, 41, 42, 43, 16, 36, - 42, 43, 16, 38, 42, 43, 16, 42, 43, 16, - 42, 43, 16, 42, 43, 16, 42, 43, 16, 42, - 43, 16, 42, 43, 16, 42, 43, 16, 42, 43, - 16, 42, 43, 16, 42, 43, 16, 42, 43, 16, - 42, 43, 16, 42, 43, 16, 42, 43, 16, 42, - - 43, 16, 42, 43, 16, 42, 43, 16, 42, 43, - 41, 38, 5, 5, 3, 3, 38, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 5, 2, 5, 3, 5, 3, - 3, 5, 3, 39, 40, 41, 38, 39, 39, 39, - 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, - 39, 39, 39, 39, 5, 39, 5, 39, 5, 39, - 39, 41, 21, 41, 41, 38, 5, 5, 17, 41, - 18, 41, 41, 16, 16, 38, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - - 16, 16, 16, 16, 4, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 4, 3, 5, 39, 39, 39, - 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, - 39, 39, 39, 39, 4, 39, 19, 19, 38, 19, - 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, - 19, 19, 19, 19, 19, 19, 5, 19, 4, 19, - 5, 19, 19, 16, 16, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 4, 16, 30, 31, 3, 3, 3, 3, 3, 3, - - 3, 3, 3, 3, 3, 3, 30, 3, 3, 3, - 3, 3, 3, 3, 3, 31, 39, 39, 39, 39, - 39, 39, 39, 39, 39, 39, 30, 39, 39, 39, - 39, 39, 39, 39, 39, 31, 39, 19, 19, 19, - 19, 19, 19, 19, 19, 19, 19, 19, 30, 19, - 19, 19, 19, 19, 19, 19, 19, 31, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 30, - 16, 16, 16, 16, 16, 16, 16, 16, 31, 15, - 6, 13, 28, 29, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 28, 3, 3, - - 29, 39, 39, 39, 15, 39, 6, 39, 39, 39, - 39, 13, 39, 39, 39, 39, 39, 39, 28, 39, - 39, 29, 39, 19, 19, 19, 15, 19, 6, 19, - 19, 19, 19, 13, 19, 19, 19, 19, 19, 19, - 19, 28, 19, 19, 29, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 28, 16, 16, - 29, 8, 12, 10, 3, 1, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 39, - 8, 39, 12, 39, 39, 10, 39, 39, 39, 39, - 39, 39, 39, 39, 39, 39, 39, 39, 19, 8, - - 19, 12, 19, 19, 10, 19, 19, 19, 19, 19, - 19, 19, 19, 19, 19, 19, 19, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, - 11, 9, 14, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 11, 39, 9, 39, 14, 39, 39, - 39, 39, 39, 39, 39, 39, 39, 39, 39, 11, - 19, 9, 19, 14, 19, 19, 19, 19, 19, 19, - 19, 19, 19, 19, 19, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 39, 39, 39, 39, 39, - - 39, 39, 39, 39, 39, 19, 19, 19, 19, 19, - 19, 19, 19, 19, 19, 16, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 27, 26, 32, 33, 34, - 35, 3, 3, 27, 3, 3, 26, 3, 3, 32, - 3, 33, 3, 3, 34, 3, 35, 39, 27, 39, - 39, 26, 39, 39, 32, 39, 33, 39, 39, 34, - 39, 35, 39, 19, 19, 27, 19, 19, 26, 19, - 19, 32, 19, 33, 19, 19, 34, 19, 35, 16, - 16, 27, 16, 16, 26, 16, 16, 32, 16, 33, - 16, 16, 34, 16, 35, 24, 25, 23, 3, 3, - - 24, 3, 25, 3, 23, 39, 24, 39, 25, 39, - 23, 39, 19, 19, 24, 19, 25, 19, 23, 16, - 16, 24, 16, 25, 16, 23, 3, 39, 19, 16, - 3, 39, 19, 16, 3, 39, 19, 16, 7, 7, - 39, 7, 19 + 3, 3, 64, 62, 63, 57, 62, 63, 57, 63, + 60, 62, 63, 58, 62, 63, 59, 62, 63, 53, + 62, 63, 52, 62, 63, 54, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 5, 62, 63, 62, 63, 62, 63, 3, 62, 63, + 3, 58, 62, 63, 3, 59, 62, 63, 3, 52, + 62, 63, 3, 54, 62, 63, 3, 62, 63, 3, + + 62, 63, 3, 62, 63, 3, 62, 63, 3, 62, + 63, 3, 62, 63, 3, 62, 63, 3, 62, 63, + 3, 62, 63, 3, 62, 63, 3, 62, 63, 3, + 62, 63, 3, 62, 63, 3, 62, 63, 3, 62, + 63, 3, 62, 63, 3, 62, 63, 3, 62, 63, + 3, 62, 63, 3, 62, 63, 3, 62, 63, 3, + 5, 62, 63, 3, 62, 63, 3, 62, 63, 3, + 62, 63, 62, 63, 56, 57, 63, 57, 62, 63, + 60, 62, 63, 58, 62, 63, 59, 62, 63, 53, + 62, 63, 52, 62, 63, 54, 62, 63, 62, 63, + + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 5, 62, 63, 62, 63, 62, 63, 62, 63, 37, + 57, 62, 63, 36, 57, 63, 57, 62, 63, 60, + 62, 63, 58, 62, 63, 59, 62, 63, 35, 53, + 62, 63, 52, 62, 63, 54, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 62, 63, 62, 63, 62, 63, 62, 63, 62, 63, + 5, 62, 63, 62, 63, 62, 63, 32, 57, 62, + 63, 33, 57, 63, 57, 62, 63, 31, 52, 62, + 63, 31, 54, 62, 63, 31, 62, 63, 31, 62, + 63, 31, 62, 63, 31, 62, 63, 31, 62, 63, + 31, 62, 63, 31, 62, 63, 31, 62, 63, 31, + 62, 63, 31, 62, 63, 31, 62, 63, 31, 62, + 63, 31, 62, 63, 31, 62, 63, 31, 62, 63, + 31, 62, 63, 31, 62, 63, 31, 62, 63, 31, + + 62, 63, 31, 62, 63, 31, 62, 63, 31, 62, + 63, 31, 62, 63, 57, 54, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 5, 61, 5, 61, 61, 3, 3, 54, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 5, + + 2, 5, 3, 5, 3, 61, 3, 61, 3, 5, + 3, 61, 3, 61, 3, 61, 55, 56, 57, 54, + 55, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 5, 55, 5, 55, 61, 5, 55, 55, 61, + 55, 61, 57, 36, 57, 57, 54, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 5, 61, 5, 61, 61, 32, 57, 33, + 57, 57, 31, 31, 54, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 61, 61, 61, 61, 61, 24, 61, 61, 61, + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 4, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 24, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 24, 61, 3, 4, + 61, 3, 5, 3, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 24, 55, 61, 55, 61, + + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 4, 55, 61, 34, + 34, 54, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 24, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 5, 34, 4, 34, 61, + 34, 61, 5, 34, 34, 61, 34, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 24, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 4, + 31, 61, 61, 61, 61, 61, 61, 61, 61, 61, + + 61, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 45, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 46, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 45, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 46, 61, 3, 61, 3, 61, 55, 61, 55, 61, + + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 45, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 46, + 55, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + + 34, 61, 34, 61, 34, 61, 34, 45, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 46, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 45, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 46, 61, 61, 61, 61, 61, 18, 61, + + 61, 61, 61, 61, 23, 61, 15, 61, 6, 61, + 61, 61, 61, 61, 61, 61, 13, 61, 61, 51, + 61, 61, 61, 61, 43, 61, 61, 44, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 23, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 51, 61, 3, 61, 3, 61, 3, 61, 3, + 43, 61, 3, 61, 3, 44, 61, 3, 61, 3, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 18, + + 55, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 23, 55, 61, 15, 55, 55, 61, 6, 55, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 13, 55, 55, 61, 55, 61, + 51, 55, 61, 55, 61, 55, 61, 55, 61, 43, + 55, 61, 55, 61, 44, 55, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 18, 34, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 23, 34, 61, + 15, 34, 34, 61, 6, 34, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + + 13, 34, 34, 61, 34, 61, 34, 51, 61, 34, + 61, 34, 61, 34, 61, 34, 43, 61, 34, 61, + 34, 44, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 23, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 51, 61, 31, 61, 31, + 61, 31, 61, 31, 43, 61, 31, 61, 31, 44, + 61, 61, 61, 61, 8, 61, 61, 61, 12, 61, + 61, 61, 10, 61, 61, 61, 61, 61, 61, 61, + + 61, 61, 61, 61, 61, 61, 61, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 1, 3, 61, 55, + 61, 55, 61, 55, 61, 8, 55, 55, 61, 55, + 61, 55, 61, 12, 55, 55, 61, 55, 61, 55, + 61, 10, 55, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 34, 61, 34, 61, 34, 61, 8, + 34, 34, 61, 34, 61, 34, 61, 12, 34, 34, + 61, 34, 61, 34, 61, 10, 34, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 19, 61, 11, 17, 61, + 61, 61, 61, 61, 61, 9, 61, 25, 61, 61, + 14, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 3, 61, 3, 17, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 19, 55, 55, 61, 11, 55, 17, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + + 61, 9, 55, 55, 61, 25, 55, 55, 61, 55, + 61, 14, 55, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 55, 61, 55, 61, 55, 61, 55, + 61, 55, 61, 19, 34, 34, 61, 11, 34, 17, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 9, 34, 34, 61, 25, 34, 34, 61, + 34, 61, 14, 34, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 31, 61, 17, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 61, 31, + 61, 31, 61, 31, 61, 61, 61, 61, 61, 61, + 29, 61, 61, 61, 61, 61, 61, 61, 61, 61, + 61, 61, 61, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 29, 61, 3, 61, 3, + 61, 3, 61, 3, 3, 61, 3, 61, 3, 61, + 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, + 3, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 29, 55, 61, 55, 61, 55, 61, 55, + + 61, 55, 55, 61, 55, 61, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 61, 55, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 29, 34, 61, 34, 61, 34, 61, 34, 61, 34, + 34, 61, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 61, 34, 61, 34, 61, 34, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 29, 31, + 61, 31, 61, 31, 61, 31, 61, 31, 31, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 61, 61, 61, 61, 28, + + 61, 61, 61, 61, 42, 61, 61, 41, 61, 61, + 47, 61, 48, 61, 61, 49, 61, 50, 61, 3, + 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, + 61, 3, 61, 3, 3, 42, 61, 3, 61, 3, + 41, 61, 3, 61, 3, 47, 61, 3, 48, 61, + 3, 61, 3, 49, 61, 3, 50, 61, 55, 61, + 55, 61, 55, 61, 28, 55, 55, 61, 55, 61, + 55, 61, 55, 61, 55, 42, 55, 61, 55, 61, + 41, 55, 61, 55, 61, 47, 55, 61, 48, 55, + 61, 55, 61, 49, 55, 61, 50, 55, 61, 34, + + 61, 34, 61, 34, 61, 28, 34, 34, 61, 34, + 61, 34, 61, 34, 61, 34, 34, 42, 61, 34, + 61, 34, 41, 61, 34, 61, 34, 47, 61, 34, + 48, 61, 34, 61, 34, 49, 61, 34, 50, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 61, 31, 61, 31, 31, 42, 61, 31, 61, + 31, 41, 61, 31, 61, 31, 47, 61, 31, 48, + 61, 31, 61, 31, 49, 61, 31, 50, 61, 16, + 61, 27, 61, 61, 61, 61, 39, 61, 40, 61, + 38, 61, 3, 61, 3, 61, 3, 61, 3, 61, + + 3, 61, 3, 3, 39, 61, 3, 40, 61, 3, + 38, 61, 16, 55, 55, 61, 27, 55, 55, 61, + 55, 61, 55, 61, 55, 61, 55, 39, 55, 61, + 40, 55, 61, 38, 55, 61, 16, 34, 34, 61, + 27, 34, 34, 61, 34, 61, 34, 61, 34, 61, + 34, 34, 39, 61, 34, 40, 61, 34, 38, 61, + 31, 61, 31, 61, 31, 61, 31, 61, 31, 61, + 31, 31, 39, 61, 31, 40, 61, 31, 38, 61, + 30, 61, 61, 26, 61, 20, 3, 30, 61, 3, + 61, 3, 61, 3, 30, 55, 61, 55, 61, 26, + + 55, 55, 61, 20, 55, 55, 30, 34, 61, 34, + 61, 26, 34, 34, 61, 20, 34, 34, 30, 31, + 61, 31, 61, 31, 61, 31, 61, 22, 3, 61, + 3, 55, 61, 22, 55, 55, 34, 61, 22, 34, + 34, 31, 61, 31, 21, 3, 21, 55, 55, 21, + 34, 34, 31, 7, 7, 55, 7, 34 } ; -static yyconst short int yy_accept[798] = +static yyconst short int yy_accept[1350] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, - 3, 4, 6, 9, 11, 14, 17, 20, 22, 24, - 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, - 46, 48, 50, 53, 55, 57, 60, 64, 68, 71, - 74, 77, 80, 83, 86, 89, 92, 95, 98, 101, - 104, 107, 110, 113, 116, 120, 123, 126, 128, 131, - 134, 137, 140, 143, 145, 147, 149, 151, 153, 155, - 157, 159, 161, 163, 165, 167, 169, 171, 173, 176, - 178, 180, 182, 186, 189, 192, 196, 199, 202, 204, - 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, - - 226, 228, 230, 232, 235, 237, 239, 243, 246, 249, - 253, 257, 260, 263, 266, 269, 272, 275, 278, 281, - 284, 287, 290, 293, 296, 299, 302, 305, 308, 311, - 312, 313, 313, 313, 313, 313, 313, 313, 313, 313, - 313, 313, 313, 313, 313, 313, 313, 313, 314, 314, - 315, 315, 316, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 336, 337, 338, 340, 341, 343, 344, 345, 345, - 347, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 367, 368, - - 369, 371, 372, 372, 373, 375, 376, 377, 377, 377, - 377, 377, 377, 377, 377, 377, 377, 377, 377, 377, - 377, 377, 377, 377, 378, 378, 379, 379, 381, 383, - 384, 385, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 405, 405, 405, 405, 405, 405, 405, 405, 405, - 405, 405, 405, 405, 405, 405, 405, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 426, 428, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, - - 440, 441, 442, 443, 444, 445, 447, 448, 450, 451, - 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, - 462, 463, 464, 465, 466, 467, 469, 471, 473, 474, - 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, - 485, 486, 487, 488, 489, 490, 491, 493, 493, 493, - 493, 493, 493, 493, 493, 493, 493, 493, 494, 494, - 494, 494, 494, 494, 494, 494, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 508, 509, - 510, 511, 512, 513, 514, 515, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 529, 530, 531, - - 532, 533, 534, 535, 536, 538, 539, 540, 541, 542, - 543, 544, 545, 546, 547, 548, 550, 551, 552, 553, - 554, 555, 556, 557, 559, 560, 561, 562, 563, 564, - 565, 566, 567, 568, 569, 571, 572, 573, 574, 575, - 576, 577, 578, 580, 580, 580, 580, 581, 582, 582, - 582, 582, 583, 583, 583, 583, 583, 583, 584, 584, - 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, - 595, 596, 597, 599, 600, 602, 603, 604, 605, 607, - 609, 610, 611, 612, 614, 615, 616, 617, 618, 619, - 621, 622, 624, 625, 626, 627, 629, 631, 632, 633, - - 634, 636, 637, 638, 639, 640, 641, 643, 644, 646, - 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, - 657, 659, 660, 662, 662, 663, 664, 664, 665, 665, - 665, 665, 665, 665, 665, 665, 665, 665, 665, 665, - 666, 668, 669, 670, 671, 672, 673, 674, 675, 676, - 677, 678, 679, 680, 681, 683, 685, 686, 688, 689, - 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, - 700, 702, 704, 705, 707, 708, 709, 710, 711, 712, - 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, - 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, - - 733, 734, 734, 734, 734, 734, 734, 734, 734, 734, - 734, 734, 735, 736, 737, 738, 739, 740, 741, 742, - 743, 744, 746, 748, 750, 751, 752, 753, 754, 755, - 756, 757, 758, 759, 760, 762, 764, 766, 767, 768, - 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, - 779, 780, 781, 782, 783, 784, 785, 786, 786, 786, - 786, 786, 786, 786, 786, 786, 786, 786, 787, 788, - 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, - 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, - 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, - - 819, 820, 821, 822, 823, 824, 825, 826, 826, 827, - 827, 828, 828, 829, 830, 830, 831, 832, 833, 835, - 836, 838, 839, 841, 843, 844, 846, 848, 849, 851, - 852, 854, 855, 857, 859, 860, 862, 864, 865, 867, - 868, 870, 871, 873, 875, 876, 878, 880, 881, 883, - 884, 886, 887, 889, 891, 892, 894, 896, 896, 897, - 898, 899, 900, 902, 904, 906, 907, 909, 911, 913, - 914, 916, 918, 920, 921, 923, 925, 927, 927, 928, - 929, 930, 931, 931, 932, 933, 934, 935, 935, 936, - 937, 938, 939, 940, 942, 944, 944 - + 3, 4, 6, 9, 11, 14, 17, 20, 23, 26, + 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, + 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, + 69, 71, 74, 76, 78, 81, 85, 89, 93, 97, + 100, 103, 106, 109, 112, 115, 118, 121, 124, 127, + 130, 133, 136, 139, 142, 145, 148, 151, 154, 157, + 160, 164, 167, 170, 173, 175, 178, 181, 184, 187, + 190, 193, 196, 199, 201, 203, 205, 207, 209, 211, + 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, + + 233, 235, 237, 239, 241, 244, 246, 248, 250, 254, + 257, 260, 263, 266, 269, 273, 276, 279, 281, 283, + 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, + 305, 307, 309, 311, 313, 315, 317, 319, 321, 324, + 326, 328, 332, 335, 338, 342, 346, 349, 352, 355, + 358, 361, 364, 367, 370, 373, 376, 379, 382, 385, + 388, 391, 394, 397, 400, 403, 406, 409, 412, 415, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, + + 446, 447, 448, 450, 452, 454, 456, 458, 460, 462, + 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, + 484, 486, 488, 490, 492, 494, 496, 498, 500, 501, + 502, 503, 505, 507, 509, 511, 513, 515, 517, 518, + 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, + 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, + 558, 560, 562, 564, 566, 568, 570, 572, 574, 575, + 577, 579, 581, 583, 583, 584, 586, 587, 588, 589, + 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, + 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, + + 610, 611, 612, 613, 614, 615, 616, 617, 618, 620, + 622, 623, 624, 626, 628, 630, 632, 634, 636, 638, + 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, + 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, + 680, 682, 683, 684, 685, 686, 687, 689, 690, 691, + 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, + 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, + 712, 713, 715, 717, 719, 721, 723, 725, 728, 730, + 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, + 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, + + 772, 774, 776, 779, 782, 784, 786, 788, 790, 792, + 794, 796, 799, 801, 803, 805, 807, 809, 811, 813, + 815, 817, 819, 821, 823, 825, 827, 829, 831, 833, + 835, 837, 839, 841, 843, 845, 847, 850, 851, 853, + 855, 857, 859, 861, 863, 865, 868, 870, 872, 874, + 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, + 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, + 916, 918, 921, 923, 925, 927, 929, 931, 933, 935, + 937, 939, 942, 944, 946, 948, 950, 952, 954, 956, + 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, + + 978, 980, 982, 984, 986, 988, 990, 993, 994, 995, + 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, + 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, + 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1027, + 1029, 1031, 1033, 1035, 1037, 1039, 1041, 1043, 1045, 1047, + 1049, 1051, 1053, 1055, 1057, 1059, 1061, 1063, 1065, 1067, + 1069, 1071, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, + 1090, 1093, 1095, 1097, 1099, 1101, 1103, 1105, 1107, 1109, + 1111, 1113, 1115, 1117, 1119, 1121, 1123, 1125, 1127, 1129, + 1131, 1133, 1135, 1137, 1139, 1141, 1144, 1146, 1148, 1150, + + 1152, 1154, 1156, 1158, 1160, 1163, 1165, 1167, 1169, 1171, + 1173, 1175, 1177, 1179, 1181, 1183, 1185, 1187, 1189, 1191, + 1193, 1195, 1197, 1199, 1201, 1203, 1205, 1207, 1210, 1212, + 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1229, 1231, 1233, + 1235, 1237, 1239, 1241, 1243, 1245, 1247, 1249, 1251, 1253, + 1255, 1257, 1259, 1261, 1263, 1265, 1267, 1269, 1271, 1273, + 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1295, + 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, + 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, + 1317, 1318, 1319, 1320, 1322, 1323, 1324, 1325, 1327, 1328, + + 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344, 1346, 1348, + 1351, 1353, 1355, 1357, 1359, 1361, 1363, 1365, 1367, 1369, + 1371, 1374, 1376, 1378, 1380, 1383, 1385, 1388, 1390, 1392, + 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 1412, + 1415, 1417, 1419, 1421, 1423, 1425, 1427, 1429, 1431, 1433, + 1435, 1437, 1439, 1441, 1444, 1446, 1448, 1450, 1453, 1455, + 1458, 1460, 1462, 1464, 1466, 1468, 1470, 1472, 1474, 1476, + 1478, 1481, 1483, 1485, 1487, 1489, 1491, 1493, 1495, 1497, + 1499, 1501, 1503, 1505, 1507, 1510, 1512, 1514, 1516, 1519, + 1521, 1524, 1526, 1528, 1530, 1532, 1534, 1536, 1538, 1540, + + 1542, 1545, 1547, 1549, 1551, 1553, 1555, 1557, 1559, 1561, + 1563, 1565, 1568, 1570, 1572, 1574, 1577, 1579, 1582, 1583, + 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, + 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, + 1604, 1605, 1606, 1607, 1608, 1609, 1611, 1613, 1615, 1617, + 1619, 1621, 1623, 1625, 1627, 1629, 1631, 1633, 1635, 1637, + 1639, 1641, 1643, 1645, 1647, 1649, 1651, 1653, 1655, 1657, + 1660, 1662, 1664, 1666, 1668, 1670, 1672, 1674, 1676, 1678, + 1680, 1682, 1684, 1686, 1688, 1690, 1692, 1694, 1696, 1698, + 1700, 1702, 1704, 1706, 1708, 1710, 1712, 1714, 1716, 1718, + + 1720, 1722, 1724, 1726, 1728, 1730, 1732, 1734, 1736, 1738, + 1740, 1742, 1744, 1746, 1748, 1750, 1752, 1754, 1756, 1758, + 1760, 1762, 1764, 1766, 1768, 1770, 1772, 1774, 1776, 1778, + 1780, 1782, 1784, 1786, 1788, 1790, 1792, 1794, 1796, 1798, + 1800, 1802, 1804, 1806, 1808, 1810, 1812, 1814, 1816, 1817, + 1818, 1819, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, + 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, + 1839, 1840, 1841, 1842, 1844, 1847, 1849, 1851, 1853, 1855, + 1857, 1859, 1861, 1863, 1865, 1867, 1869, 1871, 1873, 1875, + 1877, 1879, 1881, 1883, 1885, 1887, 1889, 1892, 1894, 1896, + + 1898, 1900, 1902, 1904, 1906, 1908, 1910, 1912, 1914, 1916, + 1918, 1920, 1922, 1924, 1926, 1928, 1930, 1932, 1934, 1936, + 1938, 1940, 1943, 1945, 1947, 1949, 1951, 1953, 1955, 1957, + 1959, 1961, 1963, 1965, 1967, 1969, 1971, 1973, 1975, 1977, + 1979, 1981, 1983, 1985, 1987, 1990, 1992, 1994, 1996, 1998, + 2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014, 2016, 2018, + 2020, 2022, 2024, 2026, 2027, 2028, 2029, 2030, 2031, 2033, + 2034, 2035, 2036, 2036, 2037, 2038, 2039, 2040, 2041, 2042, + 2043, 2044, 2045, 2047, 2049, 2051, 2053, 2055, 2058, 2060, + 2062, 2064, 2065, 2067, 2069, 2071, 2073, 2075, 2077, 2079, + + 2081, 2083, 2085, 2087, 2089, 2091, 2093, 2096, 2098, 2100, + 2102, 2103, 2105, 2107, 2109, 2111, 2113, 2115, 2117, 2119, + 2121, 2123, 2125, 2127, 2129, 2131, 2134, 2136, 2138, 2140, + 2141, 2143, 2145, 2147, 2149, 2151, 2153, 2155, 2157, 2159, + 2161, 2163, 2165, 2167, 2169, 2172, 2174, 2176, 2178, 2179, + 2181, 2183, 2185, 2187, 2189, 2191, 2193, 2195, 2197, 2198, + 2199, 2200, 2201, 2202, 2203, 2204, 2205, 2205, 2207, 2208, + 2210, 2211, 2213, 2215, 2216, 2218, 2220, 2222, 2224, 2226, + 2228, 2230, 2232, 2234, 2235, 2238, 2240, 2243, 2245, 2248, + 2251, 2253, 2256, 2259, 2261, 2263, 2265, 2267, 2269, 2271, + + 2273, 2275, 2276, 2279, 2281, 2284, 2286, 2289, 2292, 2294, + 2297, 2300, 2302, 2304, 2306, 2308, 2310, 2312, 2314, 2316, + 2317, 2320, 2322, 2325, 2327, 2330, 2333, 2335, 2338, 2341, + 2343, 2345, 2347, 2349, 2351, 2353, 2355, 2356, 2359, 2361, + 2364, 2366, 2369, 2372, 2374, 2377, 2380, 2381, 2382, 2383, + 2384, 2385, 2386, 2387, 2387, 2389, 2391, 2393, 2395, 2397, + 2399, 2401, 2403, 2404, 2407, 2410, 2413, 2415, 2417, 2419, + 2421, 2423, 2425, 2427, 2428, 2431, 2434, 2437, 2439, 2441, + 2443, 2445, 2447, 2449, 2451, 2452, 2455, 2458, 2461, 2463, + 2465, 2467, 2469, 2471, 2472, 2475, 2478, 2481, 2483, 2484, + + 2485, 2486, 2487, 2487, 2490, 2492, 2494, 2495, 2498, 2500, + 2502, 2504, 2506, 2507, 2510, 2512, 2514, 2516, 2518, 2519, + 2522, 2524, 2526, 2527, 2528, 2529, 2529, 2531, 2532, 2534, + 2536, 2537, 2539, 2541, 2542, 2544, 2545, 2546, 2546, 2547, + 2549, 2550, 2552, 2553, 2554, 2555, 2557, 2559, 2559 } ; static yyconst int yy_ec[256] = @@ -497,17 +731,17 @@ static yyconst int yy_ec[256] = 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 1, 1, 5, 6, 6, 6, 1, 6, - 6, 6, 6, 7, 8, 6, 1, 9, 9, 9, - 9, 9, 9, 9, 9, 9, 9, 10, 1, 6, - 6, 6, 6, 6, 11, 12, 13, 14, 15, 16, - 17, 18, 19, 20, 20, 21, 22, 23, 24, 25, - 20, 26, 27, 28, 20, 20, 20, 20, 29, 20, - 6, 1, 6, 6, 30, 1, 31, 20, 32, 33, - - 34, 35, 20, 36, 37, 20, 20, 38, 39, 40, - 41, 42, 20, 43, 44, 45, 46, 47, 48, 20, - 20, 20, 6, 6, 6, 1, 1, 1, 1, 1, + 1, 2, 1, 5, 6, 7, 7, 7, 1, 8, + 9, 7, 7, 10, 11, 7, 1, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 13, 1, 7, + 7, 7, 7, 7, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 23, 30, 31, 32, 33, 34, 23, 35, 36, 23, + 7, 1, 7, 7, 37, 1, 38, 23, 39, 40, + + 41, 42, 23, 43, 44, 23, 23, 45, 46, 47, + 48, 49, 23, 50, 51, 52, 53, 54, 55, 23, + 23, 23, 7, 7, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -524,553 +758,1268 @@ static yyconst int yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst int yy_meta[49] = +static yyconst int yy_meta[56] = { 0, - 1, 1, 2, 3, 4, 4, 3, 5, 5, 1, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5 + 1, 1, 2, 3, 1, 4, 4, 4, 4, 3, + 5, 6, 1, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6 } ; -static yyconst short int yy_base[809] = +static yyconst short int yy_base[1367] = { 0, - 0, 44, 88, 132, 176, 220, 264, 308, 352, 396, - 1529, 1530, 48, 51, 1530, 1530, 1519, 1509, 1511, 1504, - 1500, 1512, 1496, 1500, 1491, 1508, 1484, 25, 1476, 1485, - 1474, 1480, 0, 46, 397, 0, 0, 1504, 1494, 1496, - 1487, 1488, 1484, 1496, 1480, 1484, 1475, 1492, 1468, 27, - 1460, 1469, 1458, 1464, 70, 51, 398, 57, 79, 82, - 74, 136, 137, 140, 141, 145, 146, 149, 224, 153, - 225, 157, 228, 403, 404, 229, 407, 312, 160, 232, - 408, 0, 169, 235, 242, 1530, 0, 1488, 1478, 1480, - 1473, 1469, 1481, 1465, 1469, 1460, 1477, 1453, 29, 1445, - - 1454, 1443, 1449, 244, 141, 409, 255, 315, 318, 0, - 1473, 0, 1463, 1465, 1458, 1454, 1466, 1450, 1454, 1445, - 1462, 1438, 209, 1430, 1439, 1428, 1434, 304, 410, 321, - 1458, 1455, 1440, 1453, 1440, 1440, 1442, 1449, 1437, 1441, - 1422, 1412, 1423, 296, 1414, 1407, 1408, 0, 1426, 0, - 411, 0, 1441, 1438, 1423, 1433, 1435, 1422, 1422, 1424, - 1431, 1419, 1423, 1404, 1394, 1405, 297, 1396, 1389, 1390, - 60, 1530, 249, 331, 1408, 341, 412, 165, 259, 417, - 327, 420, 421, 424, 455, 425, 456, 459, 460, 463, - 464, 428, 469, 472, 477, 481, 482, 345, 485, 486, - - 489, 490, 1430, 494, 501, 504, 335, 498, 508, 510, - 512, 233, 511, 514, 516, 520, 402, 475, 518, 521, - 522, 526, 527, 537, 529, 538, 541, 545, 553, 556, - 0, 1422, 1419, 1404, 1417, 1404, 1404, 1406, 1413, 1401, - 1405, 1386, 1376, 1387, 522, 1378, 1371, 1372, 1390, 531, - 1391, 1385, 1395, 1384, 1395, 1394, 1395, 1395, 1379, 1374, - 1359, 1362, 527, 1357, 1368, 1355, 1354, 1530, 1375, 1369, - 1374, 1378, 1367, 1378, 1377, 1378, 1378, 1362, 1357, 1342, - 1345, 530, 1340, 1351, 1338, 1337, 0, 577, 565, 578, - 587, 588, 592, 593, 596, 599, 608, 612, 615, 616, - - 619, 620, 623, 624, 627, 628, 1379, 559, 530, 574, - 631, 442, 584, 632, 66, 581, 611, 637, 634, 603, - 635, 638, 640, 639, 643, 647, 1378, 657, 648, 1356, - 1350, 1360, 1349, 1360, 1359, 1360, 1360, 1344, 1339, 1324, - 1327, 627, 1322, 1333, 1320, 1319, 0, 1350, 1344, 1334, - 1350, 1349, 1335, 1342, 1332, 1345, 1308, 1530, 1314, 1313, - 1310, 1311, 1313, 1314, 1311, 1530, 1333, 1327, 1333, 1316, - 1332, 1331, 1317, 1324, 1314, 1327, 1290, 0, 1296, 1295, - 1292, 1293, 1295, 1296, 1293, 0, 673, 683, 687, 692, - 693, 696, 702, 703, 706, 707, 711, 716, 719, 720, - - 724, 728, 731, 732, 727, 735, 723, 740, 736, 737, - 644, 678, 688, 741, 738, 1326, 742, 743, 747, 748, - 750, 755, 754, 1325, 1313, 1307, 1297, 1313, 1312, 1298, - 1305, 1295, 1308, 1271, 0, 1277, 1276, 1273, 1274, 1276, - 1277, 1274, 0, 1294, 1298, 1297, 1530, 1530, 1278, 1295, - 1283, 1530, 1265, 1260, 1264, 1255, 1262, 725, 1259, 726, - 1282, 1286, 1270, 1284, 1265, 1282, 1270, 1252, 1247, 1251, - 1242, 1249, 728, 1246, 732, 768, 767, 789, 790, 793, - 794, 798, 799, 802, 803, 807, 808, 811, 814, 819, - 815, 823, 822, 824, 826, 1282, 1281, 812, 828, 827, - - 1280, 830, 831, 829, 833, 837, 841, 840, 842, 1266, - 1270, 1269, 1250, 1267, 1255, 1237, 1232, 1236, 1227, 1234, - 812, 1231, 813, 1259, 1530, 1530, 1258, 1530, 1257, 1221, - 1234, 1221, 1232, 1219, 1230, 1226, 1218, 1227, 1223, 1246, - 0, 1245, 1244, 1208, 1221, 1208, 1219, 1206, 1217, 1213, - 1205, 1214, 1210, 848, 860, 861, 878, 868, 881, 882, - 890, 891, 894, 895, 898, 899, 902, 905, 906, 867, - 1241, 1240, 903, 1239, 909, 879, 650, 656, 885, 910, - 913, 912, 915, 916, 918, 1230, 1229, 1228, 1192, 1205, - 1192, 1203, 1190, 1201, 1197, 1189, 1198, 1194, 1530, 1530, - - 1530, 1219, 1182, 1182, 1179, 1180, 1178, 1177, 1180, 1175, - 1174, 1209, 1172, 1172, 1169, 1170, 1168, 1167, 1170, 1165, - 1164, 924, 928, 933, 937, 946, 953, 947, 956, 957, - 960, 963, 964, 967, 1205, 1204, 1203, 239, 929, 920, - 940, 952, 968, 970, 973, 972, 974, 1196, 1159, 1159, - 1156, 1157, 1155, 1154, 1157, 1152, 1151, 1161, 1149, 1151, - 1157, 1149, 1144, 1143, 1150, 1141, 1140, 1151, 1139, 1141, - 1144, 1133, 1128, 1123, 1121, 1109, 1108, 976, 975, 979, - 987, 982, 996, 1003, 1013, 1020, 1023, 752, 985, 991, - 992, 995, 986, 1000, 1026, 1004, 1008, 1115, 1099, 1090, - - 1094, 1086, 1080, 1079, 1086, 1077, 1076, 1086, 1530, 1076, - 1530, 1075, 1530, 1530, 1085, 1530, 1530, 1082, 0, 1072, - 0, 1071, 0, 0, 1081, 0, 0, 1033, 1036, 1040, - 1050, 1053, 1054, 1057, 1058, 1062, 1067, 1041, 1110, 1031, - 1109, 1037, 1107, 1106, 1044, 1105, 1104, 1071, 0, 1061, - 0, 1060, 0, 0, 1070, 0, 0, 1057, 1530, 1530, - 1530, 1036, 0, 0, 0, 1068, 1075, 1080, 1083, 1049, - 1032, 980, 921, 817, 0, 0, 0, 810, 734, 1084, - 1028, 733, 739, 640, 1090, 1045, 400, 423, 340, 1091, - 1087, 165, 1530, 1096, 161, 1530, 1129, 1131, 1136, 1141, - - 1146, 1151, 1156, 82, 1161, 1166, 1171, 1176 + 0, 50, 101, 151, 202, 252, 303, 353, 404, 454, + 4209, 4210, 55, 58, 4210, 4210, 4210, 4210, 4210, 4196, + 0, 4177, 4185, 4187, 36, 4179, 4185, 4174, 4187, 4170, + 39, 4171, 4162, 4183, 4155, 28, 4150, 4146, 4155, 4144, + 4150, 0, 53, 455, 0, 0, 0, 0, 4178, 71, + 152, 77, 165, 159, 254, 181, 260, 83, 266, 355, + 274, 361, 283, 456, 462, 468, 476, 482, 508, 519, + 372, 526, 534, 557, 66, 176, 193, 70, 91, 160, + 189, 196, 382, 608, 621, 66, 246, 360, 268, 269, + 256, 171, 4159, 366, 371, 145, 464, 229, 474, 348, + + 335, 469, 462, 330, 494, 508, 525, 0, 555, 567, + 575, 0, 0, 0, 4210, 0, 4176, 651, 664, 694, + 715, 733, 519, 554, 557, 553, 560, 572, 566, 606, + 610, 608, 641, 609, 613, 512, 656, 651, 291, 683, + 721, 600, 678, 710, 0, 4175, 4175, 609, 377, 484, + 663, 461, 490, 563, 538, 676, 725, 627, 575, 636, + 58, 714, 674, 682, 720, 697, 721, 743, 759, 771, + 4173, 0, 4170, 4169, 724, 732, 4160, 568, 4147, 4153, + 4153, 4156, 4163, 4154, 4161, 495, 4148, 4153, 4130, 4120, + 4131, 4121, 726, 4121, 4114, 4115, 0, 4136, 0, 4150, + + 760, 0, 4151, 771, 781, 790, 806, 812, 825, 832, + 842, 848, 855, 861, 871, 880, 886, 897, 903, 910, + 925, 931, 937, 943, 949, 955, 962, 972, 399, 4210, + 780, 991, 999, 1011, 1023, 1035, 1041, 1050, 789, 798, + 824, 804, 4132, 828, 860, 958, 792, 707, 970, 633, + 869, 894, 843, 893, 905, 945, 981, 896, 983, 911, + 984, 764, 917, 1023, 854, 1021, 1015, 970, 1028, 1008, + 1061, 1040, 1058, 4159, 1075, 1078, 1083, 1027, 1109, 1122, + 1136, 1150, 1073, 1077, 1146, 1064, 1135, 1154, 1165, 1157, + 1170, 1176, 1181, 1185, 1198, 1184, 1201, 1202, 1205, 1206, + + 1219, 1220, 1226, 1065, 1239, 1087, 1240, 1255, 1260, 1276, + 1285, 0, 4148, 4148, 1089, 1156, 1264, 1102, 507, 1271, + 1060, 1121, 819, 1171, 1208, 1180, 1233, 1212, 1114, 1001, + 1249, 1061, 1167, 1254, 1261, 979, 1115, 1256, 1110, 1283, + 1290, 4131, 4130, 4142, 4123, 4138, 4127, 4122, 4119, 4130, + 4121, 4130, 4116, 4128, 4127, 4128, 4116, 4109, 4117, 4108, + 4124, 4107, 4099, 4084, 4087, 4096, 1260, 4081, 4092, 4079, + 4078, 0, 1311, 1317, 1323, 1339, 1345, 1351, 1357, 1367, + 1373, 1383, 1389, 1395, 1406, 1412, 1425, 1431, 1437, 1443, + 1453, 1465, 1475, 1481, 1487, 1493, 1502, 1509, 1515, 1521, + + 1527, 1536, 1542, 1549, 1568, 1576, 1278, 1282, 1262, 1283, + 751, 1216, 4099, 1303, 1178, 1312, 1309, 1339, 1325, 1392, + 1274, 1356, 1355, 1405, 1395, 1306, 1378, 1417, 1423, 1319, + 1427, 1546, 1426, 1439, 1473, 1534, 4098, 4125, 1495, 1546, + 1572, 1575, 1576, 1579, 1593, 1594, 1597, 1600, 1614, 1611, + 1617, 1618, 1632, 1635, 1636, 1641, 1640, 1655, 1656, 1661, + 1662, 1670, 1675, 1676, 1681, 1692, 1684, 1697, 1701, 1710, + 1741, 1719, 1725, 1745, 1738, 1752, 1535, 1630, 1452, 1480, + 673, 1651, 841, 1560, 1457, 887, 1135, 1543, 1603, 1691, + 1667, 1671, 1685, 1748, 1586, 1749, 1627, 1606, 1604, 1686, + + 1750, 1720, 1714, 1526, 1754, 1757, 4115, 4109, 4108, 4090, + 4101, 4108, 4092, 4083, 4081, 4086, 4086, 4090, 1701, 4101, + 4086, 4094, 4089, 4085, 4072, 4071, 4079, 4093, 4052, 0, + 4058, 4051, 4056, 4053, 4054, 4056, 4057, 4054, 0, 1778, + 1784, 1790, 1804, 1811, 1820, 1826, 1832, 1843, 1849, 1857, + 1864, 1877, 1886, 1892, 1898, 1908, 1915, 1921, 1928, 1934, + 1942, 1953, 1959, 1965, 1972, 1978, 1985, 1991, 2000, 2013, + 2021, 2029, 2038, 1786, 1791, 1743, 1484, 1817, 1747, 1778, + 1816, 1749, 4066, 1692, 1829, 1878, 1851, 1398, 1814, 1952, + 1850, 1881, 1916, 1925, 1752, 4065, 1958, 1815, 1993, 1927, + + 2012, 1846, 1960, 1882, 4064, 2032, 2036, 2040, 2041, 2055, + 1984, 2047, 2056, 2060, 2069, 2076, 2077, 2084, 2083, 2063, + 2097, 2092, 2101, 2105, 2112, 2116, 2108, 2125, 2129, 2133, + 2134, 2138, 2147, 2152, 2153, 2158, 2169, 2135, 2139, 2157, + 2138, 2003, 2022, 2163, 2043, 2180, 2162, 2093, 2191, 2192, + 2185, 2195, 2111, 2196, 2197, 2198, 2186, 2204, 2199, 4082, + 2205, 1958, 2207, 2208, 2209, 1920, 2213, 2214, 4081, 4070, + 4072, 4064, 4075, 4210, 4060, 4049, 4059, 4071, 4046, 0, + 4210, 4064, 4210, 4049, 4067, 4045, 4046, 4061, 4059, 4050, + 4210, 4029, 4024, 0, 4028, 4019, 4026, 2181, 4023, 2185, + + 2221, 2252, 2237, 2258, 2266, 2272, 2278, 2288, 2299, 2305, + 2311, 2317, 2324, 2332, 2339, 2345, 2351, 2366, 2372, 2378, + 2386, 2392, 2398, 2404, 2412, 2422, 2431, 2448, 2438, 2149, + 2219, 2208, 2285, 2237, 2220, 2297, 2262, 2352, 2333, 4038, + 2298, 2273, 2340, 2337, 2395, 2392, 2358, 2252, 2434, 2433, + 2412, 2430, 2394, 4037, 2246, 2431, 2432, 2439, 2435, 2441, + 2466, 2460, 2473, 2480, 4064, 2481, 2484, 2488, 2503, 2499, + 2504, 4063, 2508, 4062, 2512, 2527, 2519, 2523, 2541, 2530, + 2544, 4061, 2545, 2548, 2549, 2552, 2563, 2569, 2570, 2574, + 2583, 2463, 2423, 2495, 2477, 2518, 2365, 2540, 2573, 2554, + + 4051, 2455, 2574, 2596, 2490, 2576, 2605, 2593, 2606, 2310, + 2421, 4050, 1361, 2584, 2607, 2608, 2611, 2612, 2613, 4047, + 4027, 4210, 4027, 4031, 4025, 4210, 4039, 4024, 4040, 4210, + 4038, 4038, 4022, 4031, 4035, 3995, 4008, 3995, 4006, 3993, + 4004, 4000, 3992, 4001, 3997, 2626, 2639, 2653, 2662, 2668, + 2675, 2681, 2692, 2701, 2709, 2718, 2726, 2732, 2738, 2749, + 2755, 2761, 2767, 2773, 2779, 2788, 2801, 2807, 2813, 2819, + 2735, 2614, 2610, 2652, 2598, 2665, 2635, 2676, 2625, 4007, + 2683, 2700, 2691, 2698, 2761, 2712, 2706, 2801, 2762, 2475, + 2768, 2753, 2802, 2803, 2723, 2804, 2805, 2838, 2837, 2829, + + 4034, 2833, 2844, 2852, 4033, 2858, 2861, 2865, 4032, 2874, + 2866, 2879, 2882, 2893, 2885, 2890, 2896, 2901, 2904, 2907, + 2912, 2921, 2928, 2929, 2826, 2791, 2827, 2871, 2918, 2931, + 2825, 2888, 2938, 2950, 2952, 2906, 2854, 2960, 2944, 2945, + 2385, 2956, 2836, 2957, 2961, 2963, 2965, 2964, 4210, 4015, + 4210, 0, 4000, 4000, 4010, 4001, 3997, 4210, 3994, 4210, + 4001, 3996, 4210, 4013, 3972, 3972, 3969, 3970, 3968, 3967, + 3970, 3965, 3964, 2971, 2979, 3001, 3007, 3014, 3020, 3033, + 3043, 3049, 3059, 3071, 3078, 3084, 3090, 3096, 3102, 3108, + 3114, 3124, 3130, 2989, 2974, 2995, 3984, 2968, 3005, 3017, + + 2989, 3015, 3028, 2951, 3057, 2976, 3033, 3067, 3013, 3043, + 3076, 3023, 3094, 3097, 3098, 3053, 3113, 3115, 4011, 3136, + 4010, 3121, 3139, 3143, 3157, 3154, 3160, 4009, 3161, 4008, + 3168, 3176, 4007, 3185, 3179, 3182, 3190, 3193, 3196, 3204, + 3207, 3210, 3215, 3145, 3997, 3146, 3189, 3061, 3217, 3206, + 3136, 2647, 2748, 3996, 3207, 3101, 3220, 3229, 3237, 3238, + 3239, 3240, 3241, 3987, 3987, 3980, 3982, 3969, 0, 3964, + 3960, 3950, 3926, 3910, 3912, 3914, 3906, 3896, 3890, 3892, + 3866, 3863, 3256, 3262, 3276, 3291, 3299, 3305, 3311, 3319, + 3326, 3874, 3332, 3342, 3348, 3354, 3360, 3366, 3373, 3385, + + 3392, 3271, 3263, 3301, 3244, 3379, 3883, 3380, 3248, 3312, + 3374, 3226, 3154, 3356, 3316, 3293, 3355, 3265, 3376, 3378, + 3392, 3407, 3400, 3403, 3414, 3421, 3422, 3427, 3430, 3425, + 3435, 3441, 3438, 3444, 3449, 3452, 3465, 3466, 3469, 3376, + 3242, 3283, 3402, 3304, 3901, 3465, 3463, 3471, 3871, 3466, + 3476, 3482, 3488, 3491, 3494, 3495, 3496, 3497, 3897, 3879, + 3895, 4210, 3879, 3874, 3872, 3883, 3862, 0, 3852, 0, + 3851, 0, 0, 3861, 0, 0, 3519, 3504, 3544, 3552, + 3558, 3564, 3570, 3858, 3576, 3587, 3593, 3599, 3605, 3611, + 3617, 3623, 3632, 3501, 3864, 3503, 3518, 3507, 3508, 3173, + + 3524, 3631, 3863, 3512, 3862, 3538, 3861, 3860, 3517, 3839, + 3838, 3623, 3628, 3631, 3851, 3636, 3642, 3647, 3656, 3607, + 3650, 3663, 3664, 3667, 3670, 3671, 3685, 3678, 3689, 3640, + 3616, 3657, 3575, 3652, 3508, 3694, 3789, 3813, 3677, 3810, + 3680, 3778, 3724, 2014, 3718, 3692, 4210, 3614, 4210, 3588, + 3531, 3499, 3435, 3393, 0, 0, 0, 3725, 3731, 3737, + 3746, 3752, 3375, 3760, 3766, 3772, 3708, 3691, 3721, 3559, + 3698, 3340, 3757, 3745, 3322, 3229, 3130, 3116, 3766, 2874, + 3767, 3780, 3772, 3791, 3386, 3786, 3787, 3794, 3695, 3708, + 3771, 3777, 3779, 2513, 2353, 2220, 2114, 0, 2047, 4210, + + 1941, 4210, 1850, 3820, 3826, 3832, 1752, 1710, 1550, 3810, + 3806, 3840, 3844, 3828, 3831, 1529, 3836, 1298, 3806, 1161, + 3840, 3841, 1055, 1021, 4210, 942, 3865, 885, 3850, 3862, + 3873, 3866, 803, 3572, 3870, 666, 4210, 633, 587, 3880, + 3885, 464, 3749, 287, 4210, 3884, 182, 4210, 94, 3916, + 3919, 3922, 3928, 3934, 3940, 3946, 3952, 3958, 3964, 3966, + 3968, 3974, 3980, 3986, 3992, 3998 } ; -static yyconst short int yy_def[809] = +static yyconst short int yy_def[1367] = { 0, - 796, 1, 796, 3, 796, 5, 796, 7, 796, 9, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 797, 796, 796, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 799, 798, 798, 800, 796, 796, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 800, 801, 800, - 800, 802, 796, 796, 796, 796, 802, 802, 802, 802, - 802, 802, 802, 802, 802, 802, 802, 802, 802, 802, - - 802, 802, 802, 803, 802, 802, 796, 796, 796, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 797, 796, 797, - 796, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 805, 796, 805, 799, 798, 806, 798, 800, 800, 796, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 801, 801, 800, - - 801, 800, 807, 796, 796, 796, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 807, 807, 807, - 807, 807, 807, 808, 807, 808, 807, 796, 796, 796, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 806, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, - - 800, 800, 800, 800, 800, 800, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 808, 807, 808, 807, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, - - 800, 800, 800, 800, 800, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 798, 798, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 800, - 800, 800, 807, 807, 807, 807, 807, 807, 807, 807, - - 807, 807, 807, 807, 807, 807, 807, 807, 807, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 804, 804, - 804, 804, 804, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 798, - 798, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 798, 798, 800, 800, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 800, 800, 807, - 807, 807, 807, 807, 807, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 804, 804, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 804, 796, 796, - - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 798, 798, 798, 798, 798, 798, 798, 798, 798, - 798, 800, 800, 800, 800, 800, 800, 800, 800, 800, - 800, 800, 800, 800, 807, 807, 807, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 804, 804, 804, - - 804, 804, 804, 804, 804, 804, 804, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 798, 798, 798, - 798, 798, 798, 798, 798, 798, 798, 800, 800, 800, - 800, 800, 800, 800, 800, 800, 800, 807, 807, 807, - 807, 807, 807, 807, 807, 807, 807, 804, 804, 804, - 804, 804, 804, 804, 804, 804, 804, 796, 796, 796, - 796, 798, 798, 798, 798, 800, 800, 800, 800, 807, - 807, 807, 807, 804, 804, 804, 804, 796, 798, 800, - 807, 804, 796, 798, 800, 807, 804, 796, 798, 800, - 807, 804, 796, 800, 807, 0, 796, 796, 796, 796, - - 796, 796, 796, 796, 796, 796, 796, 796 + 1348, 1, 1348, 3, 1348, 5, 1348, 7, 1348, 9, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1350, 1349, 1349, 1351, 1351, 1351, 1351, 1351, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1353, 1352, 1352, 1352, 1354, 1348, 1348, 1354, 1354, 1354, + 1354, 1354, 1354, 1355, 1355, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + + 85, 85, 85, 85, 1356, 85, 85, 1357, 1348, 1348, + 1348, 1357, 1357, 1357, 1348, 1357, 1357, 1358, 1358, 1358, + 1358, 1358, 122, 122, 122, 122, 122, 122, 122, 122, + 122, 122, 122, 122, 122, 122, 122, 122, 1359, 122, + 122, 1348, 1348, 1348, 1360, 1360, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1348, + 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1350, 1349, 1350, 1349, + + 1349, 1351, 1351, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1362, 1348, + 1362, 1353, 1352, 1352, 1363, 1352, 1352, 1352, 1354, 1354, + 1348, 1354, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 1356, 1356, 85, + 1356, 85, 85, 1364, 1348, 1348, 1348, 1364, 1365, 1365, + 1365, 1365, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + + 282, 282, 282, 1366, 282, 1366, 282, 282, 1348, 1348, + 1348, 1360, 1360, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + + 1352, 1352, 1352, 1352, 1363, 1352, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 1364, 1364, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 1366, 282, 282, 1366, 282, 282, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 85, 85, + + 85, 85, 85, 85, 85, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1349, + 1349, 1349, 1349, 1348, 1349, 1349, 1349, 1349, 1349, 1349, + 1348, 1349, 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 85, + 85, 85, 85, 1354, 85, 85, 85, 85, 85, 85, + 1354, 85, 1354, 85, 85, 85, 85, 85, 85, 85, + 1354, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 282, 282, 282, 282, 1364, 282, 282, 282, 282, 282, + 282, 1364, 282, 1364, 282, 282, 282, 282, 282, 282, + 282, 1364, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1349, 1349, + 1349, 1348, 1349, 1349, 1349, 1348, 1349, 1349, 1349, 1348, + 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 85, 85, 85, 1354, 85, 85, 85, 1354, 85, 85, + 85, 1354, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 282, 282, 282, + + 1364, 282, 282, 282, 1364, 282, 282, 282, 1364, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1348, 1349, + 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1348, 1349, 1348, + 1349, 1349, 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1349, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1354, 85, 1354, 85, 85, 85, 85, + + 85, 85, 1354, 85, 1354, 85, 85, 1354, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 1364, 282, + 1364, 282, 282, 282, 282, 282, 282, 1364, 282, 1364, + 282, 282, 1364, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, + 1361, 1361, 1361, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1348, 1349, 1349, 1349, 1349, 1349, 1349, 1349, + 1349, 1349, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1351, 1352, 1352, 1352, 1352, 1352, 1352, 1352, 1352, + + 1352, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 1354, 85, 85, 85, 85, 85, 85, 85, 85, 85, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 1364, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1360, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1361, 1349, 1349, + 1349, 1348, 1349, 1349, 1349, 1349, 1348, 1349, 1349, 1349, + 1349, 1349, 1349, 1349, 1349, 1349, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 1351, 1352, 1352, 1352, 1352, 1352, 1352, + 1352, 1352, 1352, 85, 85, 85, 1354, 85, 85, 85, + + 85, 1354, 85, 85, 85, 85, 85, 85, 85, 85, + 85, 282, 282, 282, 1364, 282, 282, 282, 282, 1364, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1360, 1361, 1361, 1361, + 1361, 1361, 1361, 1361, 1361, 1361, 1348, 1349, 1348, 1349, + 1349, 1349, 1349, 1348, 1349, 1349, 1349, 1352, 1352, 1352, + 1352, 1352, 1351, 1352, 1352, 1352, 1354, 85, 1354, 85, + 85, 85, 85, 1354, 85, 85, 85, 1364, 282, 1364, + 282, 282, 282, 282, 1364, 282, 282, 282, 1361, 1361, + 1361, 1361, 1361, 1360, 1361, 1361, 1361, 1349, 1349, 1348, + + 1349, 1348, 1348, 1352, 1352, 1352, 1351, 85, 85, 1354, + 85, 1354, 1354, 282, 282, 1364, 282, 1364, 1364, 1361, + 1361, 1361, 1360, 1349, 1348, 1348, 1352, 1351, 85, 1354, + 1354, 282, 1364, 1364, 1361, 1360, 1348, 1348, 1351, 1354, + 1354, 1364, 1364, 1360, 1348, 1354, 1364, 0, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348 } ; -static yyconst short int yy_nxt[1579] = +static yyconst short int yy_nxt[4266] = { 0, - 12, 13, 14, 13, 12, 12, 15, 16, 17, 12, - 12, 12, 18, 19, 12, 20, 12, 12, 12, 12, - 12, 21, 22, 23, 24, 12, 25, 26, 12, 12, - 12, 12, 27, 28, 12, 12, 12, 12, 12, 29, - 12, 30, 12, 31, 12, 12, 12, 32, 33, 130, - 130, 130, 130, 130, 130, 142, 149, 165, 179, 218, - 179, 175, 172, 173, 143, 34, 166, 203, 219, 135, - 171, 171, 172, 173, 158, 179, 171, 179, 412, 171, - 130, 130, 130, 130, 180, 130, 231, 35, 12, 13, - 14, 13, 36, 36, 15, 37, 38, 12, 36, 36, - - 39, 40, 41, 42, 36, 36, 36, 36, 36, 43, - 44, 45, 46, 36, 47, 48, 36, 36, 36, 36, - 49, 50, 36, 36, 36, 36, 36, 51, 36, 52, - 36, 53, 36, 36, 36, 54, 55, 179, 179, 179, - 179, 179, 179, 179, 179, 181, 179, 179, 179, 179, - 179, 225, 179, 56, 179, 183, 179, 182, 179, 186, - 179, 199, 203, 199, 211, 184, 179, 190, 179, 185, - 204, 205, 206, 188, 793, 57, 58, 13, 59, 60, - 58, 58, 61, 62, 63, 58, 58, 58, 64, 65, - 58, 66, 58, 58, 58, 58, 58, 67, 68, 69, - - 70, 58, 71, 72, 58, 58, 58, 58, 73, 74, - 58, 58, 58, 58, 58, 75, 58, 76, 58, 77, - 58, 58, 58, 78, 79, 179, 179, 179, 179, 179, - 179, 179, 179, 179, 203, 179, 130, 130, 130, 243, - 203, 80, 200, 130, 205, 130, 688, 148, 244, 187, - 148, 172, 173, 189, 313, 185, 228, 229, 230, 195, - 179, 191, 179, 81, 82, 83, 84, 85, 82, 82, - 86, 87, 88, 82, 82, 82, 89, 90, 82, 91, - 82, 82, 82, 82, 82, 92, 93, 94, 95, 82, - 96, 97, 82, 82, 82, 82, 98, 99, 82, 82, - - 82, 82, 82, 100, 82, 101, 82, 102, 82, 82, - 82, 103, 104, 179, 249, 179, 130, 130, 130, 130, - 229, 130, 130, 130, 130, 263, 282, 236, 179, 105, - 179, 171, 171, 172, 173, 181, 203, 171, 264, 283, - 171, 148, 148, 308, 148, 197, 199, 148, 199, 793, - 148, 106, 12, 107, 108, 109, 12, 12, 15, 110, - 111, 12, 112, 112, 113, 114, 112, 115, 112, 112, - 112, 112, 112, 116, 117, 118, 119, 112, 120, 121, - 112, 112, 112, 112, 122, 123, 112, 112, 112, 112, - 112, 124, 112, 125, 112, 126, 112, 112, 112, 127, - - 33, 150, 176, 203, 179, 179, 179, 179, 179, 179, - 179, 179, 201, 226, 150, 150, 176, 128, 130, 130, - 130, 179, 179, 179, 179, 179, 179, 179, 179, 179, - 289, 179, 793, 192, 291, 792, 318, 146, 169, 129, - 151, 177, 193, 203, 194, 290, 293, 196, 196, 222, - 247, 202, 227, 250, 151, 177, 179, 179, 179, 179, - 179, 179, 179, 179, 179, 179, 179, 179, 409, 295, - 179, 299, 179, 179, 294, 179, 203, 292, 179, 297, - 179, 296, 179, 179, 179, 179, 199, 179, 199, 179, - 199, 179, 199, 179, 201, 204, 205, 206, 298, 203, - - 300, 301, 130, 130, 130, 130, 205, 130, 309, 203, - 306, 203, 203, 203, 302, 203, 303, 203, 319, 203, - 311, 203, 203, 203, 315, 305, 304, 203, 203, 314, - 203, 203, 310, 202, 312, 150, 317, 316, 224, 224, - 148, 148, 203, 148, 148, 328, 228, 229, 230, 320, - 321, 342, 406, 327, 130, 130, 130, 130, 229, 130, - 203, 323, 360, 322, 343, 380, 179, 308, 179, 361, - 325, 324, 381, 362, 250, 203, 382, 148, 148, 179, - 148, 179, 203, 148, 329, 203, 148, 387, 179, 179, - 179, 179, 413, 179, 179, 179, 179, 179, 410, 179, - - 179, 407, 179, 389, 203, 388, 391, 392, 393, 179, - 394, 179, 203, 179, 390, 179, 179, 179, 179, 179, - 179, 179, 179, 179, 179, 179, 179, 179, 179, 179, - 179, 179, 203, 203, 395, 203, 203, 414, 203, 203, - 203, 203, 396, 417, 203, 203, 411, 408, 224, 203, - 148, 203, 328, 148, 399, 403, 398, 203, 224, 397, - 148, 400, 437, 148, 402, 401, 498, 415, 404, 438, - 418, 405, 422, 439, 179, 789, 179, 419, 416, 203, - 639, 420, 421, 423, 179, 476, 179, 424, 179, 203, - 179, 329, 499, 179, 179, 179, 179, 179, 640, 179, - - 477, 479, 480, 179, 179, 179, 179, 179, 179, 179, - 179, 500, 179, 478, 179, 484, 482, 179, 481, 179, - 179, 179, 179, 179, 203, 179, 483, 179, 179, 179, - 179, 179, 179, 179, 179, 179, 203, 203, 203, 203, - 494, 203, 203, 203, 203, 496, 497, 493, 203, 203, - 501, 203, 485, 203, 486, 203, 203, 487, 535, 538, - 488, 549, 489, 490, 491, 552, 495, 492, 179, 179, - 179, 179, 536, 539, 788, 550, 555, 787, 784, 553, - 503, 504, 554, 502, 738, 507, 506, 505, 508, 509, - 179, 179, 179, 179, 179, 179, 179, 179, 556, 179, - - 179, 179, 179, 179, 179, 179, 179, 558, 179, 179, - 179, 179, 179, 203, 179, 179, 179, 179, 179, 559, - 179, 557, 179, 203, 179, 203, 179, 203, 203, 203, - 203, 203, 203, 571, 203, 572, 570, 574, 203, 573, - 560, 203, 203, 203, 562, 594, 597, 575, 561, 179, - 564, 179, 565, 567, 783, 563, 568, 622, 782, 595, - 598, 179, 179, 179, 179, 578, 566, 576, 203, 179, - 569, 179, 577, 580, 581, 584, 635, 579, 583, 179, - 203, 179, 179, 179, 179, 179, 203, 623, 582, 585, - 624, 179, 179, 179, 179, 179, 179, 179, 179, 179, - - 179, 179, 179, 179, 203, 179, 179, 179, 179, 179, - 203, 203, 636, 203, 203, 641, 203, 203, 637, 203, - 626, 203, 203, 638, 628, 179, 625, 179, 630, 179, - 203, 179, 631, 627, 179, 633, 179, 629, 179, 634, - 179, 203, 632, 643, 678, 644, 646, 179, 179, 179, - 179, 647, 642, 203, 179, 645, 179, 179, 179, 179, - 179, 179, 690, 179, 179, 179, 179, 179, 179, 203, - 179, 203, 689, 203, 203, 203, 179, 179, 179, 179, - 179, 203, 179, 179, 691, 179, 203, 203, 179, 679, - 179, 681, 203, 203, 692, 680, 203, 179, 682, 179, - - 683, 203, 685, 684, 179, 203, 179, 686, 728, 203, - 687, 693, 695, 694, 179, 696, 179, 697, 729, 730, - 731, 179, 732, 179, 179, 741, 179, 203, 739, 203, - 743, 740, 203, 203, 179, 742, 179, 179, 203, 179, - 733, 179, 203, 179, 744, 203, 203, 734, 746, 735, - 203, 179, 747, 179, 179, 179, 179, 179, 179, 179, - 179, 179, 745, 179, 736, 179, 766, 737, 179, 179, - 179, 179, 786, 771, 770, 773, 179, 779, 179, 772, - 791, 179, 767, 179, 179, 179, 179, 179, 203, 769, - 781, 179, 179, 179, 179, 768, 795, 179, 778, 179, - - 794, 777, 776, 775, 774, 203, 203, 203, 203, 780, - 203, 203, 765, 764, 763, 762, 761, 760, 759, 758, - 757, 756, 755, 754, 753, 790, 752, 751, 785, 148, - 750, 148, 148, 148, 152, 152, 174, 174, 174, 174, - 174, 178, 749, 178, 178, 178, 198, 748, 198, 198, - 198, 203, 727, 726, 203, 203, 224, 725, 224, 224, - 224, 171, 171, 171, 171, 171, 288, 724, 288, 288, - 288, 307, 723, 722, 307, 307, 326, 721, 326, 326, - 326, 720, 719, 718, 717, 716, 715, 714, 713, 712, - 711, 710, 709, 708, 707, 706, 705, 704, 703, 702, - - 701, 700, 699, 698, 203, 203, 203, 677, 676, 675, - 674, 673, 672, 671, 670, 669, 668, 667, 666, 665, - 664, 663, 662, 661, 660, 659, 658, 657, 656, 655, - 654, 653, 652, 651, 650, 649, 648, 601, 600, 599, - 203, 203, 203, 621, 620, 619, 618, 617, 616, 615, - 614, 613, 612, 601, 600, 599, 611, 610, 609, 608, - 607, 606, 605, 604, 603, 602, 601, 600, 599, 596, - 593, 592, 591, 590, 589, 588, 528, 587, 526, 525, - 586, 203, 203, 203, 551, 548, 547, 546, 545, 544, - 543, 528, 542, 526, 541, 525, 540, 537, 534, 533, - - 532, 531, 530, 529, 528, 527, 526, 525, 524, 523, - 522, 521, 520, 519, 518, 517, 516, 452, 515, 514, - 513, 448, 447, 512, 511, 510, 203, 203, 475, 474, - 473, 472, 471, 470, 469, 468, 452, 467, 466, 465, - 448, 447, 464, 463, 462, 461, 460, 459, 458, 457, - 456, 455, 454, 453, 452, 451, 450, 449, 448, 447, - 446, 445, 444, 443, 442, 441, 440, 436, 435, 434, - 433, 432, 431, 430, 429, 428, 427, 426, 425, 203, - 203, 386, 385, 384, 383, 379, 378, 377, 376, 375, - 374, 373, 372, 371, 370, 369, 368, 367, 366, 365, - - 364, 363, 359, 358, 357, 356, 355, 354, 353, 352, - 351, 350, 349, 348, 347, 346, 345, 344, 341, 340, - 339, 338, 337, 336, 335, 334, 333, 332, 331, 330, - 232, 203, 287, 286, 285, 284, 281, 280, 279, 278, - 277, 276, 275, 274, 273, 272, 271, 270, 269, 153, - 268, 267, 266, 265, 262, 261, 260, 259, 258, 257, - 256, 255, 254, 253, 252, 251, 131, 248, 247, 246, - 245, 242, 241, 240, 239, 238, 237, 236, 235, 234, - 233, 232, 223, 222, 221, 220, 217, 216, 215, 214, - 213, 212, 211, 210, 209, 208, 207, 170, 169, 168, - - 167, 164, 163, 162, 161, 160, 159, 158, 157, 156, - 155, 154, 153, 147, 146, 145, 144, 141, 140, 139, - 138, 137, 136, 135, 134, 133, 132, 131, 796, 11, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796 + 12, 13, 14, 13, 15, 12, 12, 16, 17, 18, + 19, 20, 12, 21, 22, 23, 24, 25, 26, 21, + 21, 21, 21, 21, 27, 28, 29, 30, 31, 32, + 33, 34, 21, 21, 21, 21, 21, 21, 21, 35, + 36, 37, 21, 21, 21, 21, 38, 21, 39, 21, + 40, 21, 21, 21, 41, 42, 170, 170, 170, 170, + 170, 170, 176, 183, 184, 190, 198, 240, 312, 240, + 177, 240, 185, 240, 191, 43, 202, 202, 202, 202, + 180, 202, 202, 202, 202, 202, 245, 202, 202, 202, + 202, 202, 240, 202, 240, 243, 213, 206, 331, 172, + + 44, 12, 13, 14, 13, 15, 45, 45, 46, 47, + 18, 48, 49, 12, 50, 51, 52, 53, 54, 55, + 50, 50, 50, 50, 50, 56, 57, 58, 59, 60, + 61, 62, 63, 50, 50, 50, 50, 50, 50, 50, + 64, 65, 66, 50, 50, 50, 50, 67, 50, 68, + 50, 69, 50, 50, 50, 70, 71, 202, 202, 202, + 202, 240, 202, 240, 202, 202, 202, 202, 72, 202, + 202, 202, 202, 202, 243, 202, 73, 170, 170, 170, + 258, 205, 207, 274, 252, 208, 202, 202, 202, 202, + 240, 202, 240, 209, 170, 241, 170, 240, 211, 240, + + 243, 74, 75, 13, 76, 77, 78, 75, 75, 79, + 80, 81, 82, 83, 75, 84, 85, 86, 87, 88, + 89, 84, 84, 84, 84, 84, 90, 91, 92, 93, + 94, 95, 96, 97, 84, 84, 84, 84, 84, 84, + 84, 98, 99, 100, 84, 84, 84, 84, 101, 84, + 102, 84, 103, 84, 84, 84, 104, 105, 243, 202, + 202, 202, 202, 246, 202, 202, 202, 202, 202, 260, + 202, 202, 202, 202, 202, 243, 202, 106, 210, 202, + 202, 202, 202, 251, 202, 243, 250, 212, 202, 202, + 202, 202, 249, 202, 197, 214, 220, 243, 243, 1345, + + 197, 218, 107, 108, 109, 110, 111, 112, 108, 108, + 113, 114, 115, 116, 117, 108, 118, 119, 120, 121, + 122, 123, 118, 118, 118, 118, 118, 124, 125, 126, + 127, 128, 129, 130, 131, 118, 118, 118, 118, 118, + 118, 118, 132, 133, 134, 118, 118, 118, 118, 135, + 118, 136, 118, 137, 118, 118, 118, 138, 139, 243, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 267, 202, 229, 229, 230, 231, 229, 243, 140, 215, + 216, 229, 264, 240, 229, 240, 247, 312, 217, 243, + 254, 255, 263, 242, 248, 243, 219, 316, 257, 256, + + 243, 230, 231, 141, 12, 142, 143, 144, 15, 12, + 12, 16, 17, 18, 145, 146, 12, 147, 148, 149, + 150, 151, 152, 147, 147, 147, 147, 147, 153, 154, + 155, 156, 157, 158, 159, 160, 147, 147, 147, 147, + 147, 147, 147, 161, 162, 163, 147, 147, 147, 147, + 164, 147, 165, 147, 166, 147, 147, 147, 167, 42, + 199, 202, 202, 202, 202, 274, 202, 202, 202, 202, + 202, 312, 202, 202, 202, 202, 202, 259, 202, 168, + 200, 202, 202, 202, 202, 320, 202, 202, 202, 202, + 202, 243, 202, 243, 312, 269, 221, 269, 243, 222, + + 312, 317, 195, 243, 169, 201, 265, 321, 223, 266, + 359, 261, 224, 202, 202, 202, 202, 312, 202, 226, + 262, 270, 360, 225, 202, 202, 202, 202, 484, 202, + 271, 202, 202, 202, 202, 251, 202, 243, 279, 202, + 202, 202, 202, 285, 202, 279, 279, 234, 312, 301, + 272, 323, 233, 279, 243, 227, 275, 276, 277, 228, + 209, 212, 235, 202, 202, 202, 288, 202, 170, 170, + 170, 286, 266, 312, 236, 273, 170, 276, 170, 279, + 279, 350, 237, 279, 287, 312, 279, 279, 279, 289, + 322, 279, 279, 293, 279, 351, 290, 291, 279, 1345, + + 279, 309, 310, 311, 227, 292, 279, 238, 239, 240, + 329, 240, 239, 239, 239, 239, 239, 239, 239, 312, + 239, 239, 240, 295, 240, 239, 239, 239, 239, 239, + 239, 239, 279, 239, 279, 279, 279, 312, 315, 279, + 279, 294, 279, 279, 279, 1345, 312, 279, 296, 330, + 244, 274, 274, 299, 328, 274, 274, 274, 274, 274, + 300, 274, 243, 274, 274, 274, 417, 279, 274, 274, + 274, 274, 274, 312, 274, 279, 274, 279, 297, 170, + 170, 170, 279, 312, 312, 279, 312, 298, 642, 318, + 279, 303, 312, 280, 274, 274, 305, 319, 274, 274, + + 274, 274, 274, 302, 274, 324, 274, 312, 1344, 279, + 287, 170, 310, 170, 281, 274, 274, 279, 334, 274, + 274, 274, 274, 274, 312, 274, 306, 274, 414, 335, + 312, 312, 282, 274, 274, 312, 243, 274, 274, 274, + 274, 274, 344, 274, 337, 274, 307, 279, 347, 325, + 326, 332, 345, 312, 346, 279, 339, 336, 327, 283, + 333, 338, 367, 348, 199, 199, 578, 284, 302, 312, + 322, 308, 170, 170, 170, 368, 202, 202, 202, 202, + 243, 202, 230, 231, 340, 200, 202, 202, 202, 202, + 240, 202, 240, 243, 373, 202, 202, 202, 202, 240, + + 202, 240, 430, 374, 274, 240, 337, 240, 412, 341, + 201, 202, 202, 202, 202, 242, 202, 202, 202, 202, + 202, 243, 202, 413, 375, 170, 170, 170, 378, 312, + 202, 202, 202, 202, 376, 202, 377, 202, 202, 202, + 202, 407, 202, 379, 489, 381, 380, 202, 202, 202, + 202, 312, 202, 202, 202, 202, 202, 243, 202, 382, + 202, 202, 202, 202, 420, 202, 202, 202, 202, 202, + 644, 202, 243, 408, 384, 383, 202, 202, 202, 202, + 385, 202, 386, 243, 387, 202, 202, 202, 202, 243, + 202, 202, 202, 202, 202, 418, 202, 312, 243, 389, + + 434, 388, 202, 202, 202, 202, 421, 202, 202, 202, + 202, 202, 390, 202, 647, 202, 202, 202, 202, 419, + 202, 426, 243, 243, 391, 243, 422, 1339, 392, 393, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 243, 202, 202, 202, 202, 202, 243, 202, 202, 202, + 202, 202, 428, 202, 202, 202, 202, 202, 423, 202, + 202, 202, 202, 202, 431, 202, 394, 202, 202, 202, + 202, 269, 202, 269, 243, 396, 409, 202, 202, 202, + 202, 395, 202, 415, 1338, 398, 410, 243, 411, 312, + 397, 229, 229, 230, 231, 229, 424, 416, 399, 243, + + 229, 400, 427, 229, 202, 202, 202, 202, 425, 202, + 243, 312, 243, 243, 401, 403, 202, 202, 202, 202, + 497, 202, 402, 197, 197, 504, 197, 197, 274, 269, + 379, 269, 197, 1337, 429, 197, 437, 243, 439, 404, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 243, 202, 243, 270, 234, 235, 202, 202, 202, 432, + 202, 406, 269, 271, 269, 436, 304, 236, 197, 243, + 312, 312, 433, 435, 197, 237, 275, 276, 277, 170, + 170, 170, 440, 272, 170, 276, 170, 243, 304, 446, + 197, 440, 440, 487, 440, 440, 197, 451, 448, 312, + + 238, 440, 477, 440, 447, 440, 1336, 440, 273, 438, + 274, 499, 312, 438, 438, 438, 438, 438, 482, 438, + 312, 438, 438, 274, 312, 312, 438, 438, 438, 438, + 438, 312, 438, 483, 438, 441, 438, 274, 507, 496, + 438, 438, 438, 438, 438, 312, 438, 488, 438, 442, + 438, 274, 648, 440, 438, 438, 438, 438, 438, 449, + 438, 452, 438, 440, 440, 440, 312, 505, 443, 478, + 455, 312, 440, 450, 440, 440, 440, 312, 444, 453, + 445, 312, 440, 440, 440, 440, 454, 440, 440, 457, + 312, 456, 490, 440, 440, 440, 458, 582, 440, 440, + + 440, 492, 440, 440, 440, 500, 440, 243, 459, 440, + 460, 440, 440, 440, 440, 440, 440, 461, 312, 440, + 440, 491, 312, 440, 440, 462, 440, 494, 440, 440, + 440, 440, 440, 440, 440, 440, 440, 440, 440, 495, + 464, 579, 466, 312, 440, 243, 493, 440, 440, 440, + 440, 463, 465, 473, 440, 467, 440, 440, 440, 312, + 474, 309, 310, 311, 312, 468, 312, 472, 440, 440, + 440, 312, 469, 440, 312, 576, 470, 170, 170, 170, + 475, 312, 479, 440, 485, 440, 170, 310, 170, 588, + 498, 243, 480, 312, 481, 199, 339, 502, 486, 274, + + 312, 501, 533, 243, 574, 476, 506, 243, 575, 534, + 503, 243, 243, 535, 577, 340, 202, 202, 202, 202, + 593, 202, 202, 202, 202, 202, 584, 202, 202, 202, + 202, 202, 243, 202, 581, 243, 542, 540, 243, 583, + 341, 243, 586, 541, 202, 202, 202, 202, 243, 202, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 544, 202, 202, 202, 202, 202, 597, 202, 243, 585, + 543, 312, 202, 202, 202, 202, 545, 202, 202, 202, + 202, 202, 589, 202, 243, 243, 546, 590, 202, 202, + 202, 202, 548, 202, 202, 202, 202, 202, 547, 202, + + 202, 202, 202, 202, 941, 202, 550, 243, 594, 587, + 549, 202, 202, 202, 202, 745, 202, 202, 202, 202, + 202, 243, 202, 552, 243, 551, 592, 243, 591, 553, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 554, 202, 202, 202, 202, 202, 243, 202, 202, 202, + 202, 202, 243, 202, 595, 243, 243, 555, 202, 202, + 202, 202, 312, 202, 598, 640, 557, 312, 243, 556, + 202, 202, 202, 202, 596, 202, 646, 602, 603, 559, + 202, 202, 202, 202, 558, 202, 202, 202, 202, 202, + 312, 202, 202, 202, 202, 202, 274, 202, 202, 202, + + 202, 202, 243, 202, 733, 560, 439, 202, 202, 202, + 202, 641, 202, 243, 202, 202, 202, 202, 561, 202, + 202, 202, 202, 202, 604, 202, 202, 202, 202, 202, + 274, 202, 202, 202, 202, 202, 312, 202, 562, 564, + 563, 202, 202, 202, 202, 312, 202, 202, 202, 202, + 202, 565, 202, 312, 202, 202, 202, 202, 566, 202, + 569, 638, 567, 243, 440, 667, 568, 572, 197, 197, + 312, 197, 197, 649, 440, 243, 440, 197, 570, 1329, + 197, 202, 202, 202, 202, 605, 202, 571, 599, 608, + 440, 645, 573, 440, 440, 600, 312, 440, 606, 601, + + 440, 607, 440, 440, 440, 440, 440, 440, 610, 440, + 609, 440, 440, 312, 312, 440, 312, 656, 440, 611, + 650, 440, 440, 440, 440, 440, 612, 440, 440, 440, + 440, 613, 440, 614, 616, 440, 440, 312, 615, 440, + 312, 440, 440, 659, 440, 440, 440, 440, 617, 618, + 440, 620, 619, 440, 440, 660, 639, 658, 440, 440, + 440, 312, 440, 440, 440, 440, 440, 621, 440, 440, + 440, 440, 622, 440, 440, 625, 643, 312, 623, 440, + 440, 312, 652, 440, 440, 440, 440, 624, 440, 440, + 440, 440, 626, 440, 440, 312, 312, 653, 440, 440, + + 440, 312, 440, 440, 440, 440, 440, 627, 651, 440, + 440, 440, 440, 681, 440, 440, 740, 654, 630, 440, + 440, 243, 440, 629, 312, 440, 628, 440, 440, 440, + 312, 440, 682, 661, 631, 634, 635, 440, 440, 243, + 440, 632, 304, 440, 197, 633, 304, 440, 197, 440, + 197, 473, 636, 472, 197, 440, 440, 474, 312, 312, + 312, 637, 663, 657, 312, 666, 440, 312, 440, 664, + 440, 655, 243, 665, 735, 732, 243, 475, 243, 738, + 440, 243, 440, 202, 202, 202, 202, 662, 202, 202, + 202, 202, 202, 701, 202, 202, 202, 202, 202, 702, + + 202, 730, 476, 1328, 752, 668, 731, 243, 669, 202, + 202, 202, 202, 736, 202, 243, 202, 202, 202, 202, + 243, 202, 703, 674, 704, 202, 202, 202, 202, 734, + 202, 202, 202, 202, 202, 746, 202, 202, 202, 202, + 202, 741, 202, 243, 243, 243, 243, 705, 202, 202, + 202, 202, 737, 202, 202, 202, 202, 202, 243, 202, + 742, 706, 202, 202, 202, 202, 754, 202, 707, 202, + 202, 202, 202, 708, 202, 243, 681, 744, 709, 243, + 243, 710, 202, 202, 202, 202, 748, 202, 758, 683, + 743, 202, 202, 202, 202, 711, 202, 202, 202, 202, + + 202, 1326, 202, 202, 202, 202, 202, 243, 202, 713, + 243, 243, 712, 202, 202, 202, 202, 749, 202, 714, + 202, 202, 202, 202, 760, 202, 202, 202, 202, 202, + 312, 202, 715, 202, 202, 202, 202, 751, 202, 202, + 202, 202, 202, 750, 202, 243, 691, 202, 202, 202, + 202, 716, 202, 1325, 243, 718, 243, 717, 202, 202, + 202, 202, 816, 202, 202, 202, 202, 202, 312, 202, + 202, 202, 202, 202, 756, 202, 747, 202, 202, 202, + 202, 243, 202, 202, 202, 202, 202, 243, 202, 243, + 202, 202, 202, 202, 719, 202, 202, 202, 202, 202, + + 759, 202, 440, 753, 720, 202, 202, 202, 202, 812, + 202, 766, 440, 312, 440, 674, 721, 722, 202, 202, + 202, 202, 243, 202, 312, 723, 202, 202, 202, 202, + 724, 202, 312, 725, 202, 202, 202, 202, 755, 202, + 726, 243, 728, 202, 202, 202, 202, 761, 202, 796, + 440, 762, 1297, 312, 440, 727, 705, 757, 440, 440, + 440, 764, 440, 729, 440, 440, 440, 765, 440, 440, + 440, 440, 763, 440, 440, 440, 1324, 440, 440, 798, + 776, 440, 767, 440, 440, 440, 440, 440, 440, 772, + 769, 440, 768, 440, 440, 440, 774, 440, 770, 440, + + 771, 440, 440, 312, 440, 440, 440, 440, 773, 775, + 440, 440, 440, 440, 440, 440, 778, 801, 777, 440, + 440, 312, 440, 440, 312, 440, 440, 440, 782, 440, + 440, 440, 805, 440, 440, 440, 440, 779, 440, 781, + 440, 780, 440, 440, 440, 312, 440, 440, 312, 312, + 792, 440, 440, 440, 793, 440, 440, 440, 795, 440, + 783, 440, 440, 440, 440, 440, 440, 312, 440, 871, + 440, 440, 312, 312, 784, 440, 440, 440, 243, 786, + 440, 440, 440, 440, 785, 787, 440, 440, 440, 794, + 312, 800, 788, 790, 789, 312, 312, 440, 797, 440, + + 791, 312, 312, 681, 683, 312, 312, 312, 312, 312, + 799, 803, 804, 809, 312, 312, 691, 312, 312, 312, + 806, 841, 802, 312, 312, 844, 202, 202, 202, 202, + 312, 202, 873, 807, 808, 842, 872, 243, 240, 845, + 240, 846, 202, 202, 202, 202, 875, 202, 243, 243, + 811, 810, 813, 817, 815, 814, 818, 202, 202, 202, + 202, 848, 202, 202, 202, 202, 202, 885, 202, 847, + 822, 202, 202, 202, 202, 243, 202, 202, 202, 202, + 202, 243, 202, 202, 202, 202, 202, 877, 202, 890, + 880, 243, 849, 202, 202, 202, 202, 874, 202, 240, + + 826, 240, 243, 851, 202, 202, 202, 202, 850, 202, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 312, 202, 202, 202, 202, 202, 243, 202, 853, 202, + 202, 202, 202, 876, 202, 852, 830, 202, 202, 202, + 202, 240, 202, 240, 202, 202, 202, 202, 854, 202, + 202, 202, 202, 202, 939, 202, 202, 202, 202, 202, + 857, 202, 243, 312, 878, 855, 243, 858, 881, 879, + 856, 202, 202, 202, 202, 312, 202, 202, 202, 202, + 202, 243, 202, 202, 202, 202, 202, 243, 202, 884, + 859, 202, 202, 202, 202, 312, 202, 202, 202, 202, + + 202, 929, 202, 202, 202, 202, 202, 882, 202, 202, + 202, 202, 202, 240, 202, 240, 860, 202, 202, 202, + 202, 243, 202, 243, 243, 883, 861, 202, 202, 202, + 202, 312, 202, 312, 1056, 862, 202, 202, 202, 202, + 926, 202, 889, 202, 202, 202, 202, 864, 202, 863, + 886, 728, 865, 202, 202, 202, 202, 887, 202, 243, + 243, 243, 243, 243, 243, 312, 866, 867, 243, 940, + 243, 868, 932, 312, 888, 892, 870, 899, 440, 893, + 895, 896, 891, 925, 440, 869, 898, 312, 440, 822, + 440, 440, 901, 894, 440, 897, 440, 900, 440, 440, + + 312, 440, 440, 440, 243, 312, 440, 902, 440, 440, + 440, 440, 440, 904, 440, 905, 440, 440, 440, 927, + 903, 440, 440, 934, 1011, 907, 440, 440, 312, 440, + 440, 440, 440, 440, 440, 906, 440, 440, 440, 909, + 440, 440, 440, 908, 928, 440, 913, 440, 440, 440, + 312, 440, 910, 440, 911, 440, 912, 440, 440, 440, + 440, 1323, 440, 440, 312, 930, 440, 440, 914, 440, + 440, 440, 440, 440, 440, 440, 440, 440, 440, 440, + 440, 440, 440, 312, 312, 826, 312, 440, 440, 915, + 931, 440, 440, 440, 312, 917, 916, 440, 440, 440, + + 440, 440, 440, 312, 440, 933, 312, 935, 830, 937, + 920, 440, 919, 440, 918, 312, 312, 312, 312, 922, + 936, 312, 312, 923, 921, 949, 996, 243, 998, 950, + 938, 202, 202, 202, 202, 942, 202, 924, 949, 243, + 1001, 997, 974, 243, 202, 202, 202, 202, 944, 202, + 943, 951, 947, 240, 243, 240, 946, 312, 202, 202, + 202, 202, 945, 202, 243, 1000, 948, 202, 202, 202, + 202, 1147, 202, 202, 202, 202, 202, 240, 202, 240, + 202, 202, 202, 202, 975, 202, 202, 202, 202, 202, + 999, 202, 976, 977, 243, 1003, 979, 202, 202, 202, + + 202, 240, 202, 240, 1004, 978, 202, 202, 202, 202, + 1005, 202, 243, 958, 202, 202, 202, 202, 1008, 202, + 243, 980, 981, 202, 202, 202, 202, 243, 202, 1007, + 960, 202, 202, 202, 202, 243, 202, 202, 202, 202, + 202, 243, 202, 202, 202, 202, 202, 994, 202, 983, + 963, 995, 243, 982, 202, 202, 202, 202, 312, 202, + 202, 202, 202, 202, 243, 202, 202, 202, 202, 202, + 1016, 202, 202, 202, 202, 202, 1148, 202, 202, 202, + 202, 202, 243, 202, 202, 202, 202, 202, 1006, 202, + 243, 243, 985, 202, 202, 202, 202, 243, 202, 1010, + + 984, 312, 1013, 951, 987, 1012, 202, 202, 202, 202, + 986, 202, 202, 202, 202, 202, 989, 202, 202, 202, + 202, 202, 988, 202, 202, 202, 202, 202, 990, 202, + 243, 243, 243, 243, 243, 312, 312, 312, 949, 1014, + 1049, 1017, 1044, 1015, 992, 1018, 312, 440, 991, 1021, + 1019, 440, 1009, 993, 1020, 440, 440, 440, 1045, 440, + 1022, 440, 440, 1023, 312, 440, 440, 440, 440, 1024, + 440, 1053, 440, 1026, 440, 274, 440, 1028, 1030, 440, + 440, 312, 1025, 440, 440, 1058, 440, 1029, 440, 440, + 1027, 440, 440, 440, 440, 440, 440, 440, 312, 1032, + + 440, 1046, 440, 440, 440, 1033, 1031, 440, 440, 440, + 440, 440, 440, 440, 440, 440, 312, 1050, 440, 440, + 440, 440, 440, 440, 440, 440, 440, 1035, 312, 440, + 440, 440, 440, 1052, 440, 440, 1034, 440, 1037, 440, + 440, 312, 440, 1047, 1039, 1036, 440, 440, 312, 440, + 958, 440, 1040, 1038, 312, 312, 440, 440, 440, 440, + 312, 1048, 312, 1051, 960, 1042, 312, 312, 1041, 1043, + 312, 312, 963, 312, 312, 312, 202, 202, 202, 202, + 243, 202, 1055, 1108, 202, 202, 202, 202, 1083, 202, + 240, 1102, 240, 1057, 1059, 1054, 240, 243, 240, 1103, + + 1109, 1060, 1062, 243, 1063, 243, 202, 202, 202, 202, + 1061, 202, 202, 202, 202, 202, 1106, 202, 243, 202, + 202, 202, 202, 1111, 202, 202, 202, 202, 202, 240, + 202, 240, 1084, 1086, 243, 1104, 1105, 1085, 202, 202, + 202, 202, 243, 202, 243, 1107, 243, 1087, 202, 202, + 202, 202, 243, 202, 202, 202, 202, 202, 240, 202, + 240, 1110, 243, 1088, 202, 202, 202, 202, 240, 202, + 240, 312, 243, 1090, 1114, 1089, 202, 202, 202, 202, + 1143, 1092, 243, 202, 202, 202, 202, 1091, 202, 202, + 202, 202, 202, 1112, 202, 202, 202, 202, 202, 1118, + + 202, 202, 202, 202, 202, 243, 202, 202, 202, 202, + 202, 312, 202, 202, 202, 202, 202, 274, 202, 202, + 202, 202, 202, 243, 202, 1113, 243, 243, 1093, 202, + 202, 202, 202, 1094, 202, 202, 202, 202, 202, 440, + 202, 1095, 243, 1115, 243, 1096, 312, 1116, 1117, 440, + 1151, 440, 1097, 1121, 440, 312, 312, 440, 1098, 243, + 1099, 440, 1140, 1119, 440, 1120, 440, 440, 1146, 440, + 1122, 440, 440, 1123, 1100, 440, 1124, 1141, 440, 440, + 1101, 1125, 440, 243, 440, 440, 440, 440, 440, 440, + 1126, 440, 1128, 1127, 440, 1130, 440, 440, 440, 312, + + 440, 1204, 243, 440, 1129, 1272, 440, 440, 440, 440, + 440, 440, 440, 440, 440, 440, 312, 312, 440, 1142, + 440, 440, 440, 440, 440, 440, 440, 312, 440, 1131, + 312, 1132, 440, 440, 440, 440, 1145, 440, 440, 312, + 440, 1133, 1134, 440, 1144, 440, 1135, 312, 312, 312, + 312, 312, 312, 1137, 1136, 243, 1197, 1150, 243, 1231, + 1138, 202, 202, 202, 202, 1139, 202, 202, 202, 202, + 202, 1152, 202, 243, 1177, 1200, 1203, 243, 1153, 1178, + 1195, 202, 202, 202, 202, 1156, 202, 1154, 1155, 1194, + 1157, 1158, 243, 312, 243, 1179, 202, 202, 202, 202, + + 243, 202, 1232, 1162, 202, 202, 202, 202, 1209, 202, + 202, 202, 202, 202, 312, 202, 202, 202, 202, 202, + 1196, 202, 243, 1180, 202, 202, 202, 202, 1233, 202, + 243, 202, 202, 202, 202, 1181, 202, 202, 202, 202, + 202, 243, 202, 1201, 1207, 243, 1182, 202, 202, 202, + 202, 243, 202, 202, 202, 202, 202, 1183, 202, 202, + 202, 202, 202, 1206, 202, 202, 202, 202, 202, 1311, + 202, 202, 202, 202, 202, 240, 202, 240, 202, 202, + 202, 202, 1185, 202, 243, 243, 312, 274, 1187, 1186, + 202, 202, 202, 202, 1230, 202, 1205, 202, 202, 202, + + 202, 1188, 202, 1198, 1199, 243, 1208, 243, 243, 243, + 1212, 1189, 312, 1202, 1162, 1215, 1191, 1190, 440, 1214, + 440, 440, 440, 1307, 1213, 440, 274, 1210, 440, 1211, + 440, 440, 440, 440, 1319, 440, 1192, 440, 1216, 440, + 440, 1303, 440, 1193, 440, 440, 1217, 1302, 440, 440, + 440, 440, 440, 440, 1218, 440, 440, 440, 440, 440, + 440, 1219, 440, 440, 1220, 440, 440, 440, 440, 440, + 440, 440, 440, 312, 440, 312, 312, 440, 1223, 440, + 440, 312, 440, 440, 440, 1221, 312, 440, 1222, 1234, + 1235, 1224, 312, 440, 440, 440, 440, 440, 312, 440, + + 1225, 312, 1236, 1226, 312, 312, 312, 312, 1227, 202, + 202, 202, 202, 1267, 202, 1269, 1238, 1228, 312, 240, + 1229, 240, 1240, 1239, 202, 202, 202, 202, 1301, 202, + 243, 1247, 243, 1258, 1270, 1241, 243, 243, 1244, 1271, + 1292, 243, 1242, 1300, 1273, 1243, 243, 1245, 1246, 202, + 202, 202, 202, 243, 202, 1277, 1249, 202, 202, 202, + 202, 1275, 202, 202, 202, 202, 202, 243, 202, 202, + 202, 202, 202, 274, 202, 202, 202, 202, 202, 1259, + 202, 202, 202, 202, 202, 312, 202, 1276, 243, 1260, + 1262, 1309, 202, 202, 202, 202, 1261, 202, 202, 202, + + 202, 202, 1290, 202, 202, 202, 202, 202, 274, 202, + 202, 202, 202, 202, 1343, 202, 202, 202, 202, 202, + 1299, 202, 202, 202, 202, 202, 312, 202, 202, 202, + 202, 202, 240, 202, 240, 1278, 1264, 202, 202, 202, + 202, 440, 202, 1280, 1298, 1289, 440, 1285, 1265, 440, + 312, 440, 1247, 440, 440, 1266, 440, 1279, 440, 440, + 440, 440, 312, 1281, 440, 440, 440, 312, 440, 1249, + 440, 1274, 440, 1282, 440, 440, 1284, 440, 440, 1283, + 440, 440, 440, 1291, 440, 440, 440, 312, 440, 440, + 312, 440, 440, 440, 440, 440, 440, 440, 440, 440, + + 440, 440, 312, 440, 312, 312, 440, 440, 440, 240, + 1310, 240, 1286, 440, 1293, 440, 1287, 440, 312, 440, + 243, 1308, 240, 1288, 240, 1320, 1295, 243, 312, 1296, + 202, 202, 202, 202, 312, 202, 202, 202, 202, 202, + 1321, 202, 202, 202, 202, 202, 240, 202, 240, 1300, + 274, 202, 202, 202, 202, 1304, 202, 202, 202, 202, + 202, 1347, 202, 1305, 1302, 202, 202, 202, 202, 1312, + 202, 202, 202, 202, 202, 1306, 202, 202, 202, 202, + 202, 312, 202, 1300, 440, 440, 243, 312, 312, 312, + 440, 1302, 1316, 1313, 440, 440, 1314, 440, 440, 1315, + + 440, 1317, 440, 1318, 440, 440, 1322, 274, 440, 440, + 440, 240, 440, 240, 440, 440, 440, 440, 1330, 440, + 312, 440, 440, 312, 440, 202, 202, 202, 202, 1294, + 202, 202, 202, 202, 202, 243, 202, 202, 202, 202, + 202, 240, 202, 240, 1325, 240, 440, 240, 1333, 440, + 312, 312, 274, 1325, 440, 1327, 440, 1334, 440, 440, + 1332, 440, 1340, 240, 440, 240, 440, 243, 243, 1335, + 202, 202, 202, 202, 240, 202, 240, 1337, 1342, 243, + 312, 240, 1337, 240, 440, 240, 240, 240, 240, 243, + 243, 243, 243, 1268, 440, 1331, 440, 1346, 1263, 1257, + + 1256, 1255, 1254, 1253, 1252, 1251, 1250, 1249, 1248, 1247, + 1237, 312, 243, 1184, 1176, 1341, 197, 1175, 197, 197, + 197, 197, 202, 202, 202, 204, 204, 204, 232, 232, + 232, 232, 232, 232, 239, 1174, 239, 239, 239, 239, + 243, 1173, 243, 243, 243, 243, 268, 1172, 268, 268, + 268, 268, 274, 1171, 1170, 274, 274, 274, 279, 1169, + 1168, 279, 279, 279, 304, 1167, 304, 304, 304, 304, + 312, 312, 314, 314, 229, 229, 229, 229, 229, 229, + 405, 1166, 405, 405, 405, 405, 438, 1165, 1164, 438, + 438, 438, 440, 1163, 1162, 440, 440, 440, 471, 1161, + + 471, 471, 471, 471, 1160, 1159, 1149, 312, 274, 274, + 274, 274, 274, 243, 1082, 1081, 1080, 1079, 1078, 1077, + 1076, 1075, 1074, 1073, 1072, 1071, 1070, 1069, 1068, 1067, + 1066, 1065, 1064, 274, 274, 274, 1002, 973, 972, 971, + 970, 969, 968, 967, 966, 965, 964, 963, 962, 961, + 960, 959, 958, 957, 956, 955, 954, 953, 952, 951, + 312, 312, 274, 274, 274, 274, 243, 243, 843, 840, + 839, 838, 837, 836, 835, 834, 833, 832, 831, 830, + 829, 828, 827, 826, 825, 824, 823, 822, 821, 820, + 819, 312, 312, 243, 243, 739, 700, 699, 698, 697, + + 696, 695, 694, 693, 692, 691, 690, 689, 688, 687, + 686, 685, 684, 683, 680, 679, 678, 677, 676, 675, + 674, 673, 672, 671, 670, 312, 274, 243, 580, 539, + 538, 537, 536, 532, 531, 530, 529, 528, 527, 526, + 525, 524, 523, 522, 521, 520, 519, 518, 517, 516, + 515, 514, 513, 512, 511, 510, 509, 508, 312, 313, + 274, 243, 203, 198, 372, 371, 370, 369, 366, 365, + 364, 363, 362, 361, 358, 357, 356, 355, 354, 353, + 352, 349, 343, 342, 171, 312, 313, 278, 253, 203, + 196, 195, 194, 193, 192, 189, 188, 187, 186, 182, + + 181, 180, 179, 178, 175, 174, 173, 171, 1348, 11, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348 } ; -static yyconst short int yy_chk[1579] = +static yyconst short int yy_chk[4266] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 13, - 13, 13, 14, 14, 14, 28, 34, 50, 58, 99, - 58, 56, 171, 171, 28, 2, 50, 315, 99, 34, - 55, 55, 55, 55, 56, 61, 55, 61, 315, 55, - 59, 59, 59, 60, 60, 60, 804, 2, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 2, 13, 13, 13, 14, + 14, 14, 25, 31, 31, 36, 43, 75, 161, 75, + 25, 78, 31, 78, 36, 2, 50, 50, 50, 50, + 43, 50, 52, 52, 52, 52, 86, 52, 58, 58, + 58, 58, 79, 58, 79, 86, 58, 52, 161, 1349, + 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 3, 4, 62, 63, 62, - 63, 64, 65, 64, 65, 63, 66, 67, 66, 67, - 68, 105, 68, 4, 70, 65, 70, 64, 72, 68, - 72, 79, 795, 79, 105, 66, 178, 72, 178, 67, - 83, 83, 83, 70, 792, 4, 5, 5, 5, 5, + 3, 3, 3, 3, 3, 3, 4, 51, 51, 51, + 51, 80, 51, 80, 54, 54, 54, 54, 4, 54, + 53, 53, 53, 53, 96, 53, 4, 76, 76, 76, + 96, 51, 53, 1347, 92, 54, 56, 56, 56, 56, + 81, 56, 81, 54, 77, 77, 77, 82, 56, 82, + + 92, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, - 5, 5, 5, 5, 6, 69, 71, 69, 71, 73, - 76, 73, 76, 80, 212, 80, 84, 84, 84, 123, - 638, 6, 80, 85, 85, 85, 638, 104, 123, 69, - 104, 173, 173, 71, 212, 80, 107, 107, 107, 76, - 179, 73, 179, 6, 7, 7, 7, 7, 7, 7, + 5, 5, 5, 5, 5, 5, 5, 6, 98, 55, + 55, 55, 55, 87, 55, 57, 57, 57, 57, 98, + 57, 59, 59, 59, 59, 87, 59, 6, 55, 61, + 61, 61, 61, 91, 61, 91, 90, 57, 63, 63, + 63, 63, 89, 63, 139, 59, 63, 89, 90, 1344, + + 139, 61, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 8, 78, 128, 78, 108, 108, 108, 109, - 109, 109, 130, 130, 130, 144, 167, 128, 181, 8, - 181, 174, 174, 174, 174, 181, 207, 174, 144, 167, - 174, 176, 176, 207, 176, 78, 198, 176, 198, 789, - 176, 8, 9, 9, 9, 9, 9, 9, 9, 9, + 7, 7, 7, 7, 7, 7, 7, 7, 8, 104, + 60, 60, 60, 60, 101, 60, 62, 62, 62, 62, + 104, 62, 71, 71, 71, 71, 71, 100, 8, 60, + 60, 71, 101, 83, 71, 83, 88, 149, 60, 88, + 94, 94, 100, 83, 88, 94, 62, 149, 95, 94, + + 95, 229, 229, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, - - 10, 35, 57, 217, 74, 75, 74, 75, 77, 81, - 77, 81, 81, 106, 129, 151, 177, 10, 180, 180, - 180, 182, 183, 182, 183, 184, 186, 184, 186, 192, - 182, 192, 788, 74, 184, 787, 217, 35, 57, 10, - 35, 57, 74, 312, 75, 183, 186, 77, 81, 106, - 129, 81, 106, 129, 151, 177, 185, 187, 185, 187, - 188, 189, 188, 189, 190, 191, 190, 191, 312, 188, - 193, 192, 193, 194, 187, 194, 218, 185, 195, 190, - 195, 189, 196, 197, 196, 197, 199, 200, 199, 200, - 201, 202, 201, 202, 202, 204, 204, 204, 191, 208, - - 193, 194, 205, 205, 205, 206, 206, 206, 208, 209, - 200, 210, 213, 211, 194, 214, 195, 215, 218, 219, - 210, 216, 220, 221, 214, 197, 196, 222, 223, 213, - 225, 309, 209, 202, 211, 250, 216, 215, 224, 226, - 224, 226, 227, 224, 226, 227, 228, 228, 228, 219, - 220, 245, 309, 225, 229, 229, 229, 230, 230, 230, - 308, 221, 263, 220, 245, 282, 289, 308, 289, 263, - 223, 222, 282, 263, 250, 310, 282, 288, 288, 290, - 288, 290, 316, 288, 227, 313, 288, 289, 291, 292, - 291, 292, 316, 293, 294, 293, 294, 295, 313, 295, - - 296, 310, 296, 291, 320, 290, 293, 294, 295, 297, - 296, 297, 317, 298, 292, 298, 299, 300, 299, 300, - 301, 302, 301, 302, 303, 304, 303, 304, 305, 306, - 305, 306, 311, 314, 297, 319, 321, 317, 318, 322, - 324, 323, 298, 320, 325, 411, 314, 311, 326, 329, - 326, 577, 329, 326, 301, 303, 300, 578, 328, 299, - 328, 301, 342, 328, 302, 301, 411, 318, 304, 342, - 321, 305, 323, 342, 387, 784, 387, 321, 319, 412, - 577, 321, 322, 324, 388, 387, 388, 325, 389, 413, - 389, 329, 412, 390, 391, 390, 391, 392, 578, 392, - - 388, 390, 391, 393, 394, 393, 394, 395, 396, 395, - 396, 413, 397, 389, 397, 395, 393, 398, 392, 398, - 399, 400, 399, 400, 407, 401, 394, 401, 405, 402, - 405, 402, 403, 404, 403, 404, 406, 409, 410, 415, - 407, 408, 414, 417, 418, 409, 410, 406, 419, 420, - 414, 421, 396, 688, 398, 423, 422, 399, 458, 460, - 400, 473, 401, 402, 403, 475, 408, 404, 477, 476, - 477, 476, 458, 460, 783, 473, 477, 782, 779, 475, - 417, 418, 476, 415, 688, 421, 420, 419, 422, 423, - 478, 479, 478, 479, 480, 481, 480, 481, 478, 482, - - 483, 482, 483, 484, 485, 484, 485, 482, 486, 487, - 486, 487, 488, 498, 488, 489, 491, 489, 491, 483, - 490, 481, 490, 493, 492, 494, 492, 495, 500, 499, - 504, 502, 503, 494, 505, 495, 493, 499, 506, 498, - 485, 508, 507, 509, 487, 521, 523, 500, 486, 554, - 489, 554, 490, 491, 778, 488, 492, 554, 774, 521, - 523, 555, 556, 555, 556, 504, 490, 502, 570, 558, - 492, 558, 503, 506, 507, 509, 570, 505, 508, 557, - 576, 557, 559, 560, 559, 560, 579, 557, 507, 509, - 559, 561, 562, 561, 562, 563, 564, 563, 564, 565, - - 566, 565, 566, 567, 573, 567, 568, 569, 568, 569, - 575, 580, 573, 582, 581, 579, 583, 584, 575, 585, - 561, 640, 773, 576, 563, 622, 560, 622, 565, 623, - 639, 623, 566, 562, 624, 568, 624, 564, 625, 569, - 625, 641, 567, 581, 625, 582, 584, 626, 628, 626, - 628, 585, 580, 642, 627, 583, 627, 629, 630, 629, - 630, 631, 640, 631, 632, 633, 632, 633, 634, 643, - 634, 644, 639, 646, 645, 647, 679, 678, 679, 678, - 680, 772, 680, 682, 641, 682, 689, 693, 681, 626, - 681, 628, 690, 691, 642, 627, 692, 683, 629, 683, - - 630, 694, 632, 631, 684, 696, 684, 633, 678, 697, - 634, 643, 645, 644, 685, 646, 685, 647, 679, 680, - 681, 686, 682, 686, 687, 691, 687, 695, 689, 781, - 693, 690, 740, 771, 728, 692, 728, 729, 742, 729, - 683, 730, 738, 730, 694, 745, 786, 684, 696, 685, - 770, 731, 697, 731, 732, 733, 732, 733, 734, 735, - 734, 735, 695, 736, 686, 736, 728, 687, 737, 766, - 737, 766, 781, 740, 738, 745, 767, 762, 767, 742, - 786, 768, 730, 768, 769, 780, 769, 780, 791, 735, - 770, 785, 790, 785, 790, 732, 791, 794, 758, 794, - - 790, 755, 752, 750, 748, 747, 746, 744, 743, 766, - 741, 739, 725, 722, 720, 718, 715, 712, 710, 708, - 707, 706, 705, 704, 703, 785, 702, 701, 780, 797, - 700, 797, 797, 797, 798, 798, 799, 799, 799, 799, - 799, 800, 699, 800, 800, 800, 801, 698, 801, 801, - 801, 802, 677, 676, 802, 802, 803, 675, 803, 803, - 803, 805, 805, 805, 805, 805, 806, 674, 806, 806, - 806, 807, 673, 672, 807, 807, 808, 671, 808, 808, - 808, 670, 669, 668, 667, 666, 665, 664, 663, 662, - 661, 660, 659, 658, 657, 656, 655, 654, 653, 652, - - 651, 650, 649, 648, 637, 636, 635, 621, 620, 619, - 618, 617, 616, 615, 614, 613, 612, 611, 610, 609, - 608, 607, 606, 605, 604, 603, 602, 598, 597, 596, - 595, 594, 593, 592, 591, 590, 589, 588, 587, 586, - 574, 572, 571, 553, 552, 551, 550, 549, 548, 547, - 546, 545, 544, 543, 542, 540, 539, 538, 537, 536, - 535, 534, 533, 532, 531, 530, 529, 527, 524, 522, - 520, 519, 518, 517, 516, 515, 514, 513, 512, 511, - 510, 501, 497, 496, 474, 472, 471, 470, 469, 468, - 467, 466, 465, 464, 463, 462, 461, 459, 457, 456, - - 455, 454, 453, 451, 450, 449, 446, 445, 444, 442, - 441, 440, 439, 438, 437, 436, 434, 433, 432, 431, - 430, 429, 428, 427, 426, 425, 424, 416, 385, 384, - 383, 382, 381, 380, 379, 377, 376, 375, 374, 373, - 372, 371, 370, 369, 368, 367, 365, 364, 363, 362, - 361, 360, 359, 357, 356, 355, 354, 353, 352, 351, - 350, 349, 348, 346, 345, 344, 343, 341, 340, 339, - 338, 337, 336, 335, 334, 333, 332, 331, 330, 327, - 307, 286, 285, 284, 283, 281, 280, 279, 278, 277, - 276, 275, 274, 273, 272, 271, 270, 269, 267, 266, - - 265, 264, 262, 261, 260, 259, 258, 257, 256, 255, - 254, 253, 252, 251, 249, 248, 247, 246, 244, 243, - 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, - 232, 203, 175, 170, 169, 168, 166, 165, 164, 163, - 162, 161, 160, 159, 158, 157, 156, 155, 154, 153, - 149, 147, 146, 145, 143, 142, 141, 140, 139, 138, - 137, 136, 135, 134, 133, 132, 131, 127, 126, 125, - 124, 122, 121, 120, 119, 118, 117, 116, 115, 114, - 113, 111, 103, 102, 101, 100, 98, 97, 96, 95, - 94, 93, 92, 91, 90, 89, 88, 54, 53, 52, - - 51, 49, 48, 47, 46, 45, 44, 43, 42, 41, - 40, 39, 38, 32, 31, 30, 29, 27, 26, 25, - 24, 23, 22, 21, 20, 19, 18, 17, 11, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796, 796, 796, - 796, 796, 796, 796, 796, 796, 796, 796 + 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, + 44, 64, 64, 64, 64, 1342, 64, 65, 65, 65, + 65, 152, 65, 66, 66, 66, 66, 97, 66, 10, + 44, 67, 67, 67, 67, 152, 67, 68, 68, 68, + 68, 103, 68, 97, 150, 105, 64, 105, 102, 65, + + 153, 150, 44, 99, 10, 44, 102, 153, 65, 103, + 186, 99, 66, 69, 69, 69, 69, 319, 69, 68, + 99, 106, 186, 67, 70, 70, 70, 70, 319, 70, + 107, 72, 72, 72, 72, 106, 72, 106, 136, 73, + 73, 73, 73, 123, 73, 123, 136, 73, 155, 136, + 107, 155, 72, 123, 107, 69, 109, 109, 109, 70, + 72, 73, 74, 74, 74, 74, 126, 74, 110, 110, + 110, 124, 107, 154, 74, 107, 111, 111, 111, 126, + 124, 178, 74, 125, 125, 159, 127, 126, 124, 127, + 154, 125, 129, 129, 127, 178, 128, 128, 128, 1339, + + 129, 142, 142, 142, 74, 128, 128, 74, 84, 84, + 159, 84, 84, 84, 84, 84, 84, 84, 84, 148, + 84, 85, 85, 131, 85, 85, 85, 85, 85, 85, + 85, 85, 130, 85, 132, 134, 131, 158, 148, 135, + 130, 130, 132, 134, 131, 1338, 160, 135, 132, 160, + 85, 118, 118, 134, 158, 118, 118, 118, 118, 118, + 135, 118, 250, 118, 119, 119, 250, 133, 119, 119, + 119, 119, 119, 151, 119, 133, 119, 138, 133, 143, + 143, 143, 137, 481, 163, 138, 156, 133, 481, 151, + 137, 138, 164, 119, 120, 120, 140, 151, 120, 120, + + 120, 120, 120, 137, 120, 156, 120, 166, 1336, 140, + 140, 144, 144, 144, 120, 121, 121, 140, 163, 121, + 121, 121, 121, 121, 162, 121, 141, 121, 248, 164, + 165, 167, 121, 122, 122, 157, 248, 122, 122, 122, + 122, 122, 175, 122, 166, 122, 141, 141, 176, 157, + 157, 162, 175, 168, 175, 141, 168, 165, 157, 122, + 162, 167, 193, 176, 169, 201, 411, 122, 141, 169, + 168, 141, 170, 170, 170, 193, 204, 204, 204, 204, + 411, 204, 231, 231, 169, 201, 205, 205, 205, 205, + 239, 205, 239, 262, 205, 206, 206, 206, 206, 240, + + 206, 240, 262, 206, 1333, 242, 169, 242, 247, 169, + 201, 207, 207, 207, 207, 242, 207, 208, 208, 208, + 208, 247, 208, 247, 207, 241, 241, 241, 208, 323, + 209, 209, 209, 209, 207, 209, 207, 210, 210, 210, + 210, 244, 210, 208, 323, 210, 209, 211, 211, 211, + 211, 483, 211, 212, 212, 212, 212, 244, 212, 210, + 213, 213, 213, 213, 253, 213, 214, 214, 214, 214, + 483, 214, 253, 245, 212, 211, 215, 215, 215, 215, + 213, 215, 214, 265, 215, 216, 216, 216, 216, 245, + 216, 217, 217, 217, 217, 251, 217, 486, 251, 217, + + 265, 216, 218, 218, 218, 218, 254, 218, 219, 219, + 219, 219, 218, 219, 486, 220, 220, 220, 220, 252, + 220, 258, 254, 252, 218, 258, 255, 1328, 219, 220, + 221, 221, 221, 221, 255, 221, 222, 222, 222, 222, + 260, 222, 223, 223, 223, 223, 263, 223, 224, 224, + 224, 224, 260, 224, 225, 225, 225, 225, 256, 225, + 226, 226, 226, 226, 263, 226, 221, 227, 227, 227, + 227, 268, 227, 268, 256, 223, 246, 228, 228, 228, + 228, 222, 228, 249, 1326, 225, 246, 246, 246, 336, + 224, 232, 232, 232, 232, 232, 257, 249, 225, 249, + + 232, 226, 259, 232, 233, 233, 233, 233, 257, 233, + 257, 330, 259, 261, 227, 233, 234, 234, 234, 234, + 330, 234, 228, 235, 235, 336, 235, 235, 278, 269, + 233, 269, 235, 1324, 261, 235, 270, 270, 278, 234, + 236, 236, 236, 236, 267, 236, 237, 237, 237, 237, + 266, 237, 264, 272, 237, 238, 238, 238, 238, 264, + 238, 236, 271, 273, 271, 267, 304, 238, 304, 272, + 321, 332, 264, 266, 304, 238, 275, 275, 275, 276, + 276, 276, 286, 273, 277, 277, 277, 273, 306, 283, + 306, 283, 286, 321, 286, 284, 306, 286, 284, 315, + + 238, 283, 315, 283, 283, 284, 1323, 284, 273, 279, + 279, 332, 318, 279, 279, 279, 279, 279, 318, 279, + 339, 279, 280, 280, 329, 337, 280, 280, 280, 280, + 280, 322, 280, 318, 280, 280, 281, 281, 339, 329, + 281, 281, 281, 281, 281, 487, 281, 322, 281, 281, + 282, 282, 487, 287, 282, 282, 282, 282, 282, 285, + 282, 287, 282, 287, 285, 287, 316, 337, 282, 316, + 290, 1320, 288, 285, 285, 290, 285, 333, 282, 288, + 282, 324, 288, 289, 288, 290, 289, 290, 291, 292, + 326, 291, 324, 289, 292, 289, 293, 415, 291, 293, + + 291, 326, 296, 294, 292, 333, 292, 415, 293, 293, + 294, 293, 296, 294, 296, 294, 295, 295, 325, 297, + 298, 325, 328, 299, 300, 296, 295, 328, 295, 297, + 298, 297, 298, 299, 300, 299, 300, 301, 302, 328, + 298, 412, 300, 327, 303, 412, 327, 301, 302, 301, + 302, 297, 299, 307, 303, 300, 303, 305, 307, 331, + 308, 309, 309, 309, 334, 301, 338, 305, 307, 305, + 307, 335, 302, 308, 317, 409, 303, 310, 310, 310, + 308, 320, 317, 308, 320, 308, 311, 311, 311, 421, + 331, 409, 317, 340, 317, 341, 340, 335, 320, 1318, + + 341, 334, 367, 421, 407, 308, 338, 407, 408, 367, + 335, 408, 410, 367, 410, 341, 373, 373, 373, 373, + 426, 373, 374, 374, 374, 374, 417, 374, 375, 375, + 375, 375, 414, 375, 414, 426, 375, 373, 417, 416, + 341, 416, 419, 374, 376, 376, 376, 376, 430, 376, + 377, 377, 377, 377, 419, 377, 378, 378, 378, 378, + 377, 378, 379, 379, 379, 379, 430, 379, 418, 418, + 376, 813, 380, 380, 380, 380, 378, 380, 381, 381, + 381, 381, 422, 381, 423, 422, 379, 423, 382, 382, + 382, 382, 381, 382, 383, 383, 383, 383, 380, 383, + + 384, 384, 384, 384, 813, 384, 383, 427, 427, 420, + 382, 385, 385, 385, 385, 588, 385, 386, 386, 386, + 386, 420, 386, 385, 425, 384, 425, 588, 424, 386, + 387, 387, 387, 387, 424, 387, 388, 388, 388, 388, + 387, 388, 389, 389, 389, 389, 428, 389, 390, 390, + 390, 390, 429, 390, 428, 433, 431, 388, 391, 391, + 391, 391, 479, 391, 431, 479, 390, 485, 434, 389, + 392, 392, 392, 392, 429, 392, 485, 433, 434, 392, + 393, 393, 393, 393, 391, 393, 394, 394, 394, 394, + 480, 394, 395, 395, 395, 395, 439, 395, 396, 396, + + 396, 396, 435, 396, 577, 393, 439, 397, 397, 397, + 397, 480, 397, 577, 398, 398, 398, 398, 394, 398, + 399, 399, 399, 399, 435, 399, 400, 400, 400, 400, + 1316, 400, 401, 401, 401, 401, 504, 401, 395, 397, + 396, 402, 402, 402, 402, 477, 402, 403, 403, 403, + 403, 398, 403, 488, 404, 404, 404, 404, 398, 404, + 400, 477, 398, 436, 440, 504, 399, 403, 405, 405, + 484, 405, 405, 488, 440, 432, 440, 405, 401, 1309, + 405, 406, 406, 406, 406, 436, 406, 402, 432, 443, + 441, 484, 406, 442, 443, 432, 495, 444, 441, 432, + + 441, 442, 441, 442, 443, 442, 443, 444, 445, 444, + 444, 445, 446, 489, 499, 447, 498, 495, 448, 446, + 489, 445, 446, 445, 446, 447, 447, 447, 448, 450, + 448, 448, 449, 449, 451, 451, 452, 497, 450, 450, + 478, 450, 449, 498, 449, 451, 452, 451, 452, 453, + 453, 455, 454, 454, 455, 499, 478, 497, 457, 456, + 453, 482, 453, 454, 455, 454, 455, 456, 457, 456, + 457, 456, 457, 458, 459, 460, 482, 491, 458, 460, + 461, 492, 491, 458, 459, 458, 459, 459, 462, 460, + 461, 460, 461, 463, 464, 493, 500, 492, 462, 465, + + 462, 490, 467, 463, 464, 463, 464, 462, 490, 465, + 466, 465, 467, 519, 467, 468, 584, 493, 465, 469, + 466, 584, 466, 464, 503, 468, 463, 468, 470, 469, + 502, 469, 519, 500, 466, 467, 468, 472, 470, 1308, + 470, 466, 471, 473, 471, 466, 474, 472, 474, 472, + 471, 475, 469, 473, 474, 473, 475, 476, 494, 496, + 501, 470, 502, 496, 505, 503, 475, 506, 475, 502, + 476, 494, 576, 502, 579, 576, 579, 476, 582, 582, + 476, 595, 476, 540, 540, 540, 540, 501, 540, 541, + 541, 541, 541, 540, 541, 542, 542, 542, 542, 541, + + 542, 574, 476, 1307, 595, 505, 575, 580, 506, 543, + 543, 543, 543, 580, 543, 574, 544, 544, 544, 544, + 575, 544, 542, 544, 543, 545, 545, 545, 545, 578, + 545, 546, 546, 546, 546, 589, 546, 547, 547, 547, + 547, 585, 547, 589, 598, 581, 578, 545, 548, 548, + 548, 548, 581, 548, 549, 549, 549, 549, 585, 549, + 585, 546, 550, 550, 550, 550, 598, 550, 547, 551, + 551, 551, 551, 548, 551, 602, 551, 587, 549, 591, + 587, 550, 552, 552, 552, 552, 591, 552, 602, 552, + 586, 553, 553, 553, 553, 551, 553, 554, 554, 554, + + 554, 1303, 554, 555, 555, 555, 555, 586, 555, 554, + 592, 604, 553, 556, 556, 556, 556, 592, 556, 555, + 557, 557, 557, 557, 604, 557, 558, 558, 558, 558, + 666, 558, 556, 559, 559, 559, 559, 594, 559, 560, + 560, 560, 560, 593, 560, 593, 560, 561, 561, 561, + 561, 557, 561, 1301, 594, 559, 600, 558, 562, 562, + 562, 562, 666, 562, 563, 563, 563, 563, 662, 563, + 564, 564, 564, 564, 600, 564, 590, 565, 565, 565, + 565, 590, 565, 566, 566, 566, 566, 597, 566, 603, + 567, 567, 567, 567, 561, 567, 568, 568, 568, 568, + + 603, 568, 611, 597, 563, 569, 569, 569, 569, 662, + 569, 611, 611, 642, 611, 642, 564, 565, 570, 570, + 570, 570, 599, 570, 1244, 566, 571, 571, 571, 571, + 567, 571, 643, 568, 572, 572, 572, 572, 599, 572, + 569, 601, 572, 573, 573, 573, 573, 606, 573, 643, + 606, 607, 1244, 645, 607, 570, 572, 601, 608, 609, + 606, 609, 606, 573, 607, 612, 607, 610, 608, 609, + 608, 609, 608, 610, 613, 612, 1299, 612, 614, 645, + 620, 620, 612, 610, 613, 610, 613, 615, 614, 617, + 614, 620, 613, 620, 616, 617, 618, 615, 615, 615, + + 616, 619, 618, 648, 616, 617, 616, 617, 617, 619, + 622, 619, 618, 619, 618, 621, 622, 648, 621, 623, + 622, 653, 622, 624, 1297, 621, 627, 621, 626, 623, + 625, 623, 653, 624, 626, 624, 627, 623, 627, 625, + 625, 624, 625, 628, 626, 638, 626, 629, 641, 639, + 638, 630, 631, 628, 639, 628, 632, 629, 641, 629, + 627, 630, 631, 630, 631, 633, 632, 640, 632, 730, + 634, 635, 647, 644, 629, 633, 636, 633, 730, 631, + 634, 635, 634, 635, 630, 632, 636, 637, 636, 640, + 646, 647, 633, 635, 634, 651, 657, 637, 644, 637, + + 636, 649, 650, 649, 650, 652, 654, 655, 656, 659, + 646, 651, 652, 657, 658, 661, 658, 663, 664, 665, + 654, 698, 649, 667, 668, 700, 701, 701, 701, 701, + 1296, 701, 732, 655, 656, 698, 731, 732, 734, 700, + 734, 701, 703, 703, 703, 703, 735, 703, 731, 735, + 661, 659, 663, 667, 665, 664, 668, 702, 702, 702, + 702, 703, 702, 704, 704, 704, 704, 748, 704, 702, + 704, 705, 705, 705, 705, 755, 705, 706, 706, 706, + 706, 748, 706, 707, 707, 707, 707, 737, 707, 755, + 742, 737, 705, 708, 708, 708, 708, 733, 708, 741, + + 708, 741, 742, 707, 709, 709, 709, 709, 706, 709, + 710, 710, 710, 710, 733, 710, 711, 711, 711, 711, + 810, 711, 712, 712, 712, 712, 736, 712, 711, 713, + 713, 713, 713, 736, 713, 709, 713, 714, 714, 714, + 714, 743, 714, 743, 715, 715, 715, 715, 712, 715, + 716, 716, 716, 716, 810, 716, 717, 717, 717, 717, + 716, 717, 739, 1295, 738, 714, 744, 717, 744, 739, + 715, 718, 718, 718, 718, 797, 718, 719, 719, 719, + 719, 738, 719, 720, 720, 720, 720, 747, 720, 747, + 718, 721, 721, 721, 721, 941, 721, 722, 722, 722, + + 722, 797, 722, 723, 723, 723, 723, 745, 723, 724, + 724, 724, 724, 751, 724, 751, 719, 725, 725, 725, + 725, 746, 725, 753, 745, 746, 720, 726, 726, 726, + 726, 811, 726, 793, 941, 722, 727, 727, 727, 727, + 793, 727, 753, 729, 729, 729, 729, 724, 729, 723, + 749, 729, 725, 728, 728, 728, 728, 750, 728, 752, + 756, 757, 750, 749, 759, 802, 725, 726, 758, 811, + 760, 727, 802, 792, 752, 757, 728, 762, 762, 758, + 759, 760, 756, 792, 761, 727, 761, 795, 762, 795, + 762, 763, 764, 758, 761, 760, 761, 763, 764, 766, + + 805, 763, 767, 763, 890, 794, 768, 766, 764, 766, + 764, 766, 767, 768, 767, 769, 768, 770, 768, 794, + 767, 769, 771, 805, 890, 773, 773, 770, 796, 770, + 775, 769, 771, 769, 771, 770, 773, 777, 773, 776, + 775, 778, 775, 775, 796, 776, 780, 777, 780, 777, + 798, 778, 777, 778, 778, 776, 779, 776, 780, 779, + 780, 1294, 781, 783, 800, 798, 784, 785, 781, 779, + 786, 779, 781, 783, 781, 783, 784, 785, 784, 785, + 786, 787, 786, 799, 803, 799, 806, 788, 789, 783, + 800, 787, 790, 787, 814, 786, 784, 788, 789, 788, + + 789, 791, 790, 808, 790, 803, 804, 806, 804, 808, + 789, 791, 788, 791, 787, 807, 809, 815, 816, 790, + 807, 817, 818, 791, 789, 819, 872, 875, 875, 819, + 809, 846, 846, 846, 846, 814, 846, 791, 846, 873, + 879, 873, 846, 872, 847, 847, 847, 847, 816, 847, + 815, 847, 818, 874, 879, 874, 817, 1052, 848, 848, + 848, 848, 816, 848, 877, 877, 818, 849, 849, 849, + 849, 1052, 849, 850, 850, 850, 850, 878, 850, 878, + 851, 851, 851, 851, 848, 851, 852, 852, 852, 852, + 876, 852, 849, 850, 876, 881, 852, 853, 853, 853, + + 853, 882, 853, 882, 883, 851, 854, 854, 854, 854, + 884, 854, 881, 854, 855, 855, 855, 855, 887, 855, + 883, 853, 855, 856, 856, 856, 856, 884, 856, 886, + 856, 857, 857, 857, 857, 887, 857, 858, 858, 858, + 858, 886, 858, 859, 859, 859, 859, 871, 859, 858, + 859, 871, 895, 857, 860, 860, 860, 860, 1053, 860, + 861, 861, 861, 861, 871, 861, 862, 862, 862, 862, + 895, 862, 863, 863, 863, 863, 1053, 863, 864, 864, + 864, 864, 892, 864, 865, 865, 865, 865, 885, 865, + 885, 889, 861, 866, 866, 866, 866, 891, 866, 889, + + 860, 926, 892, 926, 863, 891, 867, 867, 867, 867, + 862, 867, 868, 868, 868, 868, 865, 868, 869, 869, + 869, 869, 864, 869, 870, 870, 870, 870, 866, 870, + 888, 893, 894, 896, 897, 931, 925, 927, 925, 893, + 931, 896, 925, 894, 868, 897, 943, 900, 867, 899, + 898, 902, 888, 869, 898, 899, 898, 900, 927, 900, + 900, 902, 903, 902, 937, 899, 898, 899, 898, 903, + 904, 937, 903, 906, 903, 1280, 906, 908, 911, 907, + 904, 928, 904, 908, 911, 943, 906, 910, 906, 907, + 907, 907, 910, 908, 911, 908, 911, 912, 932, 913, + + 913, 928, 910, 915, 910, 914, 912, 912, 916, 912, + 913, 914, 913, 915, 917, 915, 936, 932, 916, 918, + 916, 914, 919, 914, 917, 920, 917, 916, 929, 918, + 921, 918, 919, 936, 919, 920, 915, 920, 918, 922, + 921, 930, 921, 929, 920, 917, 923, 924, 933, 922, + 933, 922, 921, 919, 939, 940, 923, 924, 923, 924, + 934, 930, 935, 934, 935, 923, 942, 944, 922, 924, + 938, 945, 938, 946, 948, 947, 974, 974, 974, 974, + 1004, 974, 940, 1004, 975, 975, 975, 975, 974, 975, + 994, 995, 994, 942, 944, 939, 996, 998, 996, 998, + + 1006, 945, 947, 995, 948, 1006, 976, 976, 976, 976, + 946, 976, 977, 977, 977, 977, 1001, 977, 1001, 978, + 978, 978, 978, 1009, 978, 979, 979, 979, 979, 1003, + 979, 1003, 976, 978, 999, 999, 1000, 977, 980, 980, + 980, 980, 1009, 980, 1002, 1002, 1000, 979, 981, 981, + 981, 981, 1012, 981, 982, 982, 982, 982, 1005, 982, + 1005, 1007, 1007, 980, 983, 983, 983, 983, 1008, 983, + 1008, 1048, 1010, 982, 1012, 981, 984, 984, 984, 984, + 1048, 984, 1016, 985, 985, 985, 985, 983, 985, 986, + 986, 986, 986, 1010, 986, 987, 987, 987, 987, 1016, + + 987, 988, 988, 988, 988, 1011, 988, 989, 989, 989, + 989, 1056, 989, 990, 990, 990, 990, 1278, 990, 991, + 991, 991, 991, 1013, 991, 1011, 1014, 1015, 985, 992, + 992, 992, 992, 986, 992, 993, 993, 993, 993, 1022, + 993, 987, 1017, 1013, 1018, 988, 1051, 1014, 1015, 1022, + 1056, 1022, 989, 1020, 1020, 1044, 1046, 1023, 990, 1277, + 991, 1024, 1044, 1017, 1020, 1018, 1020, 1023, 1051, 1023, + 1023, 1024, 1026, 1024, 992, 1025, 1025, 1046, 1027, 1029, + 993, 1026, 1026, 1113, 1026, 1025, 1031, 1025, 1027, 1029, + 1027, 1029, 1031, 1029, 1032, 1034, 1031, 1035, 1031, 1047, + + 1036, 1113, 1200, 1034, 1032, 1200, 1032, 1035, 1037, 1035, + 1036, 1038, 1036, 1034, 1039, 1034, 1050, 1055, 1037, 1047, + 1037, 1038, 1040, 1038, 1039, 1041, 1039, 1049, 1042, 1035, + 1057, 1036, 1040, 1043, 1040, 1041, 1050, 1041, 1042, 1058, + 1042, 1037, 1038, 1043, 1049, 1043, 1039, 1059, 1060, 1061, + 1062, 1063, 1141, 1041, 1040, 1112, 1105, 1055, 1276, 1141, + 1042, 1083, 1083, 1083, 1083, 1043, 1083, 1084, 1084, 1084, + 1084, 1057, 1084, 1105, 1083, 1109, 1112, 1109, 1058, 1084, + 1103, 1085, 1085, 1085, 1085, 1061, 1085, 1059, 1060, 1102, + 1062, 1063, 1103, 1142, 1118, 1085, 1086, 1086, 1086, 1086, + + 1102, 1086, 1142, 1086, 1087, 1087, 1087, 1087, 1118, 1087, + 1088, 1088, 1088, 1088, 1144, 1088, 1089, 1089, 1089, 1089, + 1104, 1089, 1116, 1087, 1090, 1090, 1090, 1090, 1144, 1090, + 1104, 1091, 1091, 1091, 1091, 1089, 1091, 1093, 1093, 1093, + 1093, 1110, 1093, 1110, 1116, 1115, 1090, 1094, 1094, 1094, + 1094, 1275, 1094, 1095, 1095, 1095, 1095, 1091, 1095, 1096, + 1096, 1096, 1096, 1115, 1096, 1097, 1097, 1097, 1097, 1272, + 1097, 1098, 1098, 1098, 1098, 1111, 1098, 1111, 1099, 1099, + 1099, 1099, 1093, 1099, 1117, 1114, 1140, 1285, 1095, 1094, + 1100, 1100, 1100, 1100, 1140, 1100, 1114, 1101, 1101, 1101, + + 1101, 1096, 1101, 1106, 1108, 1119, 1117, 1120, 1106, 1108, + 1121, 1097, 1143, 1111, 1143, 1124, 1099, 1098, 1123, 1123, + 1121, 1124, 1121, 1263, 1122, 1122, 1130, 1119, 1123, 1120, + 1123, 1124, 1125, 1124, 1285, 1122, 1100, 1122, 1125, 1126, + 1127, 1254, 1125, 1101, 1125, 1128, 1127, 1253, 1129, 1126, + 1127, 1126, 1127, 1131, 1128, 1128, 1133, 1128, 1129, 1132, + 1129, 1129, 1134, 1131, 1130, 1131, 1133, 1135, 1133, 1132, + 1136, 1132, 1134, 1147, 1134, 1146, 1150, 1135, 1133, 1135, + 1136, 1148, 1136, 1137, 1138, 1131, 1151, 1139, 1132, 1146, + 1147, 1134, 1152, 1137, 1138, 1137, 1138, 1139, 1153, 1139, + + 1135, 1154, 1148, 1136, 1155, 1156, 1157, 1158, 1137, 1178, + 1178, 1178, 1178, 1194, 1178, 1196, 1150, 1138, 1235, 1197, + 1139, 1197, 1152, 1151, 1177, 1177, 1177, 1177, 1252, 1177, + 1194, 1177, 1196, 1178, 1198, 1153, 1198, 1199, 1156, 1199, + 1235, 1204, 1154, 1251, 1201, 1155, 1209, 1157, 1158, 1179, + 1179, 1179, 1179, 1201, 1179, 1209, 1179, 1180, 1180, 1180, + 1180, 1204, 1180, 1181, 1181, 1181, 1181, 1206, 1181, 1182, + 1182, 1182, 1182, 1334, 1182, 1183, 1183, 1183, 1183, 1180, + 1183, 1185, 1185, 1185, 1185, 1233, 1185, 1206, 1270, 1181, + 1183, 1270, 1186, 1186, 1186, 1186, 1182, 1186, 1187, 1187, + + 1187, 1187, 1233, 1187, 1188, 1188, 1188, 1188, 1220, 1188, + 1189, 1189, 1189, 1189, 1334, 1189, 1190, 1190, 1190, 1190, + 1250, 1190, 1191, 1191, 1191, 1191, 1231, 1191, 1192, 1192, + 1192, 1192, 1202, 1192, 1202, 1212, 1186, 1193, 1193, 1193, + 1193, 1212, 1193, 1214, 1248, 1231, 1213, 1220, 1188, 1214, + 1230, 1212, 1230, 1212, 1216, 1191, 1213, 1213, 1213, 1214, + 1217, 1214, 1234, 1216, 1216, 1218, 1216, 1232, 1221, 1232, + 1217, 1202, 1217, 1217, 1219, 1218, 1219, 1218, 1221, 1218, + 1221, 1222, 1223, 1234, 1219, 1224, 1219, 1239, 1225, 1226, + 1241, 1222, 1223, 1222, 1223, 1224, 1228, 1224, 1225, 1226, + + 1225, 1226, 1246, 1227, 1236, 1289, 1228, 1229, 1228, 1267, + 1271, 1267, 1222, 1227, 1236, 1227, 1224, 1229, 1290, 1229, + 1268, 1268, 1269, 1227, 1269, 1289, 1239, 1271, 1245, 1241, + 1258, 1258, 1258, 1258, 1243, 1258, 1259, 1259, 1259, 1259, + 1290, 1259, 1260, 1260, 1260, 1260, 1274, 1260, 1274, 1260, + 1343, 1261, 1261, 1261, 1261, 1258, 1261, 1262, 1262, 1262, + 1262, 1343, 1262, 1259, 1262, 1264, 1264, 1264, 1264, 1273, + 1264, 1265, 1265, 1265, 1265, 1261, 1265, 1266, 1266, 1266, + 1266, 1291, 1266, 1291, 1279, 1281, 1273, 1292, 1242, 1293, + 1283, 1293, 1282, 1274, 1279, 1281, 1279, 1281, 1282, 1281, + + 1283, 1283, 1283, 1284, 1286, 1287, 1292, 1319, 1282, 1284, + 1282, 1310, 1288, 1310, 1286, 1287, 1286, 1287, 1311, 1284, + 1240, 1284, 1288, 1238, 1288, 1304, 1304, 1304, 1304, 1237, + 1304, 1305, 1305, 1305, 1305, 1311, 1305, 1306, 1306, 1306, + 1306, 1312, 1306, 1312, 1306, 1313, 1314, 1313, 1317, 1315, + 1321, 1322, 1215, 1322, 1317, 1305, 1314, 1319, 1314, 1315, + 1315, 1315, 1329, 1330, 1317, 1330, 1317, 1211, 1210, 1321, + 1327, 1327, 1327, 1327, 1331, 1327, 1331, 1327, 1332, 1329, + 1335, 1340, 1335, 1340, 1332, 1346, 1341, 1346, 1341, 1208, + 1207, 1205, 1203, 1195, 1332, 1313, 1332, 1341, 1184, 1174, + + 1171, 1169, 1167, 1166, 1165, 1164, 1163, 1161, 1160, 1159, + 1149, 1145, 1107, 1092, 1082, 1331, 1350, 1081, 1350, 1350, + 1350, 1350, 1351, 1351, 1351, 1352, 1352, 1352, 1353, 1353, + 1353, 1353, 1353, 1353, 1354, 1080, 1354, 1354, 1354, 1354, + 1355, 1079, 1355, 1355, 1355, 1355, 1356, 1078, 1356, 1356, + 1356, 1356, 1357, 1077, 1076, 1357, 1357, 1357, 1358, 1075, + 1074, 1358, 1358, 1358, 1359, 1073, 1359, 1359, 1359, 1359, + 1360, 1360, 1361, 1361, 1362, 1362, 1362, 1362, 1362, 1362, + 1363, 1072, 1363, 1363, 1363, 1363, 1364, 1071, 1070, 1364, + 1364, 1364, 1365, 1068, 1067, 1365, 1365, 1365, 1366, 1066, + + 1366, 1366, 1366, 1366, 1065, 1064, 1054, 1045, 1033, 1030, + 1028, 1021, 1019, 997, 973, 972, 971, 970, 969, 968, + 967, 966, 965, 964, 962, 961, 959, 957, 956, 955, + 954, 953, 950, 909, 905, 901, 880, 845, 844, 843, + 842, 841, 840, 839, 838, 837, 836, 835, 834, 833, + 832, 831, 829, 828, 827, 825, 824, 823, 821, 820, + 812, 801, 782, 774, 772, 765, 754, 740, 699, 697, + 696, 695, 693, 692, 690, 689, 688, 687, 686, 685, + 684, 682, 679, 678, 677, 676, 675, 673, 672, 671, + 670, 669, 660, 605, 596, 583, 538, 537, 536, 535, + + 534, 533, 532, 531, 529, 528, 527, 526, 525, 524, + 523, 522, 521, 520, 518, 517, 516, 515, 514, 513, + 512, 511, 510, 509, 508, 507, 438, 437, 413, 371, + 370, 369, 368, 366, 365, 364, 363, 362, 361, 360, + 359, 358, 357, 356, 355, 354, 353, 352, 351, 350, + 349, 348, 347, 346, 345, 344, 343, 342, 314, 313, + 274, 243, 203, 200, 198, 196, 195, 194, 192, 191, + 190, 189, 188, 187, 185, 184, 183, 182, 181, 180, + 179, 177, 174, 173, 171, 147, 146, 117, 93, 49, + 41, 40, 39, 38, 37, 35, 34, 33, 32, 30, + + 29, 28, 27, 26, 24, 23, 22, 20, 11, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, 1348, + 1348, 1348, 1348, 1348, 1348 } ; static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr; @@ -1099,13 +2048,32 @@ char *yytext; #include "AppHdr.h" #include "levcomp.tab.h" #include <cstring> +#include <queue> static bool alloced = false; +std::queue<const char *> free_queue; + +static void flush_free_queue(int max_allowed) +{ + while (free_queue.size() > max_allowed) + { + const char *s = free_queue.front(); + free((void *) s); + free_queue.pop(); + } +} + +static void add_to_queue(const char *s) +{ + free_queue.push(s); + flush_free_queue(20); +} + static void clean() { if (yylval.text && alloced) - free( (void*) yylval.text); + add_to_queue(yylval.text); yylval.text = NULL; alloced = false; } @@ -1126,7 +2094,7 @@ static void settext() #define KEYWORDS 4 #define YY_NEVER_INTERACTIVE 1 -#line 1130 "levcomp.lex.cc" +#line 2098 "levcomp.lex.cc" /* Macros after this point can all be overridden by user definitions in * section 1. @@ -1226,20 +2194,9 @@ YY_MALLOC_DECL YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ - else \ - { \ - errno=0; \ - while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - } + else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ + && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - @@ -1291,10 +2248,10 @@ YY_DECL register char *yy_cp, *yy_bp; register int yy_act; -#line 41 "levcomp.lpp" +#line 60 "levcomp.lpp" -#line 1298 "levcomp.lex.cc" +#line 2255 "levcomp.lex.cc" if ( yy_init ) { @@ -1343,14 +2300,14 @@ yy_match: while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 797 ) + if ( yy_current_state >= 1349 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; *yy_state_ptr++ = yy_current_state; ++yy_cp; } - while ( yy_base[yy_current_state] != 1530 ); + while ( yy_base[yy_current_state] != 4210 ); yy_find_action: yy_current_state = *--yy_state_ptr; @@ -1388,17 +2345,17 @@ do_action: /* This label is used only to access EOF actions. */ { /* beginning of action switch */ case 1: YY_RULE_SETUP -#line 43 "levcomp.lpp" +#line 62 "levcomp.lpp" { BEGIN(INITIAL); } YY_BREAK case 2: YY_RULE_SETUP -#line 45 "levcomp.lpp" +#line 64 "levcomp.lpp" ; YY_BREAK case 3: YY_RULE_SETUP -#line 47 "levcomp.lpp" +#line 66 "levcomp.lpp" { settext(); return MAP_LINE; @@ -1406,219 +2363,322 @@ YY_RULE_SETUP YY_BREAK case 4: YY_RULE_SETUP -#line 52 "levcomp.lpp" +#line 71 "levcomp.lpp" { BEGIN(MAPDEF); } YY_BREAK case 5: YY_RULE_SETUP -#line 54 "levcomp.lpp" +#line 73 "levcomp.lpp" ; YY_BREAK case 6: YY_RULE_SETUP -#line 56 "levcomp.lpp" +#line 75 "levcomp.lpp" { BEGIN(ARGUMENT); return NAME; } YY_BREAK case 7: YY_RULE_SETUP -#line 57 "levcomp.lpp" +#line 76 "levcomp.lpp" return DEFAULT_DEPTH; YY_BREAK case 8: YY_RULE_SETUP -#line 58 "levcomp.lpp" +#line 77 "levcomp.lpp" return DEPTH; YY_BREAK case 9: YY_RULE_SETUP -#line 59 "levcomp.lpp" +#line 78 "levcomp.lpp" return ORIENT; YY_BREAK case 10: YY_RULE_SETUP -#line 60 "levcomp.lpp" +#line 79 "levcomp.lpp" { BEGIN(ARGUMENT); return PLACE; } YY_BREAK case 11: YY_RULE_SETUP -#line 61 "levcomp.lpp" +#line 80 "levcomp.lpp" return CHANCE; YY_BREAK case 12: YY_RULE_SETUP -#line 62 "levcomp.lpp" +#line 81 "levcomp.lpp" return FLAGS; YY_BREAK case 13: YY_RULE_SETUP -#line 63 "levcomp.lpp" +#line 82 "levcomp.lpp" { BEGIN(KEYWORDS); return TAGS; } YY_BREAK case 14: YY_RULE_SETUP -#line 64 "levcomp.lpp" +#line 83 "levcomp.lpp" { BEGIN(ARGUMENT); return SYMBOL; } YY_BREAK case 15: YY_RULE_SETUP -#line 65 "levcomp.lpp" +#line 84 "levcomp.lpp" { BEGIN(MNAME); return MONS; } YY_BREAK case 16: YY_RULE_SETUP -#line 67 "levcomp.lpp" -{ +#line 86 "levcomp.lpp" +return BRANCH; + YY_BREAK +case 17: +YY_RULE_SETUP +#line 87 "levcomp.lpp" +return DEFAULT; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 88 "levcomp.lpp" +return DESC; + YY_BREAK +case 19: +YY_RULE_SETUP +#line 89 "levcomp.lpp" +return BRANCH; + YY_BREAK +case 20: +YY_RULE_SETUP +#line 90 "levcomp.lpp" +return ROOT_DEPTH; + YY_BREAK +case 21: +YY_RULE_SETUP +#line 91 "levcomp.lpp" +return FLOOR_COLOUR; + YY_BREAK +case 22: +YY_RULE_SETUP +#line 92 "levcomp.lpp" +return ROCK_COLOUR; + YY_BREAK +case 23: +YY_RULE_SETUP +#line 94 "levcomp.lpp" +return LEVEL; + YY_BREAK +case 24: +YY_RULE_SETUP +#line 95 "levcomp.lpp" +return END; + YY_BREAK +case 25: +YY_RULE_SETUP +#line 96 "levcomp.lpp" +return PVAULT; + YY_BREAK +case 26: +YY_RULE_SETUP +#line 97 "levcomp.lpp" +return PMINIVAULT; + YY_BREAK +case 27: +YY_RULE_SETUP +#line 99 "levcomp.lpp" +{ BEGIN(ARGUMENT); return ENTRY_MSG; } + YY_BREAK +case 28: +YY_RULE_SETUP +#line 100 "levcomp.lpp" +{ BEGIN(ARGUMENT); return EXIT_MSG; } + YY_BREAK +case 29: +YY_RULE_SETUP +#line 102 "levcomp.lpp" +return MONSTERS; + YY_BREAK +case 30: +YY_RULE_SETUP +#line 103 "levcomp.lpp" +return ENDMONSTERS; + YY_BREAK +case 31: +YY_RULE_SETUP +#line 105 "levcomp.lpp" +{ settext(); return STRING; } YY_BREAK -case 17: +case 32: YY_RULE_SETUP -#line 72 "levcomp.lpp" +#line 110 "levcomp.lpp" ; YY_BREAK -case 18: +case 33: YY_RULE_SETUP -#line 73 "levcomp.lpp" +#line 111 "levcomp.lpp" { BEGIN(INITIAL); } YY_BREAK -case 19: +case 34: YY_RULE_SETUP -#line 75 "levcomp.lpp" +#line 113 "levcomp.lpp" { settext(); return MONSTER_NAME; } YY_BREAK -case 20: +case 35: YY_RULE_SETUP -#line 80 "levcomp.lpp" +#line 118 "levcomp.lpp" return COMMA; YY_BREAK -case 21: +case 36: YY_RULE_SETUP -#line 81 "levcomp.lpp" +#line 119 "levcomp.lpp" { BEGIN(INITIAL); } YY_BREAK -case 22: +case 37: YY_RULE_SETUP -#line 82 "levcomp.lpp" +#line 120 "levcomp.lpp" ; YY_BREAK -case 23: +case 38: YY_RULE_SETUP -#line 84 "levcomp.lpp" +#line 122 "levcomp.lpp" return PANDEMONIC; YY_BREAK -case 24: +case 39: YY_RULE_SETUP -#line 85 "levcomp.lpp" +#line 123 "levcomp.lpp" return NO_HMIRROR; YY_BREAK -case 25: +case 40: YY_RULE_SETUP -#line 86 "levcomp.lpp" +#line 124 "levcomp.lpp" return NO_VMIRROR; YY_BREAK -case 26: +case 41: YY_RULE_SETUP -#line 87 "levcomp.lpp" +#line 125 "levcomp.lpp" return NO_ROTATE; YY_BREAK -case 27: +case 42: YY_RULE_SETUP -#line 89 "levcomp.lpp" +#line 127 "levcomp.lpp" return ENCOMPASS; YY_BREAK -case 28: +case 43: YY_RULE_SETUP -#line 90 "levcomp.lpp" +#line 128 "levcomp.lpp" return NORTH; YY_BREAK -case 29: +case 44: YY_RULE_SETUP -#line 91 "levcomp.lpp" +#line 129 "levcomp.lpp" return SOUTH; YY_BREAK -case 30: +case 45: YY_RULE_SETUP -#line 92 "levcomp.lpp" +#line 130 "levcomp.lpp" return EAST; YY_BREAK -case 31: +case 46: YY_RULE_SETUP -#line 93 "levcomp.lpp" +#line 131 "levcomp.lpp" return WEST; YY_BREAK -case 32: +case 47: YY_RULE_SETUP -#line 94 "levcomp.lpp" +#line 132 "levcomp.lpp" return NORTHEAST; YY_BREAK -case 33: +case 48: YY_RULE_SETUP -#line 95 "levcomp.lpp" +#line 133 "levcomp.lpp" return NORTHWEST; YY_BREAK -case 34: +case 49: YY_RULE_SETUP -#line 96 "levcomp.lpp" +#line 134 "levcomp.lpp" return SOUTHEAST; YY_BREAK -case 35: +case 50: YY_RULE_SETUP -#line 97 "levcomp.lpp" +#line 135 "levcomp.lpp" return SOUTHWEST; YY_BREAK -case 36: +case 51: YY_RULE_SETUP -#line 99 "levcomp.lpp" +#line 136 "levcomp.lpp" +return FLOAT; + YY_BREAK +case 52: +YY_RULE_SETUP +#line 138 "levcomp.lpp" return DASH; YY_BREAK -case 37: +case 53: YY_RULE_SETUP -#line 100 "levcomp.lpp" +#line 139 "levcomp.lpp" return COMMA; YY_BREAK -case 38: +case 54: YY_RULE_SETUP -#line 102 "levcomp.lpp" +#line 141 "levcomp.lpp" { clean(); yylval.i = atoi(yytext); return INTEGER; } YY_BREAK -case 39: +case 55: YY_RULE_SETUP -#line 108 "levcomp.lpp" +#line 147 "levcomp.lpp" { BEGIN(INITIAL); settext(); return STRING; } YY_BREAK -case 40: +case 56: YY_RULE_SETUP -#line 114 "levcomp.lpp" +#line 153 "levcomp.lpp" { BEGIN(INITIAL); } YY_BREAK -case 41: +case 57: YY_RULE_SETUP -#line 116 "levcomp.lpp" +#line 155 "levcomp.lpp" ; YY_BREAK -case 42: +case 58: YY_RULE_SETUP -#line 118 "levcomp.lpp" -return BAD_CHARACTER; +#line 157 "levcomp.lpp" +return OPAREN; YY_BREAK -case 43: +case 59: YY_RULE_SETUP -#line 120 "levcomp.lpp" +#line 158 "levcomp.lpp" +return CPAREN; + YY_BREAK +case 60: +YY_RULE_SETUP +#line 160 "levcomp.lpp" +return QUOTE; + YY_BREAK +case 61: +YY_RULE_SETUP +#line 162 "levcomp.lpp" +{ + settext(); + return IDENTIFIER; + } + YY_BREAK +case 62: +YY_RULE_SETUP +#line 167 "levcomp.lpp" +return CHARACTER; + YY_BREAK +case 63: +YY_RULE_SETUP +#line 169 "levcomp.lpp" ECHO; YY_BREAK -#line 1622 "levcomp.lex.cc" +#line 2682 "levcomp.lex.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(MAPDEF): case YY_STATE_EOF(ARGUMENT): @@ -1912,7 +2972,7 @@ static yy_state_type yy_get_previous_state() while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 797 ) + if ( yy_current_state >= 1349 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -1942,11 +3002,11 @@ yy_state_type yy_current_state; while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 797 ) + if ( yy_current_state >= 1349 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; - yy_is_jam = (yy_current_state == 796); + yy_is_jam = (yy_current_state == 1348); if ( ! yy_is_jam ) *yy_state_ptr++ = yy_current_state; @@ -2186,15 +3246,11 @@ YY_BUFFER_STATE b; } -#ifndef _WIN32 -#include <unistd.h> -#else #ifndef YY_ALWAYS_INTERACTIVE #ifndef YY_NEVER_INTERACTIVE extern int isatty YY_PROTO(( int )); #endif #endif -#endif #ifdef YY_USE_PROTOS void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) @@ -2512,11 +3568,12 @@ int main() return 0; } #endif -#line 120 "levcomp.lpp" +#line 169 "levcomp.lpp" int yywrap() { clean(); + flush_free_queue(0); return 1; } diff --git a/crawl-ref/source/prebuilt/levcomp.tab.cc b/crawl-ref/source/prebuilt/levcomp.tab.cc index 4b4d9dc3f3..cb96ab1ce2 100644 --- a/crawl-ref/source/prebuilt/levcomp.tab.cc +++ b/crawl-ref/source/prebuilt/levcomp.tab.cc @@ -1,139 +1,60 @@ -/* A Bison parser, made by GNU Bison 2.3. */ -/* Skeleton implementation for Bison's Yacc-like parsers in C +/* A Bison parser, made from levcomp.ypp + by GNU Bison version 1.28 */ + +#define YYBISON 1 /* Identify Bison output. */ + +#define BRANCHDEF 257 +#define BRANCH 258 +#define DESC 259 +#define DEFAULT 260 +#define DEFAULT_DEPTH 261 +#define SYMBOL 262 +#define TAGS 263 +#define NAME 264 +#define DEPTH 265 +#define ORIENT 266 +#define PLACE 267 +#define CHANCE 268 +#define FLAGS 269 +#define MONS 270 +#define ROOT_DEPTH 271 +#define ENTRY_MSG 272 +#define EXIT_MSG 273 +#define ROCK_COLOUR 274 +#define FLOOR_COLOUR 275 +#define ENCOMPASS 276 +#define FLOAT 277 +#define NORTH 278 +#define EAST 279 +#define SOUTH 280 +#define WEST 281 +#define NORTHEAST 282 +#define SOUTHEAST 283 +#define SOUTHWEST 284 +#define NORTHWEST 285 +#define LEVEL 286 +#define END 287 +#define PVAULT 288 +#define PMINIVAULT 289 +#define MONSTERS 290 +#define ENDMONSTERS 291 +#define CHARACTER 292 +#define NO_HMIRROR 293 +#define NO_VMIRROR 294 +#define NO_ROTATE 295 +#define PANDEMONIC 296 +#define DASH 297 +#define COMMA 298 +#define QUOTE 299 +#define OPAREN 300 +#define CPAREN 301 +#define INTEGER 302 +#define STRING 303 +#define MAP_LINE 304 +#define MONSTER_NAME 305 +#define IDENTIFIER 306 - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.3" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - DEFAULT_DEPTH = 258, - SYMBOL = 259, - TAGS = 260, - NAME = 261, - DEPTH = 262, - ORIENT = 263, - PLACE = 264, - CHANCE = 265, - FLAGS = 266, - MONS = 267, - ENCOMPASS = 268, - NORTH = 269, - EAST = 270, - SOUTH = 271, - WEST = 272, - NORTHEAST = 273, - SOUTHEAST = 274, - SOUTHWEST = 275, - NORTHWEST = 276, - BAD_CHARACTER = 277, - NO_HMIRROR = 278, - NO_VMIRROR = 279, - NO_ROTATE = 280, - PANDEMONIC = 281, - DASH = 282, - COMMA = 283, - INTEGER = 284, - STRING = 285, - MAP_LINE = 286, - MONSTER_NAME = 287 - }; -#endif -/* Tokens. */ -#define DEFAULT_DEPTH 258 -#define SYMBOL 259 -#define TAGS 260 -#define NAME 261 -#define DEPTH 262 -#define ORIENT 263 -#define PLACE 264 -#define CHANCE 265 -#define FLAGS 266 -#define MONS 267 -#define ENCOMPASS 268 -#define NORTH 269 -#define EAST 270 -#define SOUTH 271 -#define WEST 272 -#define NORTHEAST 273 -#define SOUTHEAST 274 -#define SOUTHWEST 275 -#define NORTHWEST 276 -#define BAD_CHARACTER 277 -#define NO_HMIRROR 278 -#define NO_VMIRROR 279 -#define NO_ROTATE 280 -#define PANDEMONIC 281 -#define DASH 282 -#define COMMA 283 -#define INTEGER 284 -#define STRING 285 -#define MAP_LINE 286 -#define MONSTER_NAME 287 - - - - -/* Copy the first part of user declarations. */ #line 1 "levcomp.ypp" @@ -153,1105 +74,484 @@ void yyerror(const char *e) } - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE 0 -#endif - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 21 "levcomp.ypp" +#line 20 "levcomp.ypp" +typedef union { int i; const char *text; -} -/* Line 193 of yacc.c. */ -#line 184 "levcomp.tab.c" - YYSTYPE; -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif +} YYSTYPE; +#include <stdio.h> - - -/* Copy the second part of user declarations. */ - - -/* Line 216 of yacc.c. */ -#line 197 "levcomp.tab.c" - -#ifdef short -# undef short +#ifndef __cplusplus +#ifndef __STDC__ +#define const #endif - -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; #endif -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -typedef signed char yytype_int8; -#else -typedef short int yytype_int8; -#endif -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; -#else -typedef unsigned short int yytype_uint16; -#endif -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; -#else -typedef short int yytype_int16; -#endif +#define YYFINAL 71 +#define YYFLAG -32768 +#define YYNTBASE 53 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 306 ? yytranslate[x] : 80) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, + 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, + 47, 48, 49, 50, 51, 52 +}; -#ifndef YYSIZE_T -# ifdef __SIZE_TYPE__ -# define YYSIZE_T __SIZE_TYPE__ -# elif defined size_t -# define YYSIZE_T size_t -# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# else -# define YYSIZE_T unsigned int -# endif -#endif +#if YYDEBUG != 0 +static const short yyprhs[] = { 0, + 0, 2, 3, 6, 8, 10, 12, 15, 20, 23, + 24, 27, 29, 31, 33, 35, 37, 39, 41, 43, + 46, 47, 50, 52, 55, 57, 60, 64, 66, 68, + 71, 73, 76, 80, 82, 85, 87, 90, 92, 94, + 96, 98, 100, 102, 104, 106, 108, 110, 113, 114, + 117, 119, 121, 123, 125, 127, 130 +}; -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) - -#ifndef YY_ -# if YYENABLE_NLS -# if ENABLE_NLS -# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) -# endif -# endif -# ifndef YY_ -# define YY_(msgid) msgid -# endif -#endif +static const short yyrhs[] = { 54, + 0, 0, 55, 54, 0, 56, 0, 58, 0, 57, + 0, 7, 70, 0, 59, 60, 77, 60, 0, 10, + 49, 0, 0, 61, 60, 0, 68, 0, 69, 0, + 71, 0, 72, 0, 74, 0, 65, 0, 64, 0, + 62, 0, 9, 63, 0, 0, 49, 63, 0, 8, + 0, 8, 49, 0, 16, 0, 16, 66, 0, 67, + 44, 66, 0, 67, 0, 51, 0, 13, 49, 0, + 11, 0, 11, 70, 0, 48, 43, 48, 0, 48, + 0, 14, 48, 0, 12, 0, 12, 73, 0, 22, + 0, 24, 0, 25, 0, 26, 0, 27, 0, 28, + 0, 29, 0, 30, 0, 31, 0, 23, 0, 15, + 75, 0, 0, 76, 75, 0, 39, 0, 40, 0, + 41, 0, 78, 0, 79, 0, 79, 78, 0, 50, + 0 +}; -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) -#else -# define YYUSE(e) /* empty */ #endif -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(n) (n) -#else -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static int -YYID (int i) -#else -static int -YYID (i) - int i; -#endif -{ - return i; -} +#if YYDEBUG != 0 +static const short yyrline[] = { 0, + 52, 55, 56, 59, 60, 63, 66, 72, 111, 119, + 120, 123, 124, 125, 126, 127, 128, 129, 130, 133, + 136, 137, 145, 146, 152, 153, 156, 157, 160, 173, + 179, 180, 186, 191, 197, 203, 204, 210, 211, 212, + 213, 214, 215, 216, 217, 218, 219, 222, 225, 226, + 242, 243, 244, 247, 250, 251, 254 +}; #endif -#if ! defined yyoverflow || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# elif defined __BUILTIN_VA_ARG_INCR -# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ -# elif defined _AIX -# define YYSTACK_ALLOC __alloca -# elif defined _MSC_VER -# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ -# define alloca _alloca -# else -# define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) -# ifndef YYSTACK_ALLOC_MAXIMUM - /* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -# endif -# else -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# ifndef YYSTACK_ALLOC_MAXIMUM -# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -# endif -# if (defined __cplusplus && ! defined _STDLIB_H \ - && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - - -#if (! defined yyoverflow \ - && (! defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - yytype_int16 yyss; - YYSTYPE yyvs; - }; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (YYID (0)) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (YYID (0)) -#endif +#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 13 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 41 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 33 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 28 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 57 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 70 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 287 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const yytype_uint8 yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, - 25, 26, 27, 28, 29, 30, 31, 32 +static const char * const yytname[] = { "$","error","$undefined.","BRANCHDEF", +"BRANCH","DESC","DEFAULT","DEFAULT_DEPTH","SYMBOL","TAGS","NAME","DEPTH","ORIENT", +"PLACE","CHANCE","FLAGS","MONS","ROOT_DEPTH","ENTRY_MSG","EXIT_MSG","ROCK_COLOUR", +"FLOOR_COLOUR","ENCOMPASS","FLOAT","NORTH","EAST","SOUTH","WEST","NORTHEAST", +"SOUTHEAST","SOUTHWEST","NORTHWEST","LEVEL","END","PVAULT","PMINIVAULT","MONSTERS", +"ENDMONSTERS","CHARACTER","NO_HMIRROR","NO_VMIRROR","NO_ROTATE","PANDEMONIC", +"DASH","COMMA","QUOTE","OPAREN","CPAREN","INTEGER","STRING","MAP_LINE","MONSTER_NAME", +"IDENTIFIER","file","definitions","definition","def","defdepth","level","name", +"metalines","metaline","tags","tagstrings","symbol","mons","mnames","mname", +"place","depth","depth_range","chance","orientation","orient_name","flags","flagnames", +"flagname","map_def","map_lines","map_line", NULL }; +#endif -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const yytype_uint8 yyprhs[] = -{ - 0, 0, 3, 5, 6, 9, 11, 13, 15, 18, - 23, 26, 27, 30, 32, 34, 36, 38, 40, 42, - 44, 46, 49, 50, 53, 55, 58, 60, 63, 67, - 69, 71, 74, 76, 79, 83, 85, 88, 90, 93, - 95, 97, 99, 101, 103, 105, 107, 109, 111, 114, - 115, 118, 120, 122, 124, 126, 128, 131 +static const short yyr1[] = { 0, + 53, 54, 54, 55, 55, 56, 57, 58, 59, 60, + 60, 61, 61, 61, 61, 61, 61, 61, 61, 62, + 63, 63, 64, 64, 65, 65, 66, 66, 67, 68, + 69, 69, 70, 70, 71, 72, 72, 73, 73, 73, + 73, 73, 73, 73, 73, 73, 73, 74, 75, 75, + 76, 76, 76, 77, 78, 78, 79 }; -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int8 yyrhs[] = -{ - 34, 0, -1, 35, -1, -1, 36, 35, -1, 37, - -1, 39, -1, 38, -1, 3, 51, -1, 40, 41, - 58, 41, -1, 6, 30, -1, -1, 42, 41, -1, - 49, -1, 50, -1, 52, -1, 53, -1, 55, -1, - 46, -1, 45, -1, 43, -1, 5, 44, -1, -1, - 30, 44, -1, 4, -1, 4, 30, -1, 12, -1, - 12, 47, -1, 48, 28, 47, -1, 48, -1, 32, - -1, 9, 30, -1, 7, -1, 7, 51, -1, 29, - 27, 29, -1, 29, -1, 10, 29, -1, 8, -1, - 8, 54, -1, 13, -1, 14, -1, 15, -1, 16, - -1, 17, -1, 18, -1, 19, -1, 20, -1, 21, - -1, 11, 56, -1, -1, 57, 56, -1, 23, -1, - 24, -1, 25, -1, 59, -1, 60, -1, 60, 59, - -1, 31, -1 +static const short yyr2[] = { 0, + 1, 0, 2, 1, 1, 1, 2, 4, 2, 0, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 0, 2, 1, 2, 1, 2, 3, 1, 1, 2, + 1, 2, 3, 1, 2, 1, 2, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 2, 0, 2, + 1, 1, 1, 1, 1, 2, 1 }; -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const yytype_uint8 yyrline[] = -{ - 0, 46, 46, 49, 50, 53, 54, 57, 60, 66, - 72, 80, 81, 84, 85, 86, 87, 88, 89, 90, - 91, 94, 97, 98, 106, 107, 113, 114, 117, 118, - 121, 134, 140, 141, 147, 152, 158, 164, 165, 171, - 172, 173, 174, 175, 176, 177, 178, 179, 182, 185, - 186, 202, 203, 204, 207, 210, 211, 214 +static const short yydefact[] = { 2, + 0, 0, 1, 2, 4, 6, 5, 10, 34, 7, + 9, 3, 23, 21, 31, 36, 0, 0, 49, 25, + 0, 10, 19, 18, 17, 12, 13, 14, 15, 16, + 0, 24, 21, 20, 32, 38, 47, 39, 40, 41, + 42, 43, 44, 45, 46, 37, 30, 35, 51, 52, + 53, 48, 49, 29, 26, 28, 57, 10, 54, 55, + 11, 33, 22, 50, 0, 8, 56, 27, 0, 0, + 0 }; -#endif -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = -{ - "$end", "error", "$undefined", "DEFAULT_DEPTH", "SYMBOL", "TAGS", - "NAME", "DEPTH", "ORIENT", "PLACE", "CHANCE", "FLAGS", "MONS", - "ENCOMPASS", "NORTH", "EAST", "SOUTH", "WEST", "NORTHEAST", "SOUTHEAST", - "SOUTHWEST", "NORTHWEST", "BAD_CHARACTER", "NO_HMIRROR", "NO_VMIRROR", - "NO_ROTATE", "PANDEMONIC", "DASH", "COMMA", "INTEGER", "STRING", - "MAP_LINE", "MONSTER_NAME", "$accept", "file", "definitions", - "definition", "def", "defdepth", "level", "name", "metalines", - "metaline", "tags", "tagstrings", "symbol", "mons", "mnames", "mname", - "place", "depth", "depth_range", "chance", "orientation", "orient_name", - "flags", "flagnames", "flagname", "map_def", "map_lines", "map_line", 0 +static const short yydefgoto[] = { 69, + 3, 4, 5, 6, 7, 8, 21, 22, 23, 34, + 24, 25, 55, 56, 26, 27, 10, 28, 29, 46, + 30, 52, 53, 58, 59, 60 }; -#endif -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const yytype_uint16 yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287 +static const short yypact[] = { 13, + -35, -28,-32768, 13,-32768,-32768,-32768, 3, -16,-32768, +-32768,-32768, -27, -20, -35, -21, -19, -17, -15, -23, + -18, 3,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + -14,-32768, -20,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, -15,-32768,-32768, -11,-32768, 3,-32768, -18, +-32768,-32768,-32768,-32768, -23,-32768,-32768,-32768, 35, 37, +-32768 }; -# endif -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = -{ - 0, 33, 34, 35, 35, 36, 36, 37, 38, 39, - 40, 41, 41, 42, 42, 42, 42, 42, 42, 42, - 42, 43, 44, 44, 45, 45, 46, 46, 47, 47, - 48, 49, 50, 50, 51, 51, 52, 53, 53, 54, - 54, 54, 54, 54, 54, 54, 54, 54, 55, 56, - 56, 57, 57, 57, 58, 59, 59, 60 +static const short yypgoto[] = {-32768, + 34,-32768,-32768,-32768,-32768,-32768, -22,-32768,-32768, 6, +-32768,-32768, -25,-32768,-32768,-32768, 26,-32768,-32768,-32768, +-32768, -10,-32768,-32768, -13,-32768 }; -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = -{ - 0, 2, 1, 0, 2, 1, 1, 1, 2, 4, - 2, 0, 2, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 0, 2, 1, 2, 1, 2, 3, 1, - 1, 2, 1, 2, 3, 1, 2, 1, 2, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, - 2, 1, 1, 1, 1, 1, 2, 1 -}; -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const yytype_uint8 yydefact[] = -{ - 3, 0, 0, 0, 2, 3, 5, 7, 6, 11, - 35, 8, 10, 1, 4, 24, 22, 32, 37, 0, - 0, 49, 26, 0, 11, 20, 19, 18, 13, 14, - 15, 16, 17, 0, 25, 22, 21, 33, 39, 40, - 41, 42, 43, 44, 45, 46, 47, 38, 31, 36, - 51, 52, 53, 48, 49, 30, 27, 29, 57, 11, - 54, 55, 12, 34, 23, 50, 0, 9, 56, 28 -}; +#define YYLAST 47 -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int8 yydefgoto[] = -{ - -1, 3, 4, 5, 6, 7, 8, 9, 23, 24, - 25, 36, 26, 27, 56, 57, 28, 29, 11, 30, - 31, 47, 32, 53, 54, 59, 60, 61 -}; -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -29 -static const yytype_int8 yypact[] = -{ - 16, -17, -10, 21, -29, 16, -29, -29, -29, 6, - -1, -29, -29, -29, -29, -3, -2, -17, -12, 1, - 3, 0, 2, 5, 6, -29, -29, -29, -29, -29, - -29, -29, -29, 4, -29, -2, -29, -29, -29, -29, - -29, -29, -29, -29, -29, -29, -29, -29, -29, -29, - -29, -29, -29, -29, 0, -29, -29, 9, -29, 6, - -29, 5, -29, -29, -29, -29, 2, -29, -29, -29 +static const short yytable[] = { 61, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 13, 14, 9, 15, 16, 17, 18, 19, 20, 1, + 11, 32, 2, 49, 50, 51, 31, 54, 33, 47, + 48, 57, 65, 62, 70, 66, 71, 12, 63, 68, + 35, 0, 64, 0, 0, 0, 67 }; -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int8 yypgoto[] = -{ - -29, -29, 24, -29, -29, -29, -29, -29, -24, -29, - -29, -5, -29, -29, -28, -29, -29, -29, 22, -29, - -29, -29, -29, -14, -29, -29, -20, -29 +static const short yycheck[] = { 22, + 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 8, 9, 48, 11, 12, 13, 14, 15, 16, 7, + 49, 49, 10, 39, 40, 41, 43, 51, 49, 49, + 48, 50, 44, 48, 0, 58, 0, 4, 33, 65, + 15, -1, 53, -1, -1, -1, 60 }; +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "/usr/share/bison.simple" +/* This file comes from bison-1.28. */ -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -1 -static const yytype_uint8 yytable[] = -{ - 62, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 15, 16, 10, 17, 18, 19, 20, 21, 22, 1, - 12, 13, 2, 50, 51, 52, 33, 34, 35, 14, - 64, 48, 49, 63, 55, 67, 58, 66, 69, 37, - 65, 68 -}; +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. -static const yytype_uint8 yycheck[] = -{ - 24, 13, 14, 15, 16, 17, 18, 19, 20, 21, - 4, 5, 29, 7, 8, 9, 10, 11, 12, 3, - 30, 0, 6, 23, 24, 25, 27, 30, 30, 5, - 35, 30, 29, 29, 32, 59, 31, 28, 66, 17, - 54, 61 -}; + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = -{ - 0, 3, 6, 34, 35, 36, 37, 38, 39, 40, - 29, 51, 30, 0, 35, 4, 5, 7, 8, 9, - 10, 11, 12, 41, 42, 43, 45, 46, 49, 50, - 52, 53, 55, 27, 30, 30, 44, 51, 13, 14, - 15, 16, 17, 18, 19, 20, 21, 54, 30, 29, - 23, 24, 25, 56, 57, 32, 47, 48, 31, 58, - 59, 60, 41, 29, 44, 56, 28, 41, 59, 47 -}; + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef YYSTACK_USE_ALLOCA +#ifdef alloca +#define YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* YYSTACK_USE_ALLOCA not defined */ + +#ifdef YYSTACK_USE_ALLOCA +#define YYSTACK_ALLOC alloca +#else +#define YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) +#define YYEMPTY -2 #define YYEOF 0 - #define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrlab1 +/* Like YYERROR except do call yyerror. + This remains here temporarily to ease the + transition to the new meaning of YYERROR, for GCC. Once GCC version 2 has supplanted version 1, this can go. */ - #define YYFAIL goto yyerrlab - #define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ +#define YYBACKUP(token, value) \ do \ if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE (yychar); \ - YYPOPSTACK (1); \ + { yychar = (token), yylval = (value); \ + yychar1 = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ goto yybackup; \ } \ else \ - { \ - yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (YYID (0)) - + { yyerror ("syntax error: cannot back up"); YYERROR; } \ +while (0) #define YYTERROR 1 #define YYERRCODE 256 - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (N)) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (YYID (0)) -#endif - - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif +#ifndef YYPURE +#define YYLEX yylex() #endif - -/* YYLEX -- calling `yylex' with the right arguments. */ - +#ifdef YYPURE +#ifdef YYLSP_NEEDED #ifdef YYLEX_PARAM -# define YYLEX yylex (YYLEX_PARAM) +#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) #else -# define YYLEX yylex () +#define YYLEX yylex(&yylval, &yylloc) #endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - yy_symbol_print (stderr, \ - Type, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) -#else -static void -yy_symbol_value_print (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE const * const yyvaluep; -#endif -{ - if (!yyvaluep) - return; -# ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); -# else - YYUSE (yyoutput); -# endif - switch (yytype) - { - default: - break; - } -} - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) +#else /* not YYLSP_NEEDED */ +#ifdef YYLEX_PARAM +#define YYLEX yylex(&yylval, YYLEX_PARAM) #else -static void -yy_symbol_print (yyoutput, yytype, yyvaluep) - FILE *yyoutput; - int yytype; - YYSTYPE const * const yyvaluep; +#define YYLEX yylex(&yylval) #endif -{ - if (yytype < YYNTOKENS) - YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); - - yy_symbol_value_print (yyoutput, yytype, yyvaluep); - YYFPRINTF (yyoutput, ")"); -} - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) -#else -static void -yy_stack_print (bottom, top) - yytype_int16 *bottom; - yytype_int16 *top; +#endif /* not YYLSP_NEEDED */ #endif -{ - YYFPRINTF (stderr, "Stack now"); - for (; bottom <= top; ++bottom) - YYFPRINTF (stderr, " %d", *bottom); - YYFPRINTF (stderr, "\n"); -} -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (yydebug) \ - yy_stack_print ((Bottom), (Top)); \ -} while (YYID (0)) +/* If nonreentrant, generate the variables here */ +#ifndef YYPURE -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yy_reduce_print (YYSTYPE *yyvsp, int yyrule) -#else -static void -yy_reduce_print (yyvsp, yyrule) - YYSTYPE *yyvsp; - int yyrule; +#ifdef YYLSP_NEEDED +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ #endif -{ - int yynrhs = yyr2[yyrule]; - int yyi; - unsigned long int yylno = yyrline[yyrule]; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", - yyrule - 1, yylno); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - fprintf (stderr, " $%d = ", yyi + 1); - yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], - &(yyvsp[(yyi + 1) - (yynrhs)]) - ); - fprintf (stderr, "\n"); - } -} -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (yydebug) \ - yy_reduce_print (yyvsp, Rule); \ -} while (YYID (0)) +int yynerrs; /* number of parse errors so far */ +#endif /* not YYPURE */ -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif +/* YYINITDEPTH indicates the initial size of the parser's stacks */ -/* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -# define YYINITDEPTH 200 +#define YYINITDEPTH 200 #endif -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). +/* YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ +#if YYMAXDEPTH == 0 +#undef YYMAXDEPTH +#endif #ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 +#define YYMAXDEPTH 10000 #endif - - -#if YYERROR_VERBOSE - -# ifndef yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static YYSIZE_T -yystrlen (const char *yystr) -#else -static YYSIZE_T -yystrlen (yystr) - const char *yystr; -#endif -{ - YYSIZE_T yylen; - for (yylen = 0; yystr[yylen]; yylen++) - continue; - return yylen; -} -# endif -# endif - -# ifndef yystpcpy -# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static char * -yystpcpy (char *yydest, const char *yysrc) -#else -static char * -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -#endif +/* Define __yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (to, from, count) + char *to; + char *from; + unsigned int count; { - char *yyd = yydest; - const char *yys = yysrc; + register char *f = from; + register char *t = to; + register int i = count; - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; + while (i-- > 0) + *t++ = *f++; } -# endif -# endif - -# ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T -yytnamerr (char *yyres, const char *yystr) -{ - if (*yystr == '"') - { - YYSIZE_T yyn = 0; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes: ; - } - if (! yyres) - return yystrlen (yystr); +#else /* __cplusplus */ - return yystpcpy (yyres, yystr) - yyres; -} -# endif - -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -yysyntax_error (char *yyresult, int yystate, int yychar) +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__yy_memcpy (char *to, char *from, unsigned int count) { - int yyn = yypact[yystate]; + register char *t = to; + register char *f = from; + register int i = count; - if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else - { - int yytype = YYTRANSLATE (yychar); - YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected - + sizeof yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy (yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr (0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy (yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen (yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr (yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; - } + while (i-- > 0) + *t++ = *f++; } -#endif /* YYERROR_VERBOSE */ - - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) -#else -static void -yydestruct (yymsg, yytype, yyvaluep) - const char *yymsg; - int yytype; - YYSTYPE *yyvaluep; #endif -{ - YYUSE (yyvaluep); - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - - default: - break; - } -} +#endif +#line 217 "/usr/share/bison.simple" -/* Prevent warnings from -Wmissing-prototypes. */ +/* The user can define YYPARSE_PARAM as the name of an argument to be passed + into yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ #ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int yyparse (void *YYPARSE_PARAM); +#ifdef __cplusplus +#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM +#define YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define YYPARSE_PARAM_ARG YYPARSE_PARAM +#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not YYPARSE_PARAM */ +#define YYPARSE_PARAM_ARG +#define YYPARSE_PARAM_DECL +#endif /* not YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef YYPARSE_PARAM +int yyparse (void *); #else -int yyparse (); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus int yyparse (void); -#else -int yyparse (); #endif -#endif /* ! YYPARSE_PARAM */ - - - -/* The look-ahead symbol. */ -int yychar; - -/* The semantic value of the look-ahead symbol. */ -YYSTYPE yylval; +#endif -/* Number of syntax errors so far. */ -int yynerrs; +int +yyparse(YYPARSE_PARAM_ARG) + YYPARSE_PARAM_DECL +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1 = 0; /* lookahead token as an internal (translated) token number */ + short yyssa[YYINITDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ -/*----------. -| yyparse. | -`----------*/ +#ifdef YYLSP_NEEDED + YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ + YYLTYPE *yyls = yylsa; + YYLTYPE *yylsp; -#ifdef YYPARSE_PARAM -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (void *YYPARSE_PARAM) +#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) #else -int -yyparse (YYPARSE_PARAM) - void *YYPARSE_PARAM; +#define YYPOPSTACK (yyvsp--, yyssp--) #endif -#else /* ! YYPARSE_PARAM */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -int -yyparse (void) -#else -int -yyparse () + int yystacksize = YYINITDEPTH; + int yyfree_stacks = 0; + +#ifdef YYPURE + int yychar; + YYSTYPE yylval; + int yynerrs; +#ifdef YYLSP_NEEDED + YYLTYPE yylloc; #endif #endif -{ - - int yystate; - int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; -#if YYERROR_VERBOSE - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; -#endif - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss = yyssa; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp; - - - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) - - YYSIZE_T yystacksize = YYINITDEPTH; - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + int yylen; - /* The number of symbols on the RHS of the reduced rule. - Keep to zero when no symbol should be popped. */ - int yylen = 0; - - YYDPRINTF ((stderr, "Starting parse\n")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif yystate = 0; yyerrstatus = 0; @@ -1263,394 +563,452 @@ yyparse () so that they stay on the same level as the state stack. The wasted elements are never initialized. */ - yyssp = yyss; + yyssp = yyss - 1; yyvsp = yyvs; +#ifdef YYLSP_NEEDED + yylsp = yyls; +#endif - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. So pushing a state here evens the stacks. */ - yyssp++; +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: - yysetstate: - *yyssp = yystate; + *++yyssp = yystate; - if (yyss + yystacksize - 1 <= yyssp) + if (yyssp >= yyss + yystacksize - 1) { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + short *yyss1 = yyss; +#ifdef YYLSP_NEEDED + YYLTYPE *yyls1 = yyls; +#endif + /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; + int size = yyssp - yyss + 1; #ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; - - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow (YY_("memory exhausted"), - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - - &yystacksize); - - yyss = yyss1; - yyvs = yyvs1; - } + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if yyoverflow is a macro. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yystacksize); +#else + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yystacksize); +#endif + + yyss = yyss1; yyvs = yyvs1; +#ifdef YYLSP_NEEDED + yyls = yyls1; +#endif #else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -# else /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; + if (yystacksize >= YYMAXDEPTH) + { + yyerror("parser stack overflow"); + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); +#endif + } + return 2; + } yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) + if (yystacksize > YYMAXDEPTH) yystacksize = YYMAXDEPTH; - - { - yytype_int16 *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); - -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif +#ifndef YYSTACK_USE_ALLOCA + yyfree_stacks = 1; +#endif + yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); + __yy_memcpy ((char *)yyss, (char *)yyss1, + size * (unsigned int) sizeof (*yyssp)); + yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); + __yy_memcpy ((char *)yyvs, (char *)yyvs1, + size * (unsigned int) sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); + __yy_memcpy ((char *)yyls, (char *)yyls1, + size * (unsigned int) sizeof (*yylsp)); +#endif #endif /* no yyoverflow */ - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yystacksize); +#endif - if (yyss + yystacksize - 1 <= yyssp) + if (yyssp >= yyss + yystacksize - 1) YYABORT; } - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif goto yybackup; + yybackup: -/*-----------. -| yybackup. | -`-----------*/ -yybackup: +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* yyresume: */ - /* Do appropriate processing given the current state. Read a - look-ahead token if we need one and don't already have one. */ + /* First try to decide what to do without reference to lookahead token. */ - /* First try to decide what to do without reference to look-ahead token. */ yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) + if (yyn == YYFLAG) goto yydefault; - /* Not known => get a look-ahead token if don't already have one. */ + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ if (yychar == YYEMPTY) { - YYDPRINTF ((stderr, "Reading a token: ")); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif yychar = YYLEX; } - if (yychar <= YYEOF) + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ { - yychar = yytoken = YYEOF; - YYDPRINTF ((stderr, "Now at end of input.\n")); + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif } else { - yytoken = YYTRANSLATE (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + { + fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef YYPRINT + YYPRINT (stderr, yychar, yylval); +#endif + fprintf (stderr, ")\n"); + } +#endif } - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; + yyn = yytable[yyn]; - if (yyn <= 0) + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) { - if (yyn == 0 || yyn == YYTABLE_NINF) + if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } + else if (yyn == 0) + goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; + /* Shift the lookahead token. */ - /* Shift the look-ahead token. */ - YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif - /* Discard the shifted token unless it is eof. */ + /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; - yystate = yyn; *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif - goto yynewstate; + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + yystate = yyn; + goto yynewstate; -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ +/* Do the default action for the current state. */ yydefault: + yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; - goto yyreduce; - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ +/* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: - /* yyn is the number of a rule to reduce with. */ yylen = yyr2[yyn]; + if (yylen > 0) + yyval = yyvsp[1-yylen]; /* implement default value of the action */ - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. +#if YYDEBUG != 0 + if (yydebug) + { + int i; - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; + fprintf (stderr, "Reducing via rule %d (line %d), ", + yyn, yyrline[yyn]); + /* Print the symbols being reduced, and their result. */ + for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) + fprintf (stderr, "%s ", yytname[yyrhs[i]]); + fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); + } +#endif - YY_REDUCE_PRINT (yyn); - switch (yyn) - { - case 2: -#line 46 "levcomp.ypp" - { } - break; - - case 3: -#line 49 "levcomp.ypp" - {} - break; - - case 4: -#line 50 "levcomp.ypp" - {} - break; - - case 5: -#line 53 "levcomp.ypp" - {} - break; - - case 6: -#line 54 "levcomp.ypp" - {} - break; - - case 8: -#line 61 "levcomp.ypp" - { - lc_default_depth = lc_range; - } - break; - case 9: + switch (yyn) { + +case 1: +#line 52 "levcomp.ypp" +{ ; + break;} +case 2: +#line 55 "levcomp.ypp" +{; + break;} +case 3: +#line 56 "levcomp.ypp" +{; + break;} +case 4: +#line 59 "levcomp.ypp" +{; + break;} +case 5: +#line 60 "levcomp.ypp" +{; + break;} +case 7: #line 67 "levcomp.ypp" - { - add_parsed_map( lc_map ); - } - break; - - case 10: +{ + lc_default_depth = lc_range; + ; + break;} +case 8: #line 73 "levcomp.ypp" - { - lc_map.init(); - lc_map.depth = lc_default_depth; - lc_map.name = (yyvsp[(2) - (2)].text); - } - break; +{ + if (lc_map.orient == MAP_FLOAT + || lc_map.is_minivault()) + { + if (lc_map.map.width() > GXM - MAPGEN_BORDER * 2 + || lc_map.map.height() > GYM - MAPGEN_BORDER * 2) + { + char buf[300]; + snprintf(buf, sizeof buf, + "%s is too big: %dx%d - max %dx%d", + lc_map.is_minivault()? "Minivault" : "Float", + lc_map.map.width(), lc_map.map.height(), + GXM - MAPGEN_BORDER * 2, + GYM - MAPGEN_BORDER * 2); + yyerror(buf); + } + } + else + { + if (lc_map.map.width() > GXM + || lc_map.map.height() > GYM) + { + char buf[300]; + snprintf(buf, sizeof buf, + "Map is too big: %dx%d - max %dx%d", + lc_map.map.width(), lc_map.map.height(), + GXM, GYM); + yyerror(buf); + } + } - case 21: -#line 94 "levcomp.ypp" - {} - break; + if (lc_map.map.height() == 0) + yyerror("Must define map."); - case 23: -#line 99 "levcomp.ypp" - { + add_parsed_map( lc_map ); + ; + break;} +case 9: +#line 112 "levcomp.ypp" +{ + lc_map.init(); + lc_map.depth = lc_default_depth; + lc_map.name = yyvsp[0].text; + ; + break;} +case 20: +#line 133 "levcomp.ypp" +{; + break;} +case 22: +#line 138 "levcomp.ypp" +{ lc_map.tags += " "; - lc_map.tags += (yyvsp[(1) - (2)].text); + lc_map.tags += yyvsp[-1].text; lc_map.tags += " "; - } - break; - - case 24: -#line 106 "levcomp.ypp" - {} - break; - - case 25: -#line 108 "levcomp.ypp" - { - lc_map.random_symbols = (yyvsp[(2) - (2)].text); - } - break; - - case 26: -#line 113 "levcomp.ypp" - {} - break; - - case 27: -#line 114 "levcomp.ypp" - {} - break; - - case 30: -#line 122 "levcomp.ypp" - { - bool recognised = lc_map.mons.add_mons((yyvsp[(1) - (1)].text)); + ; + break;} +case 23: +#line 145 "levcomp.ypp" +{; + break;} +case 24: +#line 147 "levcomp.ypp" +{ + lc_map.random_symbols = yyvsp[0].text; + ; + break;} +case 25: +#line 152 "levcomp.ypp" +{; + break;} +case 26: +#line 153 "levcomp.ypp" +{; + break;} +case 29: +#line 161 "levcomp.ypp" +{ + bool recognised = lc_map.mons.add_mons(yyvsp[0].text); if (!recognised) { char buf[300]; snprintf(buf, sizeof buf, "unknown monster '%s'", - (yyvsp[(1) - (1)].text)); + yyvsp[0].text); yyerror(buf); } - } - break; - - case 31: -#line 135 "levcomp.ypp" - { - lc_map.place = (yyvsp[(2) - (2)].text); - } - break; - - case 32: -#line 140 "levcomp.ypp" - {} - break; - - case 33: -#line 142 "levcomp.ypp" - { - lc_map.depth = lc_range; - } - break; - - case 34: -#line 148 "levcomp.ypp" - { - lc_range.set((yyvsp[(1) - (3)].i), (yyvsp[(3) - (3)].i)); - } - break; - - case 35: -#line 153 "levcomp.ypp" - { - lc_range.set((yyvsp[(1) - (1)].i)); - } - break; - - case 36: -#line 159 "levcomp.ypp" - { - lc_map.chance = (yyvsp[(2) - (2)].i); - } - break; - - case 37: -#line 164 "levcomp.ypp" - {} - break; - - case 38: -#line 166 "levcomp.ypp" - { - lc_map.orient = (map_section_type) (yyvsp[(2) - (2)].i); - } - break; - - case 39: -#line 171 "levcomp.ypp" - { (yyval.i) = MAP_ENCOMPASS; } - break; - - case 40: -#line 172 "levcomp.ypp" - { (yyval.i) = MAP_NORTH; } - break; - - case 41: -#line 173 "levcomp.ypp" - { (yyval.i) = MAP_EAST; } - break; - - case 42: + ; + break;} +case 30: #line 174 "levcomp.ypp" - { (yyval.i) = MAP_SOUTH; } - break; - - case 43: -#line 175 "levcomp.ypp" - { (yyval.i) = MAP_WEST; } - break; - - case 44: -#line 176 "levcomp.ypp" - { (yyval.i) = MAP_NORTHEAST; } - break; - - case 45: -#line 177 "levcomp.ypp" - { (yyval.i) = MAP_SOUTHEAST; } - break; - - case 46: -#line 178 "levcomp.ypp" - { (yyval.i) = MAP_SOUTHWEST; } - break; - - case 47: +{ + lc_map.place = yyvsp[0].text; + ; + break;} +case 31: #line 179 "levcomp.ypp" - { (yyval.i) = MAP_NORTHWEST; } - break; - - case 48: -#line 182 "levcomp.ypp" - {} - break; - - case 50: +{; + break;} +case 32: +#line 181 "levcomp.ypp" +{ + lc_map.depth = lc_range; + ; + break;} +case 33: #line 187 "levcomp.ypp" - { - switch ((yyvsp[(1) - (2)].i)) { +{ + lc_range.set(yyvsp[-2].i, yyvsp[0].i); + ; + break;} +case 34: +#line 192 "levcomp.ypp" +{ + lc_range.set(yyvsp[0].i); + ; + break;} +case 35: +#line 198 "levcomp.ypp" +{ + lc_map.chance = yyvsp[0].i; + ; + break;} +case 36: +#line 203 "levcomp.ypp" +{; + break;} +case 37: +#line 205 "levcomp.ypp" +{ + lc_map.orient = (map_section_type) yyvsp[0].i; + ; + break;} +case 38: +#line 210 "levcomp.ypp" +{ yyval.i = MAP_ENCOMPASS; ; + break;} +case 39: +#line 211 "levcomp.ypp" +{ yyval.i = MAP_NORTH; ; + break;} +case 40: +#line 212 "levcomp.ypp" +{ yyval.i = MAP_EAST; ; + break;} +case 41: +#line 213 "levcomp.ypp" +{ yyval.i = MAP_SOUTH; ; + break;} +case 42: +#line 214 "levcomp.ypp" +{ yyval.i = MAP_WEST; ; + break;} +case 43: +#line 215 "levcomp.ypp" +{ yyval.i = MAP_NORTHEAST; ; + break;} +case 44: +#line 216 "levcomp.ypp" +{ yyval.i = MAP_SOUTHEAST; ; + break;} +case 45: +#line 217 "levcomp.ypp" +{ yyval.i = MAP_SOUTHWEST; ; + break;} +case 46: +#line 218 "levcomp.ypp" +{ yyval.i = MAP_NORTHWEST; ; + break;} +case 47: +#line 219 "levcomp.ypp" +{ yyval.i = MAP_FLOAT; ; + break;} +case 48: +#line 222 "levcomp.ypp" +{; + break;} +case 50: +#line 227 "levcomp.ypp" +{ + switch (yyvsp[-1].i) { case NO_HMIRROR: lc_map.flags &= ~MAPF_MIRROR_HORIZONTAL; break; @@ -1661,247 +1019,247 @@ yyreduce: lc_map.flags &= ~MAPF_ROTATE; break; } - } - break; - - case 51: -#line 202 "levcomp.ypp" - { (yyval.i) = NO_HMIRROR; } - break; - - case 52: -#line 203 "levcomp.ypp" - { (yyval.i) = NO_VMIRROR; } - break; - - case 53: -#line 204 "levcomp.ypp" - { (yyval.i) = NO_ROTATE; } - break; + ; + break;} +case 51: +#line 242 "levcomp.ypp" +{ yyval.i = NO_HMIRROR; ; + break;} +case 52: +#line 243 "levcomp.ypp" +{ yyval.i = NO_VMIRROR; ; + break;} +case 53: +#line 244 "levcomp.ypp" +{ yyval.i = NO_ROTATE; ; + break;} +case 57: +#line 255 "levcomp.ypp" +{ + lc_map.map.add_line(yyvsp[0].text); + ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 543 "/usr/share/bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif - case 57: -#line 215 "levcomp.ypp" +#if YYDEBUG != 0 + if (yydebug) { - lc_map.map.add_line((yyvsp[(1) - (1)].text)); - } - break; - - -/* Line 1267 of yacc.c. */ -#line 1692 "levcomp.tab.c" - default: break; + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); } - YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); - - YYPOPSTACK (yylen); - yylen = 0; - YY_STACK_PRINT (yyss, yyssp); +#endif *++yyvsp = yyval; +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ yyn = yyr1[yyn]; - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else - yystate = yydefgoto[yyn - YYNTOKENS]; + yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; +yyerrlab: /* here on detecting error */ -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ { ++yynerrs; -#if ! YYERROR_VERBOSE - yyerror (YY_("syntax error")); -#else - { - YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); - yymsg = (char *) YYSTACK_ALLOC (yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void) yysyntax_error (yymsg, yystate, yychar); - yyerror (yymsg); - } - else - { - yyerror (YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } -#endif - } - +#ifdef YYERROR_VERBOSE + yyn = yypact[yystate]; - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse look-ahead token after an - error, discard it. */ - - if (yychar <= YYEOF) + if (yyn > YYFLAG && yyn < YYLAST) { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; + int size = 0; + char *msg; + int x, count; + + count = 0; + /* Start X at -yyn if nec to avoid negative indexes in yycheck. */ + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + size += strlen(yytname[x]) + 15, count++; + msg = (char *) malloc(size + 15); + if (msg != 0) + { + strcpy(msg, "parse error"); + + if (count < 5) + { + count = 0; + for (x = (yyn < 0 ? -yyn : 0); + x < (sizeof(yytname) / sizeof(char *)); x++) + if (yycheck[x + yyn] == x) + { + strcat(msg, count == 0 ? ", expecting `" : " or `"); + strcat(msg, yytname[x]); + strcat(msg, "'"); + count++; + } + } + yyerror(msg); + free(msg); + } + else + yyerror ("parse error; also virtual memory exceeded"); } else - { - yydestruct ("Error: discarding", - yytoken, &yylval); - yychar = YYEMPTY; - } +#endif /* YYERROR_VERBOSE */ + yyerror("parse error"); } - /* Else will try to reuse look-ahead token after shifting the error - token. */ goto yyerrlab1; +yyerrlab1: /* here on error raised explicitly by an action */ + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif - /* Do not reclaim the symbols of the rule which action triggered - this YYERROR. */ - YYPOPSTACK (yylen); - yylen = 0; - YY_STACK_PRINT (yyss, yyssp); - yystate = *yyssp; - goto yyerrlab1; + yychar = YYEMPTY; + } + /* Else will try to reuse lookahead token + after shifting the error token. */ -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ + yyerrstatus = 3; /* Each real token shifted decrements this */ - for (;;) + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; - yydestruct ("Error: popping", - yystos[yystate], yyvsp); - YYPOPSTACK (1); - yystate = *yyssp; - YY_STACK_PRINT (yyss, yyssp); + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; } + else if (yyn == 0) + goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; - *++yyvsp = yylval; - +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif - /* Shift the error token. */ - YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif yystate = yyn; goto yynewstate; - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ -yyexhaustedlab: - yyerror (YY_("memory exhausted")); - yyresult = 2; - /* Fall through. */ + yyacceptlab: + /* YYACCEPT comes here. */ + if (yyfree_stacks) + { + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); #endif + } + return 0; -yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) - yydestruct ("Cleanup: discarding lookahead", - yytoken, &yylval); - /* Do not reclaim the symbols of the rule which action triggered - this YYABORT or YYACCEPT. */ - YYPOPSTACK (yylen); - YY_STACK_PRINT (yyss, yyssp); - while (yyssp != yyss) + yyabortlab: + /* YYABORT comes here. */ + if (yyfree_stacks) { - yydestruct ("Cleanup: popping", - yystos[*yyssp], yyvsp); - YYPOPSTACK (1); - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif -#if YYERROR_VERBOSE - if (yymsg != yymsgbuf) - YYSTACK_FREE (yymsg); + free (yyss); + free (yyvs); +#ifdef YYLSP_NEEDED + free (yyls); #endif - /* Make sure YYID is used. */ - return YYID (yyresult); + } + return 1; } - - -#line 220 "levcomp.ypp" - +#line 260 "levcomp.ypp" diff --git a/crawl-ref/source/prebuilt/levcomp.tab.h b/crawl-ref/source/prebuilt/levcomp.tab.h index 64857e6606..a77766566c 100644 --- a/crawl-ref/source/prebuilt/levcomp.tab.h +++ b/crawl-ref/source/prebuilt/levcomp.tab.h @@ -1,125 +1,58 @@ -/* A Bison parser, made by GNU Bison 2.3. */ - -/* Skeleton interface for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum yytokentype { - DEFAULT_DEPTH = 258, - SYMBOL = 259, - TAGS = 260, - NAME = 261, - DEPTH = 262, - ORIENT = 263, - PLACE = 264, - CHANCE = 265, - FLAGS = 266, - MONS = 267, - ENCOMPASS = 268, - NORTH = 269, - EAST = 270, - SOUTH = 271, - WEST = 272, - NORTHEAST = 273, - SOUTHEAST = 274, - SOUTHWEST = 275, - NORTHWEST = 276, - BAD_CHARACTER = 277, - NO_HMIRROR = 278, - NO_VMIRROR = 279, - NO_ROTATE = 280, - PANDEMONIC = 281, - DASH = 282, - COMMA = 283, - INTEGER = 284, - STRING = 285, - MAP_LINE = 286, - MONSTER_NAME = 287 - }; -#endif -/* Tokens. */ -#define DEFAULT_DEPTH 258 -#define SYMBOL 259 -#define TAGS 260 -#define NAME 261 -#define DEPTH 262 -#define ORIENT 263 -#define PLACE 264 -#define CHANCE 265 -#define FLAGS 266 -#define MONS 267 -#define ENCOMPASS 268 -#define NORTH 269 -#define EAST 270 -#define SOUTH 271 -#define WEST 272 -#define NORTHEAST 273 -#define SOUTHEAST 274 -#define SOUTHWEST 275 -#define NORTHWEST 276 -#define BAD_CHARACTER 277 -#define NO_HMIRROR 278 -#define NO_VMIRROR 279 -#define NO_ROTATE 280 -#define PANDEMONIC 281 -#define DASH 282 -#define COMMA 283 -#define INTEGER 284 -#define STRING 285 -#define MAP_LINE 286 -#define MONSTER_NAME 287 - - - - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 21 "levcomp.ypp" +typedef union { int i; const char *text; -} -/* Line 1529 of yacc.c. */ -#line 118 "levcomp.tab.h" - YYSTYPE; -# define yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif +} YYSTYPE; +#define BRANCHDEF 257 +#define BRANCH 258 +#define DESC 259 +#define DEFAULT 260 +#define DEFAULT_DEPTH 261 +#define SYMBOL 262 +#define TAGS 263 +#define NAME 264 +#define DEPTH 265 +#define ORIENT 266 +#define PLACE 267 +#define CHANCE 268 +#define FLAGS 269 +#define MONS 270 +#define ROOT_DEPTH 271 +#define ENTRY_MSG 272 +#define EXIT_MSG 273 +#define ROCK_COLOUR 274 +#define FLOOR_COLOUR 275 +#define ENCOMPASS 276 +#define FLOAT 277 +#define NORTH 278 +#define EAST 279 +#define SOUTH 280 +#define WEST 281 +#define NORTHEAST 282 +#define SOUTHEAST 283 +#define SOUTHWEST 284 +#define NORTHWEST 285 +#define LEVEL 286 +#define END 287 +#define PVAULT 288 +#define PMINIVAULT 289 +#define MONSTERS 290 +#define ENDMONSTERS 291 +#define CHARACTER 292 +#define NO_HMIRROR 293 +#define NO_VMIRROR 294 +#define NO_ROTATE 295 +#define PANDEMONIC 296 +#define DASH 297 +#define COMMA 298 +#define QUOTE 299 +#define OPAREN 300 +#define CPAREN 301 +#define INTEGER 302 +#define STRING 303 +#define MAP_LINE 304 +#define MONSTER_NAME 305 +#define IDENTIFIER 306 -extern YYSTYPE yylval; +extern YYSTYPE yylval; diff --git a/crawl-ref/source/randart.h b/crawl-ref/source/randart.h index df175e0a62..43cef73652 100644 --- a/crawl-ref/source/randart.h +++ b/crawl-ref/source/randart.h @@ -16,12 +16,7 @@ #include "externs.h" // used in files.cc, newgame.cc, randart.cc {dlb} -#ifdef USE_NEW_UNRANDS #define NO_UNRANDARTS 52 -#else // USE_NEW_UNRANDS -#define NO_UNRANDARTS 14 -#endif // USE_NEW_UNRANDS - #define RA_PROPERTIES 30 // Reserving the upper bits for later expansion/versioning. diff --git a/crawl-ref/source/stuff.h b/crawl-ref/source/stuff.h index 7ae7726222..07970c2c62 100644 --- a/crawl-ref/source/stuff.h +++ b/crawl-ref/source/stuff.h @@ -69,6 +69,16 @@ int yesnoquit( const char* str, bool safe = true, bool in_bounds( int x, int y ); bool map_bounds( int x, int y ); +inline bool in_bounds(const coord_def &p) +{ + return in_bounds(p.x, p.y); +} + +inline bool map_bounds(const coord_def &p) +{ + return map_bounds(p.x, p.y); +} + int grid_distance( int x, int y, int x2, int y2 ); int distance( int x, int y, int x2, int y2); bool adjacent( int x, int y, int x2, int y2 ); diff --git a/crawl-ref/source/tags.cc b/crawl-ref/source/tags.cc index 9289ebeac3..0d4b507aaa 100644 --- a/crawl-ref/source/tags.cc +++ b/crawl-ref/source/tags.cc @@ -1304,7 +1304,7 @@ static void tag_construct_level_monsters(struct tagHeader &th) marshallByte(th, m.y); marshallByte(th, m.target_x); marshallByte(th, m.target_y); - marshallByte(th, m.flags); + marshallLong(th, m.flags); for (j = 0; j < NUM_MON_ENCHANTS; j++) marshallByte(th, m.enchantment[j]); @@ -1320,6 +1320,8 @@ static void tag_construct_level_monsters(struct tagHeader &th) for (j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j) marshallShort(th, m.spells[j]); + + marshallByte(th, m.god); } } @@ -1475,12 +1477,7 @@ static void tag_read_level_monsters(struct tagHeader &th, char minorVersion) menv[i].y = unmarshallByte(th); menv[i].target_x = unmarshallByte(th); menv[i].target_y = unmarshallByte(th); - menv[i].flags = unmarshallByte(th); - - // VERSION NOTICE: for pre 4.2 files, flags was either 0 - // or 1. Now, we can transfer ENCH_CREATED_FRIENDLY over - // from the enchantments array to flags. - // Also need to take care of ENCH_FRIEND_ABJ_xx flags + menv[i].flags = unmarshallLong(th); for (j = 0; j < ecount; j++) menv[i].enchantment[j] = unmarshallByte(th); @@ -1496,7 +1493,9 @@ static void tag_read_level_monsters(struct tagHeader &th, char minorVersion) menv[i].inv[j] = unmarshallShort(th); for (j = 0; j < NUM_MONSTER_SPELL_SLOTS; ++j) - menv[i].spells[j] = unmarshallShort(th); + menv[i].spells[j] = unmarshallShort(th); + + menv[i].god = (god_type) unmarshallByte(th); // place monster if (menv[i].type != -1) diff --git a/crawl-ref/source/travel.cc b/crawl-ref/source/travel.cc index 97952b664f..ffd12b9830 100644 --- a/crawl-ref/source/travel.cc +++ b/crawl-ref/source/travel.cc @@ -317,7 +317,7 @@ void toggle_exclude(int x, int y) } else { - coord_def c = { x, y }; + const coord_def c(x, y); curr_excludes.push_back(c); } @@ -626,7 +626,7 @@ void prevent_travel_to(const std::string &feature) bool is_branch_stair(int gridx, int gridy) { - coord_def pos = { gridx, gridy }; + const coord_def pos(gridx, gridy); const level_id curr = level_id::get_current_level_id(); const level_id next = level_id::get_next_level_id(pos); @@ -1270,7 +1270,7 @@ void find_travel_pos(int youx, int youy, { if (features) { - coord_def c = { dx, dy }; + const coord_def c(dx, dy); if (is_trap(dx, dy) || is_exclude_root(dx, dy)) features->push_back(c); trap_seeds.push_back(c); @@ -1327,14 +1327,14 @@ void find_travel_pos(int youx, int youy, || is_stash(lev, dx, dy)) && (dx != start_x || dy != start_y)) { - coord_def c = { dx, dy }; + const coord_def c(dx, dy); features->push_back(c); } if (features && is_exclude_root(dx, dy) && dx != start_x && dy != start_y) { - coord_def c = { dx, dy }; + const coord_def c(dx, dy); features->push_back(c); } } @@ -1380,8 +1380,8 @@ void find_travel_pos(int youx, int youy, } // Mappings of which branches spring from which other branches, essential to -// walk backwards up the tree. Yes, this is a horrible abuse of coord_def. -static coord_def branch_backout[] = +// walk backwards up the tree. +static int branch_backout[][2] = { { BRANCH_SWAMP, BRANCH_LAIR }, { BRANCH_SLIME_PITS, BRANCH_LAIR }, @@ -1412,8 +1412,8 @@ unsigned char find_parent_branch(unsigned char br) i < sizeof(branch_backout) / sizeof(branch_backout[0]); i++) { - if (branch_backout[i].x == br) - return (unsigned char) branch_backout[i].y; + if (branch_backout[i][0] == br) + return (unsigned char) branch_backout[i][1]; } return 0; } @@ -2268,8 +2268,9 @@ static int find_transtravel_square(const level_pos &target, bool verbose) { level_id current = level_id::get_current_level_id(); - coord_def best_stair = { -1, -1 }; - coord_def cur_stair = { you.x_pos, you.y_pos }; + coord_def best_stair(-1, -1); + coord_def cur_stair(you.x_pos, you.y_pos); + level_id closest_level; int best_level_distance = -1; travel_cache.reset_distances(); @@ -2674,7 +2675,7 @@ void LevelInfo::update_stair(int x, int y, const level_pos &p, bool guess) stair_info *LevelInfo::get_stair(int x, int y) { - coord_def c = { x, y }; + const coord_def c(x, y); return get_stair(c); } @@ -2825,7 +2826,7 @@ void LevelInfo::get_stairs(std::vector<coord_def> &st) { // Convert to grid coords, because that's what we use // everywhere else. - coord_def stair = { x + 1, y + 1 }; + const coord_def stair(x + 1, y + 1); st.push_back(stair); } } @@ -3065,7 +3066,7 @@ void TravelCache::add_waypoint(int x, int y) x = you.x_pos; y = you.y_pos; } - coord_def pos = { x, y }; + const coord_def pos(x, y); const level_id &lid = level_id::get_current_level_id(); LevelInfo &li = get_level_info(lid); diff --git a/crawl-ref/source/unrand.h b/crawl-ref/source/unrand.h index 30bfa5a1be..e4dc21af7d 100644 --- a/crawl-ref/source/unrand.h +++ b/crawl-ref/source/unrand.h @@ -413,7 +413,6 @@ "" } -#ifdef USE_NEW_UNRANDS , /* 15 */ { @@ -1108,7 +1107,6 @@ "", "" } -#endif // USE_NEW_UNRANDS , /* This is a dummy */ /* 1 */ diff --git a/crawl-ref/source/util/levcomp.lpp b/crawl-ref/source/util/levcomp.lpp index 69ad33ee23..59118eee7e 100644 --- a/crawl-ref/source/util/levcomp.lpp +++ b/crawl-ref/source/util/levcomp.lpp @@ -8,13 +8,32 @@ #include "AppHdr.h" #include "levcomp.tab.h" #include <cstring> +#include <queue> static bool alloced = false; +std::queue<const char *> free_queue; + +static void flush_free_queue(int max_allowed) +{ + while (free_queue.size() > max_allowed) + { + const char *s = free_queue.front(); + free((void *) s); + free_queue.pop(); + } +} + +static void add_to_queue(const char *s) +{ + free_queue.push(s); + flush_free_queue(20); +} + static void clean() { if (yylval.text && alloced) - free( (void*) yylval.text); + add_to_queue(yylval.text); yylval.text = NULL; alloced = false; } @@ -83,7 +102,7 @@ EXIT_MSG: { BEGIN(ARGUMENT); return EXIT_MSG; } MONSTERS return MONSTERS; ENDMONSTERS return ENDMONSTERS; -<KEYWORDS>[A-Za-z_0-9\-]+ { +<KEYWORDS>[A-Za-z_0-9\-]+ { settext(); return STRING; } @@ -114,6 +133,7 @@ northeast return NORTHEAST; northwest return NORTHWEST; southeast return SOUTHEAST; southwest return SOUTHWEST; +float return FLOAT; - return DASH; , return COMMA; @@ -151,5 +171,6 @@ southwest return SOUTHWEST; int yywrap() { clean(); + flush_free_queue(0); return 1; } diff --git a/crawl-ref/source/util/levcomp.ypp b/crawl-ref/source/util/levcomp.ypp index e419bdc878..d5b0bb2c7f 100644 --- a/crawl-ref/source/util/levcomp.ypp +++ b/crawl-ref/source/util/levcomp.ypp @@ -28,7 +28,7 @@ void yyerror(const char *e) %token <i> NAME DEPTH ORIENT PLACE CHANCE FLAGS MONS %token <i> ROOT_DEPTH ENTRY_MSG EXIT_MSG %token <i> ROCK_COLOUR FLOOR_COLOUR -%token <i> ENCOMPASS +%token <i> ENCOMPASS FLOAT %token <i> NORTH EAST SOUTH WEST %token <i> NORTHEAST SOUTHEAST SOUTHWEST NORTHWEST @@ -71,6 +71,39 @@ defdepth : DEFAULT_DEPTH depth_range level : name metalines map_def metalines { + if (lc_map.orient == MAP_FLOAT + || lc_map.is_minivault()) + { + if (lc_map.map.width() > GXM - MAPGEN_BORDER * 2 + || lc_map.map.height() > GYM - MAPGEN_BORDER * 2) + { + char buf[300]; + snprintf(buf, sizeof buf, + "%s is too big: %dx%d - max %dx%d", + lc_map.is_minivault()? "Minivault" : "Float", + lc_map.map.width(), lc_map.map.height(), + GXM - MAPGEN_BORDER * 2, + GYM - MAPGEN_BORDER * 2); + yyerror(buf); + } + } + else + { + if (lc_map.map.width() > GXM + || lc_map.map.height() > GYM) + { + char buf[300]; + snprintf(buf, sizeof buf, + "Map is too big: %dx%d - max %dx%d", + lc_map.map.width(), lc_map.map.height(), + GXM, GYM); + yyerror(buf); + } + } + + if (lc_map.map.height() == 0) + yyerror("Must define map."); + add_parsed_map( lc_map ); } ; @@ -183,6 +216,7 @@ orient_name : ENCOMPASS { $$ = MAP_ENCOMPASS; } | SOUTHEAST { $$ = MAP_SOUTHEAST; } | SOUTHWEST { $$ = MAP_SOUTHWEST; } | NORTHWEST { $$ = MAP_NORTHWEST; } + | FLOAT { $$ = MAP_FLOAT; } ; flags : FLAGS flagnames {} |