diff options
23 files changed, 3018 insertions, 1758 deletions
diff --git a/crawl-ref/docs/develop/levels/syntax.txt b/crawl-ref/docs/develop/levels/syntax.txt index a1561ba84c..8fba8bed49 100644 --- a/crawl-ref/docs/develop/levels/syntax.txt +++ b/crawl-ref/docs/develop/levels/syntax.txt @@ -1016,6 +1016,105 @@ MARKER: A = feat:<feature_name> or lua:<marker_expr> SHUFFLE: Oa/|c MARKER: O = lua:<expr> +SUBVAULT: X : some_vault_tag / some_other_vault_tag:20 + + Pick a vault that matches the tag and replace matching glyphs in + the current map with the cells from that vault. + + Multiple glyphs can be specified on the left hand side and + weighted sets of tags can be used on the right hand side. + + The use of an equal sign to pick a different subvault per-glyph, + e.g. "X = some_vault_tag" is not supported at this time. Use + a ':' instead to fix the choice of vault tag among all glyphs. + + When a subvault is applied, the first step is finding the smallest + bounding box around the glyphs. For example, in the following vault + definition, the smallest bounding box around the X glyph is a 4x3 + rectangle: + + ...... + ..XXX. + ..XXX. + .XXX.. + ...... + + After the bounding box is calculated, a valid subvault that matches + the given tags and is no larger than the bounding box will be found. + If no subvault can be found, the vault will throw an error. If a + subvault is found that is smaller than the provided bounding box, + then it will be randomly placed and possibly rotated within the + bounding box. + + There is not much optimization to best fit a subvault into the + glyphs provided by the parent vault. So, take some care when using + non-rectangular subvaults. The only special case is if you provide + a subvault that is the exact same shape as what the parent vault + requests. + + Everything from the subvault cell (feature, items, monsters, + properties, markers) overwrite the glyph in the parent map. + Once replaced, this cell is immutable and cannot be changed + with something like SUBST, MARKER, or KFEAT. + + Additional glyphs that are not replaced by the subvault will be left + untouched so that the parent vault can replace them with whatever + feature it desires. These untouched glyphs can occur either because + the subvault was smaller than the bounding box or because the + subvault left the glyph blank (' '). Because of this, a SUBVAULT + command should usually be followed by a SUBST command to clean up + these remaining glyphs. + + Subvaults are allowed to include subvaults themselves, recursively. + However, there is no checking for infinite loops or cycles of + subvaults, so use this feature with some care. + + During map verification, the SUBVAULT command does not do anything. + Therefore, the compilation step for Lua vaults will not catch errors + where no maps exist for a given tag or where all maps that do exist + are too big to fit into the provided space in the parent map. (The + reasoning for not verifying the subvault command is so that you can + specify maps by tag that may be defined later in the file or even in + another file that hasn't been loaded yet.) So, test your subvaults! + + As the size of the subvault may vary depending on the parent vault, + there are some helpful Lua functions (in the dgn library) that can + be used to get more information about what the parent vault is + requesting. Here's a quick reference: + + is_subvault() + + This function returns true if the current map is being used as a + subvault and false if the current map is a normal vault. + + local width, height = subvault_size() + + This function returns the width and height of the subvault. + If not a subvault, it returns 0. + + iter.subvault_iterator(_G) + + Can be used to iterate through all the 0-indexed coordinates + in the subvault that will get copied back to the parent vault. + It will return no points if this is not a subvault. + + default_subvault_glyphs() + + This is a convenience function that replaces the current + subvault map with one that is the exact size of the bounding + box. For any valid square that the parent map will replace with + the subvault, it will place a '.' in the map. For any invalid + square that will not be replaced by the subvault, it will place + a ' ' in the map. If not a subvault, it does nothing. + + The advantage of this is that a vault author can then use nsubst + on the '.' feature to ensure that a fixed number of objects will + be created in the parent vault. + + NOTE: This function will also entirely clear the current map, so + call it first in the subvault definition. + + Handling long lines ------------------- diff --git a/crawl-ref/source/Crawl.xcodeproj/project.pbxproj b/crawl-ref/source/Crawl.xcodeproj/project.pbxproj index be85465d4f..469990806f 100644 --- a/crawl-ref/source/Crawl.xcodeproj/project.pbxproj +++ b/crawl-ref/source/Crawl.xcodeproj/project.pbxproj @@ -67,6 +67,7 @@ 7B3B07600BD13AF000F2980E /* libncurses.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 7B3B075F0BD13AF000F2980E /* libncurses.dylib */; }; 7BBC4A070B0F783C00F27D45 /* levcomp.lpp in Sources */ = {isa = PBXBuildFile; fileRef = 7B352ED10B001B9E00CABB32 /* levcomp.lpp */; }; 7BBC4A080B0F783C00F27D45 /* levcomp.ypp in Sources */ = {isa = PBXBuildFile; fileRef = 7B352ED20B001B9E00CABB32 /* levcomp.ypp */; }; + 93F94B1F10C178990077B142 /* l_subvault.cc in Sources */ = {isa = PBXBuildFile; fileRef = 93F94B1E10C178990077B142 /* l_subvault.cc */; }; B032D686106C02070002D70D /* liblua.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 7B0EFD420BD12E9200002671 /* liblua.a */; }; B032D687106C02070002D70D /* libreadline.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 7B3B07560BD13A8100F2980E /* libreadline.dylib */; }; B032D688106C02070002D70D /* libncurses.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 7B3B075F0BD13AF000F2980E /* libncurses.dylib */; }; @@ -635,6 +636,7 @@ 7B3B07560BD13A8100F2980E /* libreadline.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libreadline.dylib; path = /usr/lib/libreadline.dylib; sourceTree = "<absolute>"; }; 7B3B075F0BD13AF000F2980E /* libncurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libncurses.dylib; path = /usr/lib/libncurses.dylib; sourceTree = "<absolute>"; }; 8DD76FB20486AB0100D96B5E /* crawl */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = crawl; sourceTree = BUILT_PRODUCTS_DIR; }; + 93F94B1E10C178990077B142 /* l_subvault.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = l_subvault.cc; sourceTree = "<group>"; }; B02C574310670C63006AC96D /* libgui.cc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = libgui.cc; sourceTree = "<group>"; }; B02C574410670C63006AC96D /* libgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = libgui.h; sourceTree = "<group>"; }; B02C575F10670ED2006AC96D /* SDLMain.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDLMain.h; sourceTree = "<group>"; }; @@ -1380,6 +1382,7 @@ E5D63FF810BD494400A99626 /* l_moninf.cc */, E5D63FF910BD494400A99626 /* l_mons.cc */, E5D63FFA10BD494400A99626 /* l_option.cc */, + 93F94B1E10C178990077B142 /* l_subvault.cc */, E5D63FFB10BD494400A99626 /* l_travel.cc */, E5D63FFC10BD494400A99626 /* l_view.cc */, E5D63FFD10BD494400A99626 /* l_you.cc */, @@ -2260,6 +2263,7 @@ E5D6410E10BD494500A99626 /* l_moninf.cc in Sources */, E5D6410F10BD494500A99626 /* l_mons.cc in Sources */, E5D6411010BD494500A99626 /* l_option.cc in Sources */, + 93F94B1F10C178990077B142 /* l_subvault.cc in Sources */, E5D6411110BD494500A99626 /* l_travel.cc in Sources */, E5D6411210BD494500A99626 /* l_view.cc in Sources */, E5D6411310BD494500A99626 /* l_you.cc in Sources */, diff --git a/crawl-ref/source/MSVC/crawl.vcproj b/crawl-ref/source/MSVC/crawl.vcproj index 83ecc61d16..cc1c458ff3 100644 --- a/crawl-ref/source/MSVC/crawl.vcproj +++ b/crawl-ref/source/MSVC/crawl.vcproj @@ -1321,6 +1321,10 @@ >
</File>
<File
+ RelativePath="..\l_subvault.cc"
+ >
+ </File>
+ <File
RelativePath="..\l_view.cc"
>
</File>
diff --git a/crawl-ref/source/dat/clua/iter.lua b/crawl-ref/source/dat/clua/iter.lua index 904bd57151..f9371d81eb 100644 --- a/crawl-ref/source/dat/clua/iter.lua +++ b/crawl-ref/source/dat/clua/iter.lua @@ -283,3 +283,39 @@ function iter.stack_destroy(coord, extra) end end end + +------------------------------------------------------------------------------- +-- subvault_iterator +-- Iterates through all map locations in a subvault that will get written +-- back to a parent. +------------------------------------------------------------------------------- +function iter.subvault_iterator (e, filter) + + if e == nil then + error("subvault_iterator requires the env to be passed, e.g. _G") + end + + local top_corner = dgn.point(0, 0) + local bottom_corner + + local w,h = e.subvault_size() + if w == 0 or h == 0 then + -- Construct a valid rectangle. subvault_cell_valid will always fail. + bottom_corner = top_corner + else + bottom_corner = dgn.point(w-1, h-1) + end + + + local function check_mask (point) + if filter ~= nil then + if not filter(point) then + return false + end + end + + return e.subvault_cell_valid(point.x, point.y) + end + + return iter.rect_iterator(top_corner, bottom_corner, check_mask) +end diff --git a/crawl-ref/source/dat/levdes.vim b/crawl-ref/source/dat/levdes.vim index fe3712f9b2..d506c76982 100644 --- a/crawl-ref/source/dat/levdes.vim +++ b/crawl-ref/source/dat/levdes.vim @@ -51,7 +51,7 @@ syn region desNsubst start=/^NSUBST:\s*/ end=/$/ contains=desNsubstDec,desSubstA syn region desShuffle start=/^SHUFFLE:\s*/ end=/$/ contains=desShuffleDec,desMapFrag keepend -syn keyword desDeclarator NAME: ORIENT: DEPTH: PLACE: MONS: FLAGS: default-depth: TAGS: CHANCE: WEIGHT: ITEM: KFEAT: KMONS: KITEM: COLOUR: KMASK: KPROP: MARKER: LFLAGS: BFLAGS: LROCKCOL: LFLOORCOL: LFLOORTILE: LROCKTILE: FTILE: RTILE: +syn keyword desDeclarator NAME: ORIENT: DEPTH: PLACE: MONS: FLAGS: default-depth: TAGS: CHANCE: WEIGHT: ITEM: KFEAT: KMONS: KITEM: COLOUR: KMASK: KPROP: MARKER: LFLAGS: BFLAGS: LROCKCOL: LFLOORCOL: LFLOORTILE: LROCKTILE: FTILE: RTILE: SUBVAULT: syn keyword desOrientation encompass north south east west northeast northwest southeast southwest float syn keyword desOrientation no_hmirror no_vmirror no_rotate syn keyword desOrientation entry pan lab bazaar allow_dup dummy mini_float minotaur diff --git a/crawl-ref/source/dat/vaults.des b/crawl-ref/source/dat/vaults.des index c4fae8660c..583bbfbe76 100644 --- a/crawl-ref/source/dat/vaults.des +++ b/crawl-ref/source/dat/vaults.des @@ -7,6 +7,25 @@ # moved to mini.des, float.des and large.des. Portal vaults live in portal.des. ############################################################################### +{{ + -- Vault:8 common loot substitutions + function vault8_loot(e) + e.subst("? = | * .:40 ^:3") + e.subst("| = | *:2") + e.subst("* = * |:2") + end + + -- Vault:8 cross-vault rune subsitution + -- Turn 'O' into a rune (if it doesn't exist yet) or a good item + function vault8_rune(e) + if dgn.map_by_tag("vault8_rune") then + e.subvault("O : vault8_rune") + else + e.subvault("O : vault8_norune") + end + end +}} + ############################################################################## # Vaults entries ############################################################################## @@ -342,57 +361,31 @@ ENDMAP ############################################################################## # # This map traditionally allows controlled teleports. Even with the now -# random placement of the rune, this seems fine: two of the spots are +# random placement of the rune, this seems fine: some of the spots are # awkward to reach via teleport, and there is now always a monster on the # rune. # -NAME: vaults_vault -PLACE: Vault:8 -ORIENT: encompass -TAGS: no_rotate no_dump -# -# the rune's spot, occassionally put nasty on the rune -NSUBST: O = O / o -KMONS: O = 8 / 9 -KMONS: o = 8 / 9 -KFEAT: O = O -: local brnd = crawl.random2(13) -: if brnd == 12 then -KFEAT: o = any shop -: else -KITEM: o = any good_item -: end +# Vaults:8 extensively uses subvaults. To provide another Vault:8 quadrant +# variation, create a map tagged vault8_quadrant that is 27x24. It should +# have three blank cells on one corner (see any existing quadrant for an +# example), which will be used to orient that corner towards the middle of +# the map. Each quadrant must be capable of generating a rune, which +# should be done by placing an 'O' glyph and calling vault8_rune(_G). + +############################################################################### +# The main vault for Vault:8. # -# NW -SHUFFLE: AC/BD, EG/FH, IKN/MJL, '" -SUBST: A=., B=xx=, C=+, D=x, E=+, F=xx=, G=., H=x -SUBST: I=., M=xx=, J=x, K=+, N=+, L=xx= -SUBST: ':$, ":*, ^=^., a:x. -# -# SW -SHUFFLE: !_ -SUBST: ! = | * .:20 -SUBST: _ = 8 9 .:20 -# -# NE -NSUBST: U = 1:. / *:xxxx= -NSUBST: V = 1:. / *:xxxx= -SUBST: - = 8 9 .:20 -# -# SE (double use of Y=Y. and Z=Z. for decreasing variance) -SUBST: ? = | * .:40 ^:3 -SUBST: Y = Y ., Z = Z . -SUBST: Y = Y ., Z = Z . -SUBST: Y = 9:30 8:10 .:40 -SUBST: Z = 9:10 8:30 .:40 -# -# general loot -SUBST: | = | *:2 -SUBST: * = * |:2 -# +NAME: vaults_vault +PLACE: Vault:8 +ORIENT: encompass +TAGS: no_rotate no_dump +SUBVAULT: A : vault8_quadrant +SUBVAULT: B : vault8_quadrant +SUBVAULT: C : vault8_quadrant +SUBVAULT: D : vault8_quadrant +SUBST: ABCD = . MONS: vault guard -# {{ local detail = "is etched with murals depicting, in great and gruesome ".. "detail, exactly what will be done to anyone caught stealing from the ".. @@ -406,63 +399,60 @@ MONS: vault guard dgn.set_feature_desc_long("wall of green crystal", "This wall of green crystal " .. detail) }} -# -validate {{ return glyphs_connected('O', '{') }} MAP xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx xxxx..............................................................xxxx xxxx..............................................................xxxx -xxxx..xxxxxxxxxxxxxxxxxxxxxxxxxxx....xxxxxxxxxxxxxxxxxxxxxxxxxxx..xxxx -xxxx..x.........................x....xxxxxxxxxxxxxxxxxxxxxxxxxxx..xxxx -xxxx..x.xxxxxxxxxxx..xxxxxxxxJxIx....xxxxx.................xxxxx..xxxx -xxxx..x.x'.'.'.'.'x..x........x.x....xxx...........-.........xxx..xxxx -xxxx..x.x.'.'.'.'.x..x..^^^^..x.x....xxx...-.................xxx..xxxx -xxxx..x.x'.'.'.'.'x..x..^||^..x.x....xx.........-.......-.....xx..xxxx -xxxx..x.x.'.'.'.'.x..x..^O|^..x.x....xx.......................xx..xxxx -xxxx..x.x'.'.'.'.'x..x..^||^..x.x....xx.-....xxxxxxxxxxx....-.xx..xxxx -xxxx..x.x.'.'.'.'.x..x..^^^^..x.x....xx......x.........x......xx..xxxx -xxxx..x.x'.'.'.'.'L..K........x.x....xx....xxU.........Uxx....xx..xxxx -xxxx..x.N.'.'.'.'.xxxxxxxxxxxxx.x....xx..-.x....xxxxx....x....xx..xxxx -xxxx..xMxxxxxxxxxxx99988......A.x....xx....x.-.Vx$$$xx...x.-..xx..xxxx -xxxx..x...........G99xxxxxxxxDx.x....xx....x..xx$***$xx..x....xx..xxxx -xxxx..x.xxxxxxxxxFx99x........x.x....xx.-..x..x$$*O*$$x-.x....xx..xxxx -xxxx..x.x?????????x88x."""""".x.x....xx....x..xx$***$xx..x....xx..xxxx -xxxx..x.x?????????x..x."""""".x.x....xx....x...Vx$$$xV...x..-.xx..xxxx -xxxx..x.x?????????x..x."""""".x.x....xx..-.xxx-.xxxxx..Uxx....xx..xxxx -xxxx..x.x?????????x..x."""""".x.x....xx......x.........x......xx..xxxx -xxxx..x.x?????????x..x."""""".x.x....xx......xxxxxxxxxxx.-....xx..xxxx -xxxx..x.x?????????x..x."""""".x.x....xxx...-.................xxx..xxxx -xxxx..x.x?????????x..C........x.x....xxx........-....-.......xxx..xxxx -xxxx..x.xxxxxxxxxEx..xxxxxxxxxx.a..11....xx................xxxxx..xxxx -xxxx..x...........H..B............1111...xxxxxxxxxxxxxxxxxxxxxxx..xxxx -xxxx..xxxxxxxxxxxxxxxxxxxxxxxxa..1....1..xxxxxxxxxxxxxxxxxxxxxxx..xxxx -xxxx............................1..(}..1..........................xxxx -xxxx...........................11.[..{.11.........................xxxx -xxxx............................1..])..1..........................xxxx -xxxx.............................1....1...........................xxxx -xxxx..xxxxxxxxxxxxxxxxxxxxxxx.a...1111.axaxxaaxaxxxxxxxxxxxxxxxx..xxxx -xxxx..xx!x.x.x!x.x.x.x.x.x.x.x.a...11........................??x..xxxx -xxxx..x.x.x.x.x.x.x.x!x.x.x_x.x.a....a................Y..Z...??x..xxxx -xxxx..xx.x!x.x.x.x.x.x.x.x!x.x.x.....x..Y..Y..Y..Y..Y..Z..Y..Y.x..xxxx -xxxx..x.x.x.x.x_x.x.x_x.x.x.x.x.x....a...Y..Y..Y..Z..Y..Y..Z...x..xxxx -xxxx..xx.x.x.x.x.x.x.x.x.x.x.x_xx....x.Y..Y..Y..Y..Z..Y..Z..Y..x..xxxx -xxxx..x.x.x!x.x.x.x.x.x.x!x.x.x.x....x..Y..Y..Z..Z..Y..Y..Y..Z.x..xxxx -xxxx..xx.x_x.x.x!x.x.x.x.x.x.x.xx....a...Y..Z..Y..Y..Z..Y..Y...x..xxxx -xxxx..x.x.x.x.x_x.x.x.x.x.x.x.x.x....a.Y..Y..Z..Z..Y..Y..Y..Z..x..xxxx -xxxx..xx.x.x.x.x.x.x.x.x.x.x.x!xx....x..Z..Y..Y..Y..Z..Y..Y..Y.x..xxxx -xxxx..x_x.x!x.x.x.x.x.x!x.x_x.x.x....x...Y..Y..Z..Y..Z..Z..Y...x..xxxx -xxxx..xx.x.x.x.x.x.x.x.x.x.x.x.xx....x.Z..Z..Y..Y..Z..Y..Z..Z..x..xxxx -xxxx..x.x.x_x.x.x.x.x.x.x.x.x_x.x....x..Y..Z..Y..Z..Z..Y..Z..Z.x..xxxx -xxxx..xx.x.x.x.x.x.x_x.x.x.x.x.xx....x...Z..Z..Z..Y..Z..Z..Y...x..xxxx -xxxx..x!x.x.x.x!x.x.x.x.x.x.x.x.x....x.Y..Z..Y..Z..Z..Z..Z..Z..x..xxxx -xxxx..xx.x.x.x.x.x.x!x.x.x.x.x.xx....x..Z..Y..Z..Y.............x..xxxx -xxxx..x.x.x.x.x.x.x.x.x.x_x.x.x.x....x...Y..Z..Z..Z...ZZZZZZZZ.x..xxxx -xxxx..xx.x_x.x.x.x.x.x.x.x.x.x_xx....x....Z..Y..Z..Y..Z........x..xxxx -xxxx..x.x!x.x.x.x.x.x.x!x.x.x.x.x....x..Z..Z..Y..Z....Z..??????x..xxxx -xxxx..xx.x.x.x.x.x.x_x.x.x.x.x.xx....x...Z..Y..Z..Z...Z..??????x..xxxx -xxxx..x.x.x.x.x.x_x.x.x.x.x.x.x.x....x??..Y..Z..Z..Z..Z..??????x..xxxx -xxxx..xO.x.x_x.x.x!x.x.x.x.x!x_xx....x??.................?????Ox..xxxx -xxxx..xxxxxxxxxxxxxxxxxxxxxxxxxxx....xxxxxxxxxxxxxxxxxxxxxxxxxxx..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA....BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAAA.11.BBBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAAA.1111.BBBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx..AAAAAAAAAAAAAAAAAAAAAAAAA.1....1.BBBBBBBBBBBBBBBBBBBBBBBBB..xxxx +xxxx...........................1..(}..1...........................xxxx +xxxx..........................11.[..{.11..........................xxxx +xxxx...........................1..])..1...........................xxxx +xxxx............................1....1............................xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCC..1111..DDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCC..11..DDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx +xxxx..CCCCCCCCCCCCCCCCCCCCCCCCCCC....DDDDDDDDDDDDDDDDDDDDDDDDDDD..xxxx xxxx..............................................................xxxx xxxx..............................................................xxxx xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx @@ -470,6 +460,279 @@ ENDMAP ############################################################################## +# Vault:8 - the subvault used to place the rune. +# +# Used by the 'vault8_rune()' function in the prelude. +# +NAME: vault8_rune +TAGS: vault8_rune +KMONS: O = 8 / 9 +KFEAT: O = O +MAP +O +ENDMAP + +############################################################################## +# Vault:8 - the subvault used for potential rune locations that do not +# contain the real rune. +# +# Used by the 'vault8_rune()' function in the prelude. +# +NAME: vault8_norune +TAGS: vault8_norune allow_dup +KMONS: o = 8 / 9 +: if crawl.random2(13) == 12 then +KFEAT: o = any shop +: else +KITEM: o = any good_item +: end +MAP +o +ENDMAP + +############################################################################## +# Vault:8 - Rooms Quadrant +# +# This quadrant uses a subvault for each room. Any subvault tagged +# vault8_room_rune should be guaranteed to provide a rune. Any subvault +# tagged vault8_room should just provide loot. Note that the rooms +# are not all the same sizes. +# +NAME: vault8_rooms +TAGS: vault8_quadrant +SHUFFLE: AC/BD, EG/FH, IKN/MJL +SUBST: A=., B=xx=, C=+, D=x, E=+, F=xx=, G=., H=x +SUBST: I=., M=xx=, J=x, K=+, N=+, L=xx= +SUBST: a:x. +SHUFFLE: VXYZ +SUBVAULT: V : vault8_room_rune +SUBVAULT: X : vault8_room +SUBVAULT: Y : vault8_room +SUBVAULT: Z : vault8_room +SUBST: VXYZ = . +MAP +xxxxxxxxxxxxxxxxxxxxxxxxxxx +x.........................x +x.xxxxxxxxxxx..xxxxxxxxJxIx +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVx..xXXXXXXXXx.x +x.xVVVVVVVVVL..KXXXXXXXXx.x +x.NVVVVVVVVVxxxxxxxxxxxxx.x +xMxxxxxxxxxxx99988......A.x +x...........G99xxxxxxxxDx.x +x.xxxxxxxxxFx99xZZZZZZZZx.x +x.xYYYYYYYYYx88xZZZZZZZZx.x +x.xYYYYYYYYYx..xZZZZZZZZx.x +x.xYYYYYYYYYx..xZZZZZZZZx.x +x.xYYYYYYYYYx..xZZZZZZZZx.x +x.xYYYYYYYYYx..xZZZZZZZZx.x +x.xYYYYYYYYYx..CZZZZZZZZx.x +x.xxxxxxxxxEx..xxxxxxxxxx.a +x...........H..B.......... +xxxxxxxxxxxxxxxxxxxxxxxxa +ENDMAP + +############################################################################## +# Vault:8 - Rooms Quadrant - Traps and Loot Subvault +# +# Replace each square with traps or loot, but mostly floor. +# +NAME: vault8_room_traps_and_loot +TAGS: vault8_room +: default_subvault_glyphs() +SUBST: . = ? +: vault8_loot(_G) +MAP +ENDMAP + +############################################################################## +# Vault:8 - Rooms Quadrant - Border Subvault +# +# Fill the room with loot, but leave an empty border. +# +NAME: vault8_room_border +TAGS: vault8_room +{{ + default_subvault_glyphs() + local w, h = subvault_size() + + local i + for i in iter.subvault_iterator(_G) do + if i.x == 0 or i.x == w-1 or i.y == 0 or i.y == h-1 then + -- border + mapgrd[i.x+1][i.y+1] = '.' + else + -- inside + mapgrd[i.x+1][i.y+1] = '*' + end + end +}} +: vault8_loot(_G) +MAP +ENDMAP + +############################################################################## +# Vault:8 - Rooms Quadrant - Diamond Subvault +# +# Fill the room with money in a diamond pattern. +# +NAME: vault8_room_diamond +TAGS: vault8_room +{{ + default_subvault_glyphs() + local w, h = subvault_size() + + local i + for i in iter.subvault_iterator(_G) do + if (i.x + i.y) % 2 == 0 then + mapgrd[i.x+1][i.y+1] = '$' + else + mapgrd[i.x+1][i.y+1] = '.' + end + end +}} +: vault8_loot(_G) +MAP +ENDMAP + +############################################################################## +# Vault:8 - Rooms Quadrant - Rune Subvault +# +# The room in the rooms quadrant that actually contains the rune. +# +NAME: vault8_room_rune +TAGS: vault8_room_rune +SUBST: ^ = ^. +: vault8_loot(_G) +: vault8_rune(_G) +MAP +...... +.^^^^. +.^||^. +.^O|^. +.^||^. +.^^^^. +...... +ENDMAP + + +############################################################################## +# Vault:8 - Cross Quadrant +# +NAME: vault8_cross +TAGS: vault8_quadrant +NSUBST: U = 1:. / *:xxxx= +NSUBST: V = 1:. / *:xxxx= +SUBST: - = 8 9 .:20 +: vault8_loot(_G) +: vault8_rune(_G) +MAP +xxxxxxxxxxxxxxxxxxxxxxxxxxx +xxxxxxxxxxxxxxxxxxxxxxxxxxx +xxxxx.................xxxxx +xxx.......-.....-.......xxx +xxx...-.............-...xxx +xx.......................xx +xx.-....xxxxxxxxxxx....-.xx +xx......x.........x......xx +xx....xxU.........Uxx....xx +xx..-.x....xxxxx....x....xx +xx....x.-.Vx$$$xx...x.-..xx +xx....x..xx$***$xx..x....xx +xx.-..x..x$$*O*$$x-.x....xx +xx....x..xx$***$xx..x....xx +xx....x...Vx$$$xV...x..-.xx +xx..-.xxx-.xxxxx..Uxx....xx +xx......x.........x......xx +xx......xxxxxxxxxxx.-....xx +xxx...-.................xxx +xxx........-....-.......xxx +....xx................xxxxx + ...xxxxxxxxxxxxxxxxxxxxxxx + ..xxxxxxxxxxxxxxxxxxxxxxx +ENDMAP + +############################################################################## +# Vault:8 - Diamond Quadrant +# +NAME: vault8_diamond +TAGS: vault8_quadrant +SHUFFLE: !_ +SUBST: ! = | * .:20 +SUBST: _ = 8 9 .:20 +SUBST: a:x. +: vault8_loot(_G) +: vault8_rune(_G) +MAP +xxxxxxxxxxxxxxxxxxxxxxx.a +xx!x.x.x!x.x.x.x.x.x.x.x.a +x.x.x.x.x.x.x.x!x.x.x_x.x.a +xx.x!x.x.x.x.x.x.x.x!x.x.x. +x.x.x.x.x_x.x.x_x.x.x.x.x.x +xx.x.x.x.x.x.x.x.x.x.x.x_xx +x.x.x!x.x.x.x.x.x.x!x.x.x.x +xx.x_x.x.x!x.x.x.x.x.x.x.xx +x.x.x.x.x_x.x.x.x.x.x.x.x.x +xx.x.x.x.x.x.x.x.x.x.x.x!xx +x_x.x!x.x.x.x.x.x!x.x_x.x.x +xx.x.x.x.x.x.x.x.x.x.x.x.xx +x.x.x_x.x.x.x.x.x.x.x.x_x.x +xx.x.x.x.x.x.x_x.x.x.x.x.xx +x!x.x.x.x!x.x.x.x.x.x.x.x.x +xx.x.x.x.x.x.x!x.x.x.x.x.xx +x.x.x.x.x.x.x.x.x.x_x.x.x.x +xx.x_x.x.x.x.x.x.x.x.x.x_xx +x.x!x.x.x.x.x.x.x!x.x.x.x.x +xx.x.x.x.x.x.x_x.x.x.x.x.xx +x.x.x.x.x.x_x.x.x.x.x.x.x.x +xO.x.x_x.x.x!x.x.x.x.x!x_xx +xxxxxxxxxxxxxxxxxxxxxxxxxxx +ENDMAP + +############################################################################## +# Vault:8 - Stripes Quadrant +# +NAME: vault8_stripes +TAGS: vault8_quadrant +# double use of Y=Y. and Z=Z. for decreasing variance +SUBST: Y = Y ., Z = Z . +SUBST: Y = Y ., Z = Z . +SUBST: Y = 9:30 8:10 .:40 +SUBST: Z = 9:10 8:30 .:40 +SUBST: a:x. +: vault8_loot(_G) +: vault8_rune(_G) +MAP + axaxxaaxaxxxxxxxxxxxxxxxx + .......................??x +a................Y..Z...??x +x..Y..Y..Y..Y..Y..Z..Y..Y.x +a...Y..Y..Y..Z..Y..Y..Z...x +x.Y..Y..Y..Y..Z..Y..Z..Y..x +x..Y..Y..Z..Z..Y..Y..Y..Z.x +a...Y..Z..Y..Y..Z..Y..Y...x +a.Y..Y..Z..Z..Y..Y..Y..Z..x +x..Z..Y..Y..Y..Z..Y..Y..Y.x +x...Y..Y..Z..Y..Z..Z..Y...x +x.Z..Z..Y..Y..Z..Y..Z..Z..x +x..Y..Z..Y..Z..Z..Y..Z..Z.x +x...Z..Z..Z..Y..Z..Z..Y...x +x.Y..Z..Y..Z..Z..Z..Z..Z..x +x..Z..Y..Z..Y.............x +x...Y..Z..Z..Z...ZZZZZZZZ.x +x....Z..Y..Z..Y..Z........x +x..Z..Z..Y..Z....Z..??????x +x...Z..Y..Z..Z...Z..??????x +x??..Y..Z..Z..Z..Z..??????x +x??.................?????Ox +xxxxxxxxxxxxxxxxxxxxxxxxxxx +ENDMAP + +############################################################################## # The Hall of Blades ############################################################################## diff --git a/crawl-ref/source/dlua.cc b/crawl-ref/source/dlua.cc index 12e3da2860..dec579a9a1 100644 --- a/crawl-ref/source/dlua.cc +++ b/crawl-ref/source/dlua.cc @@ -281,6 +281,7 @@ void init_dungeon_lua() luaL_openlib(dlua, "dgn", dgn_item_dlib, 0); luaL_openlib(dlua, "dgn", dgn_level_dlib, 0); luaL_openlib(dlua, "dgn", dgn_mons_dlib, 0); + luaL_openlib(dlua, "dgn", dgn_subvault_dlib, 0); luaL_openlib(dlua, "dgn", dgn_tile_dlib, 0); luaL_openlib(dlua, "feat", feat_dlib, 0); luaL_openlib(dlua, "debug", debug_dlib, 0); diff --git a/crawl-ref/source/dungeon.cc b/crawl-ref/source/dungeon.cc index b3ade88bf7..9baca8cfa2 100644 --- a/crawl-ref/source/dungeon.cc +++ b/crawl-ref/source/dungeon.cc @@ -213,10 +213,13 @@ static bool _build_vaults(int level_number, bool check_collisions = false, bool make_no_exits = false, const coord_def &where = coord_def(-1, -1)); -static void _vault_grid( vault_placement &, - int vgrid, - const coord_def& where, - bool recursive = false); +static void _vault_grid(vault_placement &, + int vgrid, + const coord_def& where, + keyed_mapspec *mapsp); +static void _vault_grid(vault_placement &, + int vgrid, + const coord_def& where); static const map_def *_dgn_random_map_for_place(bool minivault); static void _dgn_load_colour_grid(); @@ -522,7 +525,7 @@ void dgn_set_grid_colour_at(const coord_def &c, int colour) } } -static void _dgn_register_vault(const map_def &map) +void dgn_register_vault(const map_def &map) { if (!map.has_tag("allow_dup")) you.uniq_map_names.insert(map.name); @@ -817,7 +820,7 @@ static void _mask_vault(const vault_placement &place, unsigned mask) void dgn_register_place(const vault_placement &place, bool register_vault) { if (register_vault) - _dgn_register_vault(place.map); + dgn_register_vault(place.map); if (!place.map.has_tag("layout")) _mask_vault(place, MMT_VAULT | MMT_NO_DOOR); @@ -842,8 +845,8 @@ void dgn_register_place(const vault_placement &place, bool register_vault) for (int x = place.pos.x + place.size.x - 1; x >= place.pos.x; --x) if (place.map.in_map(coord_def(x - place.pos.x, y - place.pos.y))) { - int key = place.map.map.glyph(x - place.pos.x, y - place.pos.y); - const keyed_mapspec* spec = place.map.mapspec_for_key(key); + coord_def c(x - place.pos.x, y - place.pos.y); + const keyed_mapspec* spec = place.map.mapspec_at(c); if (spec != NULL) { @@ -4995,10 +4998,10 @@ dungeon_feature_type map_feature_at(map_def *map, const coord_def &c, int rawfea if (rawfeat == ' ') return (NUM_FEATURES); - keyed_mapspec *mapsp = map? map->mapspec_for_key(rawfeat) : NULL; + keyed_mapspec *mapsp = map? map->mapspec_at(c) : NULL; if (mapsp) { - const feature_spec f = mapsp->get_feat(); + feature_spec f = mapsp->get_feat(); if (f.trap >= 0) { // f.feat == 1 means trap is generated known. @@ -5054,52 +5057,56 @@ dungeon_feature_type map_feature_at(map_def *map, const coord_def &c, int rawfea : DNGN_FLOOR); // includes everything else } -static void _vault_grid( vault_placement &place, - int vgrid, - const coord_def& where, - bool recursive ) +static void _vault_grid(vault_placement &place, + int vgrid, + const coord_def& where, + keyed_mapspec *mapsp) { - keyed_mapspec *mapsp = (recursive ? NULL - : place.map.mapspec_for_key(vgrid)); - if (mapsp) + if (!mapsp) { - const feature_spec f = mapsp->get_feat(); - if (f.trap >= 0) - { - const trap_type trap = - (f.trap == TRAP_INDEPTH) - ? random_trap_for_place(place.level_number) - : static_cast<trap_type>(f.trap); + _vault_grid(place, vgrid, where); + return; + } - place_specific_trap(where, trap); + const feature_spec f = mapsp->get_feat(); + if (f.trap >= 0) + { + const trap_type trap = + (f.trap == TRAP_INDEPTH) + ? random_trap_for_place(place.level_number) + : static_cast<trap_type>(f.trap); - // f.feat == 1 means trap is generated known. - if (f.feat == 1) - grd(where) = trap_category(trap); - } - else if (f.feat >= 0) - { - grd(where) = static_cast<dungeon_feature_type>( f.feat ); - vgrid = -1; - } - else if (f.glyph >= 0) - { - _vault_grid( place, f.glyph, where, true ); - } - else if (f.shop >= 0) - place_spec_shop(place.level_number, where, f.shop); - else - grd(where) = DNGN_FLOOR; + place_specific_trap(where, trap); - mons_list &mons = mapsp->get_monsters(); - _dgn_place_one_monster(place, mons, place.level_number, where); + // f.feat == 1 means trap is generated known. + if (f.feat == 1) + grd(where) = trap_category(trap); + } + else if (f.feat >= 0) + { + grd(where) = static_cast<dungeon_feature_type>(f.feat); + vgrid = -1; + } + else if (f.glyph >= 0) + { + _vault_grid(place, f.glyph, where); + } + else if (f.shop >= 0) + place_spec_shop(place.level_number, where, f.shop); + else + grd(where) = DNGN_FLOOR; - item_list &items = mapsp->get_items(); - dgn_place_multiple_items(items, where, place.level_number); + mons_list &mons = mapsp->get_monsters(); + _dgn_place_one_monster(place, mons, place.level_number, where); - return; - } + item_list &items = mapsp->get_items(); + dgn_place_multiple_items(items, where, place.level_number); +} +static void _vault_grid(vault_placement &place, + int vgrid, + const coord_def& where) +{ // First, set base tile for grids {dlb}: grd(where) = ((vgrid == -1) ? grd(where) : (vgrid == 'x') ? DNGN_ROCK_WALL : @@ -5243,11 +5250,14 @@ static void _vault_grid( vault_placement &place, } // defghijk - items - if (vgrid >= 'd' && vgrid <= 'k') - _dgn_place_item_explicit(vgrid - 'd', where, place, place.level_number); + if (map_def::valid_item_array_glyph(vgrid)) + { + int slot = map_def::item_array_glyph_to_slot(vgrid); + _dgn_place_item_explicit(slot, where, place, place.level_number); + } // Finally, handle grids that place monsters {dlb}: - if (vgrid >= '0' && vgrid <= '9') + if (map_def::valid_monster_glyph(vgrid)) { int monster_level; mons_spec monster_type_thing(RANDOM_MONSTER); @@ -5263,7 +5273,8 @@ static void _vault_grid( vault_placement &place, if (vgrid != '8' && vgrid != '9' && vgrid != '0') { - monster_type_thing = place.map.mons.get_monster(vgrid - '1'); + int slot = map_def::monster_array_glyph_to_slot(vgrid); + monster_type_thing = place.map.mons.get_monster(slot); monster_type mt = static_cast<monster_type>(monster_type_thing.mid); // Is a map for a specific place trying to place a unique which // somehow already got created? @@ -5282,7 +5293,7 @@ static void _vault_grid( vault_placement &place, _dgn_place_monster(place, monster_type_thing, monster_level, where); } -} // end vault_grid() +} // Currently only used for Slime: branch end // where it will turn the stone walls into clear rock walls @@ -8526,7 +8537,10 @@ void vault_placement::apply_grid() continue; const dungeon_feature_type oldgrid = grd(*ri); - _vault_grid( *this, feat, *ri ); + + keyed_mapspec *mapsp = map.mapspec_at(dp); + _vault_grid(*this, feat, *ri, mapsp); + if (!Generating_Level) { // Have to link items each square at a time, or diff --git a/crawl-ref/source/dungeon.h b/crawl-ref/source/dungeon.h index e7dbfd4ebe..c2f5e7456f 100644 --- a/crawl-ref/source/dungeon.h +++ b/crawl-ref/source/dungeon.h @@ -386,6 +386,7 @@ void dgn_reset_level(); bool dgn_square_is_passable(const coord_def &c); void dgn_register_place(const vault_placement &place, bool register_vault); +void dgn_register_vault(const map_def &map); struct spec_room { diff --git a/crawl-ref/source/l_dgn.cc b/crawl-ref/source/l_dgn.cc index 81a4939a25..ca0ca1db9b 100644 --- a/crawl-ref/source/l_dgn.cc +++ b/crawl-ref/source/l_dgn.cc @@ -524,7 +524,7 @@ static int dgn_marker(lua_State *ls) static int dgn_kfeat(lua_State *ls) { MAP(ls, 1, map); - std::string err = map->add_key_feat(luaL_checkstring(ls, 2)); + std::string err = map->map.add_key_feat(luaL_checkstring(ls, 2)); if (!err.empty()) luaL_error(ls, err.c_str()); return (0); @@ -533,7 +533,7 @@ static int dgn_kfeat(lua_State *ls) static int dgn_kmons(lua_State *ls) { MAP(ls, 1, map); - std::string err = map->add_key_mons(luaL_checkstring(ls, 2)); + std::string err = map->map.add_key_mons(luaL_checkstring(ls, 2)); if (!err.empty()) luaL_error(ls, err.c_str()); return (0); @@ -542,7 +542,7 @@ static int dgn_kmons(lua_State *ls) static int dgn_kitem(lua_State *ls) { MAP(ls, 1, map); - std::string err = map->add_key_item(luaL_checkstring(ls, 2)); + std::string err = map->map.add_key_item(luaL_checkstring(ls, 2)); if (!err.empty()) luaL_error(ls, err.c_str()); return (0); @@ -551,7 +551,7 @@ static int dgn_kitem(lua_State *ls) static int dgn_kmask(lua_State *ls) { MAP(ls, 1, map); - std::string err = map->add_key_mask(luaL_checkstring(ls, 2)); + std::string err = map->map.add_key_mask(luaL_checkstring(ls, 2)); if (!err.empty()) luaL_error(ls, err.c_str()); return (0); @@ -570,6 +570,27 @@ static int dgn_map_size(lua_State *ls) return (2); } +static int dgn_subvault(lua_State *ls) +{ + MAP(ls, 1, map); + if (lua_gettop(ls) == 1) + luaL_error(ls, "Expected args, got none."); + + for (int i = 2, size = lua_gettop(ls); i <= size; ++i) + { + if (lua_isnil(ls, i)) + luaL_error(ls, "Unexpected nil."); + else + { + std::string err = map->subvault_from_tagstring(luaL_checkstring(ls, i)); + if (!err.empty()) + luaL_error(ls, err.c_str()); + } + } + + return (0); +} + static int dgn_name(lua_State *ls) { MAP(ls, 1, map); @@ -1566,6 +1587,13 @@ LUAFN(dgn_get_special_room_info) return (5); } +LUAFN(dgn_is_validating) +{ + MAP(ls, 1, map); + lua_pushboolean(ls, map->is_validating()); + return (1); +} + LUAFN(_dgn_resolve_map) { if (lua_isnil(ls, 1)) @@ -1694,6 +1722,7 @@ const struct luaL_reg dgn_dlib[] = { "kprop", dgn_kprop }, { "kmask", dgn_kmask }, { "mapsize", dgn_map_size }, +{ "subvault", dgn_subvault }, { "colour_at", dgn_colour_at }, @@ -1747,6 +1776,7 @@ const struct luaL_reg dgn_dlib[] = { "marker_at_pos", _dgn_marker_at_pos }, { "get_special_room_info", dgn_get_special_room_info }, +{ "is_validating", dgn_is_validating }, { "fill_grd_area", dgn_fill_grd_area }, diff --git a/crawl-ref/source/l_libs.h b/crawl-ref/source/l_libs.h index d487ea0bb8..0d7484fe75 100644 --- a/crawl-ref/source/l_libs.h +++ b/crawl-ref/source/l_libs.h @@ -48,6 +48,7 @@ extern const struct luaL_reg dgn_grid_dlib[]; extern const struct luaL_reg dgn_item_dlib[]; extern const struct luaL_reg dgn_level_dlib[]; extern const struct luaL_reg dgn_mons_dlib[]; +extern const struct luaL_reg dgn_subvault_dlib[]; extern const struct luaL_reg dgn_tile_dlib[]; extern const struct luaL_reg feat_dlib[]; extern const struct luaL_reg los_dlib[]; diff --git a/crawl-ref/source/l_subvault.cc b/crawl-ref/source/l_subvault.cc new file mode 100644 index 0000000000..f15963b222 --- /dev/null +++ b/crawl-ref/source/l_subvault.cc @@ -0,0 +1,57 @@ +/* + * File: l_subvault.cc + * Summary: Subvault routines (library "dgn"). + */ + +#include "AppHdr.h" + +#include "coord.h" +#include "cluautil.h" +#include "l_libs.h" +#include "mapdef.h" + +static int dgn_is_subvault(lua_State *ls) +{ + MAP(ls, 1, map); + + lua_pushboolean(ls, map->is_subvault()); + return (1); +} + +static int dgn_default_subvault_glyphs(lua_State *ls) +{ + MAP(ls, 1, map); + + map->apply_subvault_mask(); + return (0); +} + +static int dgn_subvault_cell_valid(lua_State *ls) +{ + MAP(ls, 1, map); + coord_def c; + c.x = luaL_checkint(ls, 2); + c.y = luaL_checkint(ls, 3); + + lua_pushboolean(ls, map->subvault_cell_valid(c)); + return (1); +} + +static int dgn_subvault_size(lua_State *ls) +{ + MAP(ls, 1, map); + + lua_pushnumber(ls, map->subvault_width()); + lua_pushnumber(ls, map->subvault_height()); + return (2); +} + +const struct luaL_reg dgn_subvault_dlib[] = +{ +{ "is_subvault", dgn_is_subvault }, +{ "default_subvault_glyphs", dgn_default_subvault_glyphs }, +{ "subvault_cell_valid", dgn_subvault_cell_valid }, +{ "subvault_size", dgn_subvault_size }, + +{ NULL, NULL } +}; diff --git a/crawl-ref/source/makefile.obj b/crawl-ref/source/makefile.obj index c888263332..fd38cf9783 100644 --- a/crawl-ref/source/makefile.obj +++ b/crawl-ref/source/makefile.obj @@ -79,6 +79,7 @@ l_mapmrk.o \ l_moninf.o \ l_mons.o \ l_option.o \ +l_subvault.o \ l_travel.o \ l_view.o \ l_you.o \ diff --git a/crawl-ref/source/mapdef.cc b/crawl-ref/source/mapdef.cc index 88d1f9381e..5c110ac4f9 100644 --- a/crawl-ref/source/mapdef.cc +++ b/crawl-ref/source/mapdef.cc @@ -597,7 +597,7 @@ std::string map_lines::parse_glyph_replacements(std::string s, } template<class T> -std::string map_lines::parse_weighted_str(const std::string &spec, T &list) +std::string parse_weighted_str(const std::string &spec, T &list) { std::vector<std::string> speclist = split_string("/", spec); for (int i = 0, vsize = speclist.size(); i < vsize; ++i) @@ -702,6 +702,12 @@ std::string map_lines::add_fproperty(const std::string &sub) return (""); } +bool map_string_list::parse(const std::string &fp, int weight) +{ + push_back(map_weighted_string(fp, weight)); + return (!fp.empty()); +} + std::string map_lines::add_subst(const std::string &sub) { std::string s = trimmed_string(sub); @@ -918,9 +924,13 @@ void map_lines::clear() { clear_markers(); lines.clear(); + keyspecs.clear(); overlay.reset(NULL); map_width = 0; solid_checked = false; + + // First non-legal character. + next_keyspec_idx = 256; } void map_lines::subst(std::string &s, subst_spec &spec) @@ -969,6 +979,207 @@ void map_lines::overlay_fprops(fprop_spec &spec) } } +void map_lines::fill_mask_matrix(const std::string &glyphs, + const coord_def &tl, + const coord_def &br, + Matrix<bool> &flags) +{ + ASSERT(tl.x >= 0); + ASSERT(tl.y >= 0); + ASSERT(br.x < width()); + ASSERT(br.y < height()); + ASSERT(tl.x <= br.x); + ASSERT(tl.y <= br.y); + + for (int y = tl.y; y <= br.y; ++y) + for (int x = tl.x; x <= br.x; ++x) + { + int ox = x - tl.x; + int oy = y - tl.y; + flags(ox, oy) = (strchr(glyphs.c_str(), (*this)(x, y)) != NULL); + } +} + +void map_lines::merge_subvault(const coord_def &mtl, const coord_def &mbr, + const Matrix<bool> &mask, const map_def &vmap) +{ + const map_lines &vlines = vmap.map; + + // If vault is bigger than the mask region (mtl, mbr), then it gets + // randomly centered. (vtl, vbr) stores the vault's region. + coord_def vtl = mtl; + coord_def vbr = mbr; + + int width_diff = (mbr.x - mtl.x + 1) - vlines.width(); + int height_diff = (mbr.y - mtl.y + 1) - vlines.height(); + + // Adjust vault coords with a random offset. + int ox = random2(width_diff + 1); + int oy = random2(height_diff + 1); + vtl.x += ox; + vtl.y += oy; + vbr.x -= (width_diff - ox); + vbr.y -= (height_diff - oy); + + if (!overlay.get()) + overlay.reset(new overlay_matrix(width(), height())); + + // Clear any markers in the vault's grid + for (size_t i = 0; i < markers.size(); ++i) + { + map_marker *mm = markers[i]; + if (mm->pos.x >= vtl.x && mm->pos.x <= vbr.x + && mm->pos.y >= vtl.y && mm->pos.y <= vbr.y) + { + // Erase this marker. + markers[i] = markers[markers.size() - 1]; + markers.resize(markers.size() - 1); + i--; + } + } + + // Copy markers and update locations. + for (size_t i = 0; i < vlines.markers.size(); ++i) + { + map_marker *mm = vlines.markers[i]; + coord_def mapc = mm->pos + vtl; + coord_def maskc = mapc - mtl; + + if (!mask(maskc.x, maskc.y)) + continue; + + map_marker *clone = mm->clone(); + clone->pos = mapc; + add_marker(clone); + } + + // Cache keyspecs we've already pushed into the extended keyspec space. + // If !ksmap[key], then we haven't seen the 'key' glyph before. + keyspec_map ksmap(0); + + for (int y = mtl.y; y <= mbr.y; ++y) + for (int x = mtl.x; x <= mbr.x; ++x) + { + int mx = x - mtl.x; + int my = y - mtl.y; + if (!mask(mx, my)) + continue; + + // Outside subvault? + if (x < vtl.x || x > vbr.x || y < vtl.y || y > vbr.y) + continue; + + int vx = x - vtl.x; + int vy = y - vtl.y; + coord_def vc(vx, vy); + + char c = vlines(vc); + if (c == ' ') + continue; + + // Merge keyspecs. + // Push vault keyspecs into extended keyspecs. + // Push MONS/ITEM into KMONS/KITEM keyspecs. + // Generate KFEAT keyspecs for any normal glyphs. + int idx; + if (ksmap[c]) + { + // Already generated this keyed_pmapspec. + idx = ksmap[c]; + } + else + { + idx = next_keyspec_idx++; + ASSERT(idx > 0); + + if (c != SUBVAULT_GLYPH) + ksmap[c] = idx; + + const keyed_mapspec *kspec = vlines.mapspec_at(vc); + + // If c is a SUBVAULT_GLYPH, it came from a sub-subvault. + // Sub-subvaults should always have mapspecs at this point. + ASSERT(c != SUBVAULT_GLYPH || kspec); + + if (kspec) + { + // Copy vault keyspec into the extended keyspecs. + keyspecs[idx] = *kspec; + keyspecs[idx].key_glyph = SUBVAULT_GLYPH; + } + else if (map_def::valid_monster_array_glyph(c)) + { + // Translate monster array into keyed_mapspec + keyed_mapspec &km = keyspecs[idx]; + km.key_glyph = SUBVAULT_GLYPH; + + km.feat.feats.clear(); + feature_spec spec(-1); + spec.glyph = '.'; + km.feat.feats.insert(km.feat.feats.begin(), spec); + + int slot = map_def::monster_array_glyph_to_slot(c); + km.mons.set_from_slot(vmap.mons, slot); + } + else if (map_def::valid_item_array_glyph(c)) + { + // Translate item array into keyed_mapspec + keyed_mapspec &km = keyspecs[idx]; + km.key_glyph = SUBVAULT_GLYPH; + + km.feat.feats.clear(); + feature_spec spec(-1); + spec.glyph = '.'; + km.feat.feats.insert(km.feat.feats.begin(), spec); + + int slot = map_def::item_array_glyph_to_slot(c); + km.item.set_from_slot(vmap.items, slot); + } + else + { + // Normal glyph. Turn into a feature keyspec. + // This is valid for non-array items and monsters + // as well, e.g. '$' and '8'. + keyed_mapspec &km = keyspecs[idx]; + km.key_glyph = SUBVAULT_GLYPH; + km.feat.feats.clear(); + + feature_spec spec(-1); + spec.glyph = c; + km.feat.feats.insert(km.feat.feats.begin(), spec); + } + } + + // Finally, handle merging the cell itself. + + // Glyph becomes SUBVAULT_GLYPH. (The old glyph gets merged into a + // keyspec, above). This is so that the glyphs that are included + // from a subvault are immutable by the parent vault. Otherwise, + // latent transformations (like KMONS or KITEM) from the parent + // vault might confusingly modify a glyph from the subvault. + // + // NOTE: It'd be possible to allow subvaults to be modified by the + // parent vault, but KMONS/KITEM/KFEAT/MONS/ITEM would have to + // apply immediately instead of latently. They would also then + // need to be stored per-coord, rather than per-glyph. + (*this)(x, y) = SUBVAULT_GLYPH; + + // Merge overlays + if (vlines.overlay.get()) + { + (*overlay)(x, y) = (*vlines.overlay)(vx, vy); + } + else + { + // Erase any existing overlay, as the vault's doesn't exist. + (*overlay)(x, y) = overlay_def(); + } + + // Set keyspec index for this subvault. + (*overlay)(x, y).keyspec_idx = idx; + } +} + #ifdef USE_TILE void map_lines::overlay_tiles(tile_spec &spec) { @@ -1221,6 +1432,112 @@ void map_lines::hmirror() solid_checked = false; } +keyed_mapspec *map_lines::mapspec_for_key(int key) +{ + keyed_specs::iterator i = keyspecs.find(key); + return i != keyspecs.end()? &i->second : NULL; +} + +const keyed_mapspec *map_lines::mapspec_for_key(int key) const +{ + keyed_specs::const_iterator i = keyspecs.find(key); + return i != keyspecs.end()? &i->second : NULL; +} + +keyed_mapspec *map_lines::mapspec_at(const coord_def &c) +{ + int key = (*this)(c); + + if (key == SUBVAULT_GLYPH) + { + // Any subvault should create the overlay. + ASSERT(overlay.get()); + if (!overlay.get()) + return NULL; + + key = (*overlay)(c.x, c.y).keyspec_idx; + ASSERT(key); + if (!key) + return NULL; + } + + return (mapspec_for_key(key)); +} + +const keyed_mapspec *map_lines::mapspec_at(const coord_def &c) const +{ + int key = (*this)(c); + + if (key == SUBVAULT_GLYPH) + { + // Any subvault should create the overlay and set the keyspec idx. + ASSERT(overlay.get()); + if (!overlay.get()) + return NULL; + + key = (*overlay)(c.x, c.y).keyspec_idx; + ASSERT(key); + if (!key) + return NULL; + } + + return (mapspec_for_key(key)); +} + +std::string map_lines::add_key_field( + const std::string &s, + std::string (keyed_mapspec::*set_field)(const std::string &s, bool fixed), + void (keyed_mapspec::*copy_field)(const keyed_mapspec &spec)) +{ + int separator = 0; + std::string key, arg; + + std::string err = mapdef_split_key_item(s, &key, &separator, &arg, -1); + if (!err.empty()) + return (err); + + keyed_mapspec &kmbase = keyspecs[key[0]]; + kmbase.key_glyph = key[0]; + err = ((kmbase.*set_field)(arg, separator == ':')); + if (!err.empty()) + return (err); + + size_t len = key.length(); + for (size_t i = 1; i < len; i++) + { + keyed_mapspec &km = keyspecs[key[i]]; + km.key_glyph = key[i]; + ((km.*copy_field)(kmbase)); + } + + return (err); +} + +std::string map_lines::add_key_item(const std::string &s) +{ + return add_key_field(s, &keyed_mapspec::set_item, + &keyed_mapspec::copy_item); +} + +std::string map_lines::add_key_feat(const std::string &s) +{ + return add_key_field(s, &keyed_mapspec::set_feat, + &keyed_mapspec::copy_feat); +} + +std::string map_lines::add_key_mons(const std::string &s) +{ + return add_key_field(s, &keyed_mapspec::set_mons, + &keyed_mapspec::copy_mons); +} + +std::string map_lines::add_key_mask(const std::string &s) +{ + return add_key_field(s, &keyed_mapspec::set_mask, + &keyed_mapspec::copy_mask); +} + + std::vector<coord_def> map_lines::find_glyph(int gly) const { std::vector<coord_def> points; @@ -1478,11 +1795,12 @@ dlua_set_map::~dlua_set_map() map_def::map_def() : name(), tags(), place(), depths(), orient(), chance(), weight(), weight_depth_mult(), weight_depth_div(), welcome_messages(), map(), - mons(), items(), random_mons(), keyspecs(), prelude("dlprelude"), + mons(), items(), random_mons(), prelude("dlprelude"), mapchunk("dlmapchunk"), main("dlmain"), validate("dlvalidate"), veto("dlveto"), rock_colour(BLACK), floor_colour(BLACK), rock_tile(0), floor_tile(0), - border_fill_type(DNGN_ROCK_WALL), index_only(false), cache_offset(0L) + border_fill_type(DNGN_ROCK_WALL), index_only(false), cache_offset(0L), + validating_map_flag(false) { init(); } @@ -1501,13 +1819,16 @@ void map_def::init() veto.clear(); place_loaded_from.clear(); reinit(); + + // Subvault mask set and cleared externally. + // It should *not* be in reinit. + svmask = NULL; } void map_def::reinit() { items.clear(); random_mons.clear(); - keyspecs.clear(); level_flags.clear(); branch_flags.clear(); @@ -1549,6 +1870,33 @@ void map_def::reinit() mons.clear(); } +bool map_def::valid_item_array_glyph(int gly) +{ + return (gly >= 'd' && gly <= 'k'); +} + +int map_def::item_array_glyph_to_slot(int gly) +{ + ASSERT(map_def::valid_item_array_glyph(gly)); + return (gly - 'd'); +} + +bool map_def::valid_monster_glyph(int gly) +{ + return (gly >= '0' && gly <= '9'); +} + +bool map_def::valid_monster_array_glyph(int gly) +{ + return (gly >= '1' && gly <= '7'); +} + +int map_def::monster_array_glyph_to_slot(int gly) +{ + ASSERT(map_def::valid_monster_array_glyph(gly)); + return (gly - '1'); +} + bool map_def::in_map(const coord_def &c) const { return map.in_map(c); @@ -1846,10 +2194,14 @@ std::string map_def::validate_temple_map() // TODO: check for substitutions and shuffles - keyed_mapspec *spec = mapspec_for_key('B'); - - if (spec != NULL && spec->feat.feats.size() > 0) - return ("Can't change feat 'B' in temple (KFEAT)"); + std::vector<coord_def> b_glyphs = map.find_glyph('B'); + for (std::vector<coord_def>::iterator i = b_glyphs.begin(); + i != b_glyphs.end(); ++i) + { + const keyed_mapspec *spec = map.mapspec_at(*i); + if (spec != NULL && spec->feat.feats.size() > 0) + return ("Can't change feat 'B' in temple (KFEAT)"); + } std::vector<god_type> god_list = temple_god_list(); @@ -1861,6 +2213,8 @@ std::string map_def::validate_temple_map() std::string map_def::validate_map_def() { + unwind_bool valid_flag(validating_map_flag, true); + std::string err = run_lua(true); if (!err.empty()) return (err); @@ -2255,69 +2609,193 @@ std::vector<std::string> map_def::get_tags() const return split_string(" ", tags); } -const keyed_mapspec *map_def::mapspec_for_key(int key) const +keyed_mapspec *map_def::mapspec_at(const coord_def &c) { - keyed_specs::const_iterator i = keyspecs.find(key); - return i != keyspecs.end()? &i->second : NULL; + return (map.mapspec_at(c)); } -keyed_mapspec *map_def::mapspec_for_key(int key) +const keyed_mapspec *map_def::mapspec_at(const coord_def &c) const { - keyed_specs::iterator i = keyspecs.find(key); - return i != keyspecs.end()? &i->second : NULL; + return (map.mapspec_at(c)); } -std::string map_def::add_key_field( - const std::string &s, - std::string (keyed_mapspec::*set_field)(const std::string &s, bool fixed), - void (keyed_mapspec::*copy_field)(keyed_mapspec &spec)) +std::string map_def::subvault_from_tagstring(const std::string &sub) { - int separator = 0; - std::string key, arg; + std::string s = trimmed_string(sub); - std::string err = mapdef_split_key_item(s, &key, &separator, &arg, -1); + if (s.empty()) + return (""); + + int sep = 0; + std::string key; + std::string substitute; + + std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute, -1); if (!err.empty()) return (err); - keyed_mapspec &kmbase = keyspecs[key[0]]; - kmbase.key_glyph = key[0]; - err = ((kmbase.*set_field)(arg, separator == ':')); + // Randomly picking a different vault per-glyph is not supported. + if (sep != ':') + return ("SUBVAULT does not support '='. Use ':' instead."); + + map_string_list vlist; + err = parse_weighted_str<map_string_list>(substitute, vlist); if (!err.empty()) return (err); - size_t len = key.length(); - for (size_t i = 1; i < len; i++) + bool fix = false; + string_spec spec(key, fix, vlist); + + // Although it's unfortunate to not be able to validate subvaults except a + // run-time, this allows subvaults to reference maps by tag that may not + // have been loaded yet. + if (!is_validating()) + err = apply_subvault(spec); + + if (!err.empty()) + return (err); + + return (""); +} + +std::string map_def::apply_subvault(string_spec &spec) +{ + // Find bounding box for key glyphs + coord_def tl, br; + if (!map.find_bounds(spec.key.c_str(), tl, br)) { - keyed_mapspec &km = keyspecs[key[i]]; - km.key_glyph = key[i]; - ((km.*copy_field)(kmbase)); + // No glyphs, so do nothing. + return (""); } - return (err); + int vwidth = br.x - tl.x + 1; + int vheight = br.y - tl.y + 1; + Matrix<bool> flags(vwidth, vheight); + map.fill_mask_matrix(spec.key, tl, br, flags); + + // Backup pre-subvault unique tags and names. + const std::set<std::string> uniq_tags = you.uniq_map_tags; + const std::set<std::string> uniq_names = you.uniq_map_names; + + const int max_tries = 100; + int ntries = 0; + + std::string tag = spec.get_property(); + while (++ntries <= max_tries) + { + // Each iteration, restore tags and names. This is because this vault + // may successfully load a subvault (registering its tag and name), but + // then itself fail. + you.uniq_map_tags = uniq_tags; + you.uniq_map_names = uniq_names; + + const map_def *orig = random_map_for_tag(tag); + if (!orig) + return (make_stringf("No vault found for tag '%s'", tag.c_str())); + + map_def vault = *orig; + + vault.load(); + + // Temporarily set the subvault mask so this subvault can know + // that it is being generated as a subvault. + vault.svmask = &flags; + + if (!resolve_subvault(vault)) + continue; + + ASSERT(vault.map.width() <= vwidth); + ASSERT(vault.map.height() <= vheight); + + map.merge_subvault(tl, br, flags, vault); + + dgn_register_vault(vault); + + return (""); + } + + // Failure, restore original unique tags and names. + you.uniq_map_tags = uniq_tags; + you.uniq_map_names = uniq_names; + + return (make_stringf("Could not fit '%s' in (%d,%d) to (%d, %d).", + tag.c_str(), tl.x, tl.y, br.x, br.y)); } -std::string map_def::add_key_item(const std::string &s) +bool map_def::is_subvault() const { - return add_key_field(s, &keyed_mapspec::set_item, - &keyed_mapspec::copy_item); + return (svmask != NULL); } -std::string map_def::add_key_feat(const std::string &s) +void map_def::apply_subvault_mask() { - return add_key_field(s, &keyed_mapspec::set_feat, - &keyed_mapspec::copy_feat); + if (!svmask) + return; + + map.clear(); + map.extend(subvault_width(), subvault_height(), ' '); + + for (rectangle_iterator ri(map.get_iter()); ri; ++ri) + { + const coord_def mc = *ri; + if (subvault_cell_valid(mc)) + map(mc) = '.'; + else + map(mc) = ' '; + } } -std::string map_def::add_key_mons(const std::string &s) +bool map_def::subvault_cell_valid(const coord_def &c) const { - return add_key_field(s, &keyed_mapspec::set_mons, - &keyed_mapspec::copy_mons); + if (!svmask) + return false; + + if (c.x < 0 || c.x >= subvault_width() + || c.y < 0 || c.y >= subvault_height()) + { + return false; + } + + return (*svmask)(c.x, c.y); } -std::string map_def::add_key_mask(const std::string &s) +int map_def::subvault_width() const { - return add_key_field(s, &keyed_mapspec::set_mask, - &keyed_mapspec::copy_mask); + if (!svmask) + return 0; + + return (svmask->width()); +} + +int map_def::subvault_height() const +{ + if (!svmask) + return 0; + + return (svmask->height()); +} + +int map_def::subvault_mismatch_count(const coord_def &offset) const +{ + int count = 0; + if (!is_subvault()) + return (count); + + for (rectangle_iterator ri(map.get_iter()); ri; ++ri) + { + // Coordinate in the subvault + const coord_def sc = *ri; + // Coordinate in the mask + const coord_def mc = sc + offset; + + bool valid_subvault_cell = (map(sc) != ' '); + bool valid_mask = (*svmask)(mc.x, mc.y); + + if (valid_subvault_cell && !valid_mask) + count++; + } + + return (count); } /////////////////////////////////////////////////////////////////// @@ -2398,6 +2876,18 @@ void mons_list::clear() mons.clear(); } +void mons_list::set_from_slot(const mons_list &list, int slot_index) +{ + clear(); + + // Don't set anything if an invalid index. + // Future calls to get_monster will just return a random monster. + if (slot_index < 0 || (size_t)slot_index >= list.mons.size()) + return; + + mons.push_back(list.mons[slot_index]); +} + bool mons_list::check_mimic(const std::string &s, int *mid, bool *fix) const { if (s == "mimic") @@ -3078,6 +3568,18 @@ std::string item_list::set_item(int index, const std::string &spec) return (error); } +void item_list::set_from_slot(const item_list &list, int slot_index) +{ + clear(); + + // Don't set anything if an invalid index. + // Future calls to get_item will just return no item. + if (slot_index < 0 || (size_t)slot_index >= list.items.size()) + return; + + items.push_back(list.items[slot_index]); +} + // TODO: More checking for innapropriate combinations, like the holy // wrath brand on a demonic weapon or the running ego on a helmet. static int str_to_ego(item_spec &spec, std::string ego_str) @@ -3590,6 +4092,24 @@ int fprop_spec::get_property() } ////////////////////////////////////////////////////////////////////////// +// string_spec + +std::string string_spec::get_property() +{ + if (!fixed_str.empty()) + return fixed_str; + + std::string chosen = ""; + int cweight = 0; + for (int i = 0, size = strlist.size(); i < size; ++i) + if (x_chance_in_y(strlist[i].second, cweight += strlist[i].second)) + chosen = strlist[i].first; + if (fix) + fixed_str = chosen; + return (chosen); +} + +////////////////////////////////////////////////////////////////////////// // map_marker_spec std::string map_marker_spec::apply_transform(map_lines &map) @@ -3696,7 +4216,7 @@ std::string keyed_mapspec::set_feat(const std::string &s, bool fix) return (err); } -void keyed_mapspec::copy_feat(keyed_mapspec &spec) +void keyed_mapspec::copy_feat(const keyed_mapspec &spec) { feat = spec.feat; } @@ -3853,17 +4373,17 @@ std::string keyed_mapspec::set_mask(const std::string &s, bool garbage) return (err); } -void keyed_mapspec::copy_mons(keyed_mapspec &spec) +void keyed_mapspec::copy_mons(const keyed_mapspec &spec) { mons = spec.mons; } -void keyed_mapspec::copy_item(keyed_mapspec &spec) +void keyed_mapspec::copy_item(const keyed_mapspec &spec) { item = spec.item; } -void keyed_mapspec::copy_mask(keyed_mapspec &spec) +void keyed_mapspec::copy_mask(const keyed_mapspec &spec) { map_mask = spec.map_mask; } diff --git a/crawl-ref/source/mapdef.h b/crawl-ref/source/mapdef.h index 8c3df25039..fb8728d3f6 100644 --- a/crawl-ref/source/mapdef.h +++ b/crawl-ref/source/mapdef.h @@ -228,8 +228,35 @@ private: map_marker *create_marker(); }; +typedef std::pair<std::string, int> map_weighted_string; +class map_string_list : public std::vector<map_weighted_string> +{ +public: + bool parse(const std::string &fp, int weight); +}; +class string_spec +{ +public: + string_spec(std::string _key, bool _fix, const map_string_list &slist) + : key(_key), fix(_fix), fixed_str(""), strlist(slist) + { + } + + std::string get_property(); + +public: + std::string key; + bool fix; + std::string fixed_str; + map_string_list strlist; +}; + +template<class T> +std::string parse_weighted_str(const std::string &cspec, T &list); + class map_def; class rectangle_iterator; +class keyed_mapspec; class map_lines { public: @@ -305,6 +332,14 @@ public: char operator () (int x, int y) const; char& operator () (int x, int y); + const keyed_mapspec *mapspec_at(const coord_def &c) const; + keyed_mapspec *mapspec_at(const coord_def &c); + + std::string add_key_item(const std::string &s); + std::string add_key_mons(const std::string &s); + std::string add_key_feat(const std::string &s); + std::string add_key_mask(const std::string &s); + bool in_bounds(const coord_def &c) const; // Extend map dimensions with glyph 'fill' to minimum width and height. @@ -317,6 +352,12 @@ public: int count_feature_in_box(const coord_def &tl, const coord_def &br, const char *feat) const; + void fill_mask_matrix(const std::string &glyphs, const coord_def &tl, + const coord_def &br, Matrix<bool> &flags); + + // Merge vault onto the tl/br subregion, where mask is true. + void merge_subvault(const coord_def &tl, const coord_def &br, + const Matrix<bool> &mask, const map_def &vault); private: void init_from(const map_lines &map); template <typename V> void clear_vector(V &vect); @@ -335,6 +376,12 @@ private: void nsubst(nsubst_spec &); void overlay_colours(colour_spec &); void overlay_fprops(fprop_spec &); + + // Merge cell (vx, vy) from vault onto this map's (x, y) cell. + typedef FixedVector<int, 256> keyspec_map; + void merge_cell(int x, int y, const map_def &vault, int vx, int vy, + int keyspec_idx); + #ifdef USE_TILE void overlay_tiles(tile_spec &); #endif @@ -351,12 +398,20 @@ private: subst_spec &spec); std::string parse_glyph_replacements(std::string s, glyph_replacements_t &gly); - template<class T> - std::string parse_weighted_str(const std::string &cspec, T &list); + #ifdef USE_TILE std::string add_tile(const std::string &sub, bool is_floor); #endif + std::string add_key_field( + const std::string &s, + std::string (keyed_mapspec::*set_field)( + const std::string &s, bool fixed), + void (keyed_mapspec::*copy_field)(const keyed_mapspec &spec)); + + const keyed_mapspec *mapspec_for_key(int key) const; + keyed_mapspec *mapspec_for_key(int key); + friend class subst_spec; friend class nsubst_spec; friend class shuffle_spec; @@ -370,15 +425,25 @@ private: struct overlay_def { - overlay_def() : colour(0), rocktile(0), floortile(0), property(0) {} + overlay_def() : colour(0), rocktile(0), floortile(0), property(0), keyspec_idx(0) {} int colour; int rocktile; int floortile; int property; + int keyspec_idx; }; typedef Matrix<overlay_def> overlay_matrix; std::auto_ptr<overlay_matrix> overlay; + typedef std::map<int, keyed_mapspec> keyed_specs; + keyed_specs keyspecs; + int next_keyspec_idx; + + enum + { + SUBVAULT_GLYPH = 1 + }; + int map_width; bool solid_north, solid_east, solid_south, solid_west; bool solid_checked; @@ -432,6 +497,9 @@ public: std::string add_item(const std::string &spec, bool fix = false); std::string set_item(int index, const std::string &spec); + // Set this list to be a copy of the item_spec_slot in list. + void set_from_slot(const item_list &list, int slot_index); + private: struct item_spec_slot { @@ -503,6 +571,9 @@ public: void clear(); + // Set this list to be a copy of the mons_spec_slot in list. + void set_from_slot(const mons_list &list, int slot_index); + mons_spec get_monster(int index); mons_spec get_monster(int slot_index, int list_index) const; @@ -611,10 +682,10 @@ public: // Copy from the given mapspec. If that entry is fixed, // it should be pre-selected prior to the copy. - void copy_feat(keyed_mapspec &spec); - void copy_mons(keyed_mapspec &spec); - void copy_item(keyed_mapspec &spec); - void copy_mask(keyed_mapspec &spec); + void copy_feat(const keyed_mapspec &spec); + void copy_mons(const keyed_mapspec &spec); + void copy_item(const keyed_mapspec &spec); + void copy_mask(const keyed_mapspec &spec); feature_spec get_feat(); mons_list &get_monsters(); @@ -631,8 +702,6 @@ private: feature_spec parse_trap(std::string s, int weight); }; -typedef std::map<int, keyed_mapspec> keyed_specs; - typedef std::vector<level_range> depth_ranges; class map_def; @@ -709,12 +778,16 @@ public: mons_list mons; item_list items; + static bool valid_item_array_glyph(int gly); + static int item_array_glyph_to_slot(int gly); + static bool valid_monster_array_glyph(int gly); + static bool valid_monster_glyph(int gly); + static int monster_array_glyph_to_slot(int gly); + std::vector<mons_spec> random_mons; map_flags level_flags, branch_flags; - keyed_specs keyspecs; - dlua_chunk prelude, mapchunk, main, validate, veto; map_file_place place_loaded_from; @@ -731,6 +804,12 @@ private: long cache_offset; std::string file; + typedef Matrix<bool> subvault_mask; + subvault_mask *svmask; + + // True if this map is in the process of being validated. + bool validating_map_flag; + public: map_def(); void init(); @@ -763,6 +842,8 @@ public: std::string validate_map_def(); std::string validate_temple_map(); + // Returns true if this map is in the middle of validation. + bool is_validating() const { return (validating_map_flag); } void add_prelude_line(int line, const std::string &s); void add_main_line(int line, const std::string &s); @@ -776,19 +857,14 @@ public: bool is_usable_in(const level_id &lid) const; - keyed_mapspec *mapspec_for_key(int key); - const keyed_mapspec *mapspec_for_key(int key) const; + const keyed_mapspec *mapspec_at(const coord_def &c) const; + keyed_mapspec *mapspec_at(const coord_def &c); bool has_depth() const; void add_depth(const level_range &depth); void add_depths(depth_ranges::const_iterator s, depth_ranges::const_iterator e); - std::string add_key_item(const std::string &s); - std::string add_key_mons(const std::string &s); - std::string add_key_feat(const std::string &s); - std::string add_key_mask(const std::string &s); - bool can_dock(map_section_type) const; coord_def dock_pos(map_section_type) const; coord_def float_dock(); @@ -809,6 +885,17 @@ public: int glyph_at(const coord_def &c) const; + // Subvault functions. + std::string subvault_from_tagstring(const std::string &s); + bool is_subvault() const; + void apply_subvault_mask(); + bool subvault_cell_valid(const coord_def &c) const; + int subvault_width() const; + int subvault_height() const; + // Returns the number of cells in the subvault map that + // will not get copied to parent vault at a given placement. + int subvault_mismatch_count(const coord_def &place) const; + public: struct map_feature_finder { @@ -834,16 +921,12 @@ public: }; private: + void write_depth_ranges(writer&) const; void read_depth_ranges(reader&); bool test_lua_boolchunk(dlua_chunk &, bool def = false, bool croak = false); std::string rewrite_chunk_errors(const std::string &s) const; - - std::string add_key_field( - const std::string &s, - std::string (keyed_mapspec::*set_field)( - const std::string &s, bool fixed), - void (keyed_mapspec::*copy_field)(keyed_mapspec &spec)); + std::string apply_subvault(string_spec &); }; const int CHANCE_ROLL = 10000; diff --git a/crawl-ref/source/maps.cc b/crawl-ref/source/maps.cc index cc59a8043d..abb72b8a25 100644 --- a/crawl-ref/source/maps.cc +++ b/crawl-ref/source/maps.cc @@ -118,8 +118,7 @@ static int write_vault(map_def &mdef, return (place.orient); } -// Mirror the map if appropriate, resolve substitutable symbols (?), -static bool resolve_map(map_def &map) +static bool resolve_map_lua(map_def &map) { map.reinit(); std::string err = map.run_lua(true); @@ -144,6 +143,15 @@ static bool resolve_map(map_def &map) if (!map.test_lua_validate(false)) return (false); + return (true); +} + +// Mirror the map if appropriate, resolve substitutable symbols (?), +static bool resolve_map(map_def &map) +{ + if (!resolve_map_lua(map)) + return false; + // Mirroring is possible for any map that does not explicitly forbid it. // Note that mirroring also flips the orientation. if (coinflip()) @@ -154,8 +162,108 @@ static bool resolve_map(map_def &map) // The map may also refuse to be rotated. if (coinflip()) - map.rotate( coinflip() ); + map.rotate(coinflip()); + + return true; +} + +bool resolve_subvault(map_def &map) +{ + ASSERT(map.is_subvault()); + if (!map.is_subvault()) + return false; + + if (!resolve_map_lua(map)) + return false; + + int width = map.subvault_width(); + int height = map.subvault_height(); + + bool can_rot = (map.map.width() <= height && map.map.height() <= width); + bool must_rot = (map.map.width() > width || map.map.height() > height); + + // Too big, whether or not it is rotated. + if (must_rot && !can_rot) + return false; + + if (must_rot || can_rot && coinflip()) + { + bool dir = coinflip(); + map.rotate(dir); + + // Update post-rotation dimensions. + width = map.subvault_width(); + height = map.subvault_height(); + } + + // Inexact fits with dimensions flipped will get rotated above. + bool exact_fit = (map.map.height() == height && map.map.width() == width); + if (!exact_fit) + { + if (coinflip()) + map.hmirror(); + + if (coinflip()) + map.vmirror(); + + // The map may have refused to have been rotated, so verify dimensions. + bool valid = (map.map.width() <= width && map.map.height() <= height); + return (valid); + } + + // Don't bother flipping or rotating 1x1 subvaults. + // This just cuts down on level generation message spam. + if (exact_fit && width == height && width == 1) + return (true); + + // Count original mismatches. If mirroring the map causes more cells to + // not be written, then don't mirror. This allows oddly shaped subvaults + // to be fit correctly into a parent vault that specifies the exact same + // shape. + const coord_def svplace(0, 0); + + // 0 - normal + // 1 - flip horz + // 2 - flip vert + horz + // 3 - flip vert + int mismatch[4]; + + // Mirror map in all directions to find best fit. + mismatch[0] = map.subvault_mismatch_count(svplace); + map.hmirror(); + mismatch[1] = map.subvault_mismatch_count(svplace); + map.vmirror(); + mismatch[2] = map.subvault_mismatch_count(svplace); + map.hmirror(); + mismatch[3] = map.subvault_mismatch_count(svplace); + + int min_mismatch = std::min(mismatch[0], mismatch[1]); + min_mismatch = std::min(min_mismatch, mismatch[2]); + min_mismatch = std::min(min_mismatch, mismatch[3]); + + // Pick a mirror combination with the minimum number of mismatches. + int idx = random2(4); + while (mismatch[idx] != min_mismatch) + idx = (idx + 1) % 4; + + // Flip the map (currently vmirror'd) to the correct orientation. + if (idx == 0) + { + map.vmirror(); + } + else if (idx == 1) + { + map.vmirror(); + map.hmirror(); + } + else if (idx == 2) + { + map.hmirror(); + } + + ASSERT(map.subvault_mismatch_count(svplace) == min_mismatch); + // We already know this is an exact fit, so this is a success. return (true); } diff --git a/crawl-ref/source/maps.h b/crawl-ref/source/maps.h index e3f902a23a..c05d5515b5 100644 --- a/crawl-ref/source/maps.h +++ b/crawl-ref/source/maps.h @@ -20,6 +20,8 @@ struct vault_placement; int vault_main(vault_placement &vp, const map_def *vault, bool check_place = false); +bool resolve_subvault(map_def &vault); + // Given a rectangular region, slides it to fit into the map. size must be // smaller than (GXM,GYM). void fit_region_into_map_bounds(coord_def &pos, const coord_def &size, diff --git a/crawl-ref/source/matrix.h b/crawl-ref/source/matrix.h index 520711ca88..311602cfdc 100644 --- a/crawl-ref/source/matrix.h +++ b/crawl-ref/source/matrix.h @@ -16,21 +16,24 @@ public: void init(const Z &initial); Z &operator () (int x, int y) { - return data[x + y * width]; + return data[x + y * mwidth]; } const Z &operator () (int x, int y) const { - return data[x + y * width]; + return data[x + y * mwidth]; } + int width() const { return mwidth; } + int height() const { return mheight; } + private: Z *data; - int width, height, size; + int mwidth, mheight, size; }; template <typename Z> Matrix<Z>::Matrix(int _width, int _height, const Z &initial) - : data(NULL), width(_width), height(_height), size(_width * _height) + : data(NULL), mwidth(_width), mheight(_height), size(_width * _height) { data = new Z [ size ]; init(initial); @@ -38,7 +41,7 @@ Matrix<Z>::Matrix(int _width, int _height, const Z &initial) template <typename Z> Matrix<Z>::Matrix(int _width, int _height) - : data(NULL), width(_width), height(_height), size(_width * _height) + : data(NULL), mwidth(_width), mheight(_height), size(_width * _height) { data = new Z [ size ]; } diff --git a/crawl-ref/source/prebuilt/levcomp.lex.cc b/crawl-ref/source/prebuilt/levcomp.lex.cc index 4a03b78195..09810f30db 100644 --- a/crawl-ref/source/prebuilt/levcomp.lex.cc +++ b/crawl-ref/source/prebuilt/levcomp.lex.cc @@ -9,7 +9,7 @@ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 -#define YY_FLEX_SUBMINOR_VERSION 35 +#define YY_FLEX_SUBMINOR_VERSION 33 #if YY_FLEX_SUBMINOR_VERSION > 0 #define FLEX_BETA #endif @@ -31,7 +31,7 @@ /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#if __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. @@ -94,12 +94,11 @@ typedef unsigned int flex_uint32_t; #else /* ! __cplusplus */ -/* C99 requires __STDC__ to be defined as 1. */ -#if defined (__STDC__) +#if __STDC__ #define YY_USE_CONST -#endif /* defined (__STDC__) */ +#endif /* __STDC__ */ #endif /* ! __cplusplus */ #ifdef YY_USE_CONST @@ -192,9 +191,14 @@ extern FILE *yyin, *yyout; #define unput(c) yyunput( c, (yytext_ptr) ) +/* The following is because we cannot portably get our hands on size_t + * (without autoconf's help, which isn't available because we want + * flex-generated scanners to compile on their own). + */ + #ifndef YY_TYPEDEF_YY_SIZE_T #define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; +typedef unsigned int yy_size_t; #endif #ifndef YY_STRUCT_YY_BUFFER_STATE @@ -373,8 +377,8 @@ static void yy_fatal_error (yyconst char msg[] ); *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 80 -#define YY_END_OF_BUFFER 81 +#define YY_NUM_RULES 81 +#define YY_END_OF_BUFFER 82 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -382,38 +386,38 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static yyconst flex_int16_t yy_accept[1073] = +static yyconst flex_int16_t yy_accept[1096] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 81, 79, 76, 77, - 78, 74, 79, 72, 75, 73, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 76, 34, 36, 79, 79, 79, 79, 79, - 79, 80, 6, 80, 80, 4, 2, 3, 80, 2, - 2, 2, 2, 9, 10, 80, 9, 9, 80, 12, - 80, 32, 76, 33, 78, 32, 32, 32, 32, 32, + 0, 0, 0, 0, 0, 0, 82, 80, 77, 78, + 79, 75, 80, 73, 76, 74, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 77, 34, 36, 80, 80, 80, 80, 80, + 80, 81, 6, 81, 81, 4, 2, 3, 81, 2, + 2, 2, 2, 9, 10, 81, 9, 9, 81, 12, + 81, 32, 77, 33, 79, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, - 32, 32, 32, 32, 32, 32, 32, 76, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 77, 32, 32, - 32, 32, 32, 32, 32, 32, 79, 28, 23, 28, - 74, 79, 27, 75, 73, 79, 79, 79, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 28, 34, 36, 79, 79, 79, 79, 79, - 79, 15, 16, 78, 13, 13, 13, 13, 13, 13, + 32, 32, 32, 32, 32, 32, 80, 28, 23, 28, + 75, 80, 27, 76, 74, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 28, 34, 36, 80, 80, 80, 80, 80, + 80, 15, 16, 79, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 79, 13, 15, 13, 13, 13, 13, 13, - 80, 21, 22, 80, 20, 80, 76, 77, 75, 0, + 13, 13, 80, 13, 15, 13, 13, 13, 13, 13, + 81, 21, 22, 81, 20, 81, 77, 78, 76, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 76, 34, 36, 0, 0, 0, + 0, 0, 0, 0, 77, 34, 36, 0, 0, 0, 0, 34, 0, 0, 0, 0, 0, 0, 0, 39, 6, 5, 0, 0, 2, 3, 2, 0, 2, 2, 2, 2, 9, 9, 10, 9, 9, 9, 0, 11, - 0, 12, 31, 0, 31, 76, 33, 0, 0, 33, + 0, 12, 31, 0, 31, 77, 33, 0, 0, 33, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, - 31, 31, 31, 31, 31, 0, 30, 31, 76, 31, + 31, 31, 31, 31, 31, 0, 30, 31, 77, 31, 34, 31, 31, 31, 31, 31, 31, 31, 31, 31, 26, 0, 26, 28, 23, 28, 0, 23, 26, 26, @@ -446,62 +450,65 @@ static yyconst flex_int16_t yy_accept[1073] = 0, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 35, 0, 0, 0, 0, 0, 2, 9, - 8, 0, 9, 7, 0, 31, 31, 31, 31, 31, + 0, 0, 0, 35, 0, 0, 0, 0, 0, 2, + 9, 8, 0, 9, 7, 0, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, - 31, 31, 31, 0, 0, 31, 31, 31, 31, 26, + 31, 31, 31, 31, 31, 0, 0, 31, 31, 31, + 31, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 26, 26, 26, 26, 0, 0, 26, - 26, 26, 26, 13, 13, 13, 13, 13, 13, 13, + 0, 0, 26, 26, 26, 26, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 0, 0, 0, 0, 0, 0, - 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 13, 13, 13, 13, 13, 13, 13, 13, 0, 0, + 0, 0, 0, 0, 64, 0, 0, 0, 0, 0, - 63, 42, 0, 0, 0, 0, 0, 0, 51, 0, - 0, 0, 38, 0, 0, 0, 0, 2, 31, 31, + 0, 0, 0, 0, 63, 42, 0, 0, 0, 0, + 0, 0, 0, 51, 0, 0, 0, 38, 0, 0, + 0, 0, 2, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, - 31, 31, 31, 31, 31, 31, 31, 31, 31, 0, - 31, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 31, 31, 31, 31, 31, 0, 31, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 0, 26, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 0, + 26, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 0, 0, 0, 44, 50, 61, 67, 68, 70, 69, - 71, 0, 0, 0, 0, 0, 0, 0, 46, 62, - 0, 54, 0, 0, 0, 0, 0, 41, 1, 31, + 13, 13, 13, 13, 13, 13, 13, 13, 0, 0, + 0, 44, 50, 61, 67, 68, 70, 69, 71, 0, + 0, 0, 0, 0, 0, 0, 46, 62, 0, 54, + 0, 0, 0, 0, 0, 0, 41, 1, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 26, 26, 13, 13, 13, 13, 13, + 26, 26, 26, 26, 26, 26, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 53, 48, 56, 52, 0, 0, 0, 0, 65, - 55, 45, 0, 49, 0, 0, 0, 0, 1, 31, + 13, 13, 13, 53, 48, 56, 52, 0, 0, 0, + 0, 65, 55, 45, 0, 0, 49, 0, 0, 0, + 0, 1, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, - 31, 31, 31, 31, 31, 31, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, - 26, 26, 26, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 0, 0, 0, 0, 66, 47, 0, 0, - 0, 0, 31, 31, 31, 31, 31, 31, 31, 0, - 31, 31, 26, 26, 26, 26, 26, 26, 26, 0, - - 26, 26, 13, 13, 13, 13, 13, 13, 0, 0, - 58, 0, 0, 37, 0, 0, 31, 31, 31, 31, - 31, 31, 0, 31, 26, 26, 26, 26, 26, 26, - 0, 26, 13, 13, 13, 13, 57, 0, 60, 0, - 40, 31, 31, 31, 31, 31, 26, 26, 26, 26, - 26, 13, 13, 59, 0, 31, 31, 26, 26, 13, - 0, 31, 26, 13, 0, 31, 26, 13, 43, 31, - 26, 0 + 26, 26, 26, 26, 26, 26, 26, 26, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 0, 0, + 0, 0, 66, 0, 47, 0, 0, 0, 0, 31, + + 31, 31, 31, 31, 31, 31, 31, 0, 31, 31, + 26, 26, 26, 26, 26, 26, 26, 26, 0, 26, + 26, 13, 13, 13, 13, 13, 13, 13, 0, 0, + 58, 0, 72, 0, 37, 0, 0, 31, 31, 31, + 31, 31, 31, 31, 0, 31, 26, 26, 26, 26, + 26, 26, 26, 0, 26, 13, 13, 13, 13, 57, + 0, 60, 0, 40, 31, 31, 31, 31, 31, 26, + 26, 26, 26, 26, 13, 13, 59, 0, 31, 31, + 26, 26, 13, 0, 31, 26, 13, 0, 31, 26, + 13, 43, 31, 26, 0 + } ; static yyconst flex_int32_t yy_ec[256] = @@ -514,12 +521,12 @@ static yyconst flex_int32_t yy_ec[256] = 11, 11, 11, 11, 11, 11, 11, 12, 1, 1, 1, 1, 1, 1, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, - 22, 29, 30, 31, 32, 22, 33, 22, 22, 22, - 1, 34, 1, 1, 22, 1, 35, 22, 22, 36, + 22, 29, 30, 31, 32, 33, 34, 22, 22, 22, + 1, 35, 1, 1, 22, 1, 36, 22, 22, 37, - 37, 38, 22, 39, 40, 22, 22, 41, 22, 22, - 42, 43, 22, 44, 45, 46, 47, 48, 22, 22, - 22, 22, 49, 1, 50, 1, 1, 1, 1, 1, + 38, 39, 22, 40, 41, 22, 22, 42, 22, 22, + 43, 44, 22, 45, 46, 47, 48, 49, 22, 22, + 22, 22, 50, 1, 51, 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, @@ -536,1065 +543,1090 @@ static yyconst flex_int32_t yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst flex_int32_t yy_meta[51] = +static yyconst flex_int32_t yy_meta[52] = { 0, 1, 2, 3, 4, 1, 1, 1, 1, 5, 6, 6, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, - 6, 6, 6, 1, 6, 6, 6, 6, 6, 6, - 6, 6, 6, 6, 6, 6, 6, 6, 1, 1 + 6, 6, 6, 6, 1, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 1, + 1 } ; -static yyconst flex_int16_t yy_base[1090] = +static yyconst flex_int16_t yy_base[1113] = { 0, - 0, 49, 53, 60, 64, 66, 49, 68, 116, 165, - 214, 263, 312, 361, 76, 170, 2328, 3533, 71, 3533, - 2308, 3533, 2291, 3533, 2285, 3533, 2275, 55, 2275, 60, - 2256, 68, 70, 74, 70, 2252, 2256, 2244, 75, 2241, - 2214, 2184, 409, 0, 3533, 155, 2172, 2160, 144, 67, - 2153, 3533, 3533, 2198, 180, 3533, 0, 3533, 2183, 189, - 0, 2154, 164, 2129, 3533, 2172, 58, 2117, 109, 3533, - 2157, 268, 275, 3533, 366, 373, 378, 383, 388, 392, - 414, 426, 432, 437, 460, 493, 470, 474, 479, 501, - 515, 520, 524, 529, 536, 543, 555, 562, 567, 571, - - 577, 581, 589, 593, 605, 598, 269, 617, 3533, 632, - 374, 422, 3533, 433, 379, 468, 641, 582, 624, 639, - 651, 660, 647, 675, 662, 682, 652, 688, 690, 695, - 723, 696, 732, 709, 697, 736, 705, 740, 742, 746, - 748, 756, 3533, 789, 2147, 2143, 0, 2134, 160, 2125, - 164, 2107, 264, 168, 185, 253, 2103, 2105, 2097, 179, - 2105, 2093, 198, 2071, 796, 254, 2055, 2052, 151, 170, - 770, 803, 3533, 807, 3533, 811, 282, 3533, 2076, 2052, - 2059, 2047, 2040, 2053, 2043, 2045, 2041, 2022, 263, 2018, - 2022, 2011, 2002, 2002, 1998, 1990, 1992, 1995, 1986, 1972, - - 1989, 1983, 270, 1960, 0, 0, 3533, 1936, 1935, 258, - 1922, 0, 268, 1933, 1928, 1951, 378, 1922, 1909, 3533, - 3533, 3533, 1951, 295, 0, 3533, 0, 1940, 609, 1923, - 1912, 384, 1885, 1874, 3533, 260, 1873, 815, 361, 3533, - 1917, 3533, 820, 824, 829, 844, 3533, 848, 857, 3533, - 862, 866, 870, 875, 882, 889, 893, 901, 915, 920, - 926, 932, 938, 942, 953, 963, 969, 973, 979, 986, - 991, 1004, 1012, 1025, 1019, 1029, 3533, 1037, 0, 1043, - 1047, 1052, 1056, 1060, 1064, 1074, 1068, 1078, 1087, 1095, - 887, 936, 1101, 1112, 3533, 1120, 1134, 3533, 1129, 1125, - - 1139, 1140, 1148, 1153, 1146, 1155, 1160, 1166, 1179, 1173, - 1181, 1183, 1191, 1193, 1199, 1206, 1207, 1216, 1221, 1229, - 1230, 1234, 1241, 1254, 3533, 1267, 1243, 0, 1274, 1280, - 1288, 1296, 1294, 1298, 1300, 1302, 1304, 1310, 1314, 1337, - 3533, 1347, 1355, 1359, 3533, 0, 1907, 1889, 1869, 1857, - 1844, 1857, 1841, 1843, 1842, 1827, 378, 1827, 1831, 1822, - 1819, 1821, 1801, 1792, 1801, 1807, 1795, 1779, 1789, 1778, - 374, 1363, 3533, 1752, 0, 426, 1754, 1747, 1767, 395, - 1738, 1729, 1321, 1341, 1374, 1380, 3533, 1384, 1392, 1368, - 1396, 3533, 1401, 1760, 1743, 1740, 1734, 1735, 1724, 1715, - - 1726, 1718, 1681, 1679, 1676, 432, 1683, 1674, 1656, 1667, - 1668, 1655, 1645, 1632, 1631, 1605, 1604, 1614, 1614, 1593, - 1407, 488, 1582, 1594, 1571, 1561, 1577, 1417, 1421, 1429, - 3533, 1433, 1438, 3533, 1442, 1446, 1450, 1456, 1460, 1473, - 1464, 1491, 1495, 1500, 1507, 1516, 1522, 1526, 1531, 1543, - 1550, 1557, 1565, 1571, 1581, 1585, 1590, 1596, 1602, 1608, - 1616, 1612, 1635, 1649, 1639, 1653, 1657, 1661, 1666, 1672, - 3533, 1676, 1538, 1480, 1662, 1688, 1697, 1702, 1707, 1708, - 1712, 1713, 1718, 1722, 1732, 1723, 1728, 1748, 1753, 1758, - 1759, 1766, 1772, 1781, 1783, 1789, 1793, 1799, 1800, 1827, - - 1805, 1835, 1816, 1823, 1839, 1840, 1841, 1584, 1567, 1555, - 1540, 1549, 1540, 1538, 1545, 1527, 1508, 1506, 1496, 450, - 1507, 1496, 1485, 1486, 1487, 1472, 1472, 1462, 1463, 1444, - 1443, 1451, 1448, 1422, 1849, 910, 1415, 1425, 1409, 1397, - 1874, 3533, 1882, 1410, 1413, 1395, 1397, 1386, 1398, 1401, - 1376, 1367, 1368, 1360, 1352, 1355, 1342, 1339, 1337, 1341, - 1325, 1303, 1305, 1304, 1303, 1300, 1286, 1299, 1290, 1268, - 1247, 1886, 3533, 943, 1238, 1239, 1244, 1508, 1261, 1890, - 3533, 1894, 1898, 3533, 1902, 1907, 1912, 1917, 1927, 1932, - 1940, 1948, 1954, 1965, 1971, 1976, 1987, 1982, 1991, 2007, - - 2015, 2022, 2031, 2040, 2035, 2046, 2050, 2055, 2073, 2081, - 2077, 2086, 2090, 2096, 2101, 2112, 2117, 2121, 2129, 1995, - 2134, 2138, 2107, 2143, 2142, 2169, 2151, 2164, 2160, 2182, - 2186, 2188, 2190, 2195, 2194, 2203, 2221, 2204, 2225, 2208, - 2230, 2234, 2238, 2244, 2243, 2239, 2248, 2281, 2255, 2256, - 2260, 2265, 2269, 1254, 1252, 1234, 1240, 1224, 1235, 1239, - 1218, 1222, 1214, 1200, 1194, 1197, 1187, 1180, 1182, 1179, - 1178, 1149, 1144, 1152, 1144, 1138, 1116, 1131, 1112, 1101, - 1079, 1073, 1082, 1576, 1081, 1093, 1080, 1095, 1084, 1076, - 3533, 1062, 1055, 1038, 1025, 1023, 998, 993, 454, 990, - - 3533, 3533, 987, 984, 999, 998, 980, 990, 3533, 970, - 973, 945, 3533, 949, 945, 1643, 930, 936, 2304, 2308, - 2312, 2317, 2328, 2343, 2322, 2348, 2359, 2363, 2368, 2374, - 2379, 2383, 2390, 2394, 2399, 2414, 2425, 2430, 2434, 2438, - 2447, 2453, 2458, 2465, 2472, 2478, 2484, 2489, 2496, 2500, - 2505, 2506, 2420, 2512, 2286, 2530, 2543, 2439, 2545, 2551, - 2556, 2557, 2568, 2569, 2576, 2581, 2582, 2570, 2587, 2592, - 2593, 2617, 2623, 2612, 2628, 2604, 2629, 2639, 2637, 2643, - 2645, 2650, 2654, 2656, 933, 939, 923, 938, 921, 917, - 914, 901, 899, 896, 895, 871, 859, 465, 856, 850, - - 845, 857, 845, 832, 843, 813, 818, 801, 804, 804, - 826, 824, 823, 3533, 3533, 3533, 3533, 3533, 3533, 3533, - 3533, 815, 485, 794, 782, 790, 784, 783, 3533, 3533, - 772, 3533, 776, 769, 739, 742, 732, 3533, 772, 2663, - 2687, 2696, 2678, 2691, 2702, 2709, 2713, 2718, 2722, 2727, - 2733, 2744, 2737, 2749, 2753, 2764, 2777, 2758, 2786, 2791, - 2795, 2800, 2805, 2811, 2819, 2826, 2831, 2772, 2835, 2836, - 2812, 2847, 2849, 2853, 2857, 2859, 2861, 2866, 2872, 2871, - 2877, 2873, 2887, 2896, 2907, 2883, 2908, 2918, 2913, 2920, - 2922, 2924, 2926, 2931, 2932, 761, 759, 757, 756, 492, - - 738, 743, 750, 744, 743, 737, 734, 723, 686, 686, - 675, 3533, 3533, 3533, 3533, 692, 696, 691, 680, 3533, - 3533, 3533, 670, 3533, 659, 653, 1861, 622, 645, 2941, - 2946, 2957, 2967, 2977, 2981, 2985, 2990, 2994, 3001, 3008, - 3018, 3027, 3032, 3036, 3043, 3049, 3016, 3053, 3054, 3055, - 3063, 3070, 3069, 3071, 3062, 3076, 3077, 3096, 3097, 3104, - 3110, 3112, 3116, 618, 610, 606, 601, 612, 605, 598, - 1866, 569, 564, 556, 566, 557, 3533, 3533, 532, 1923, - 513, 1928, 3121, 3130, 3135, 3154, 3147, 3158, 3163, 3168, - 3172, 3178, 3184, 3185, 3173, 3196, 3189, 3191, 3198, 3209, - - 3226, 3231, 537, 531, 540, 533, 507, 2274, 524, 515, - 3533, 503, 475, 3533, 2295, 461, 3233, 3237, 3242, 3247, - 3251, 3259, 3264, 3268, 3272, 3277, 3281, 3285, 3287, 3294, - 3298, 3299, 477, 465, 439, 410, 3533, 431, 3533, 382, - 3533, 3303, 3318, 3334, 3338, 3349, 3307, 3344, 3324, 3355, - 3329, 362, 329, 3533, 261, 3357, 3362, 3368, 3369, 255, - 247, 3375, 3382, 139, 103, 3388, 3383, 94, 3533, 3402, - 3392, 3533, 3436, 3442, 3448, 3454, 3460, 3466, 3472, 3478, - 3484, 3490, 3496, 3502, 3508, 3514, 3520, 54, 3526 + 0, 50, 54, 61, 65, 67, 50, 69, 118, 168, + 218, 268, 318, 368, 77, 173, 2459, 3602, 72, 3602, + 2451, 3602, 2438, 3602, 2435, 3602, 2426, 56, 2418, 60, + 2403, 77, 72, 76, 74, 2398, 2398, 2377, 65, 2390, + 2385, 2360, 417, 0, 3602, 158, 2339, 2338, 63, 70, + 2324, 3602, 3602, 2361, 183, 3602, 0, 3602, 2353, 187, + 0, 2329, 155, 2301, 3602, 2344, 64, 2293, 180, 3602, + 2337, 273, 280, 3602, 373, 380, 385, 390, 395, 399, + 422, 433, 437, 445, 460, 494, 479, 498, 488, 502, + 522, 530, 534, 538, 543, 572, 548, 577, 554, 566, + + 583, 588, 593, 600, 604, 609, 274, 617, 3602, 627, + 381, 589, 3602, 632, 386, 453, 443, 643, 645, 651, + 656, 661, 670, 687, 666, 683, 668, 704, 652, 706, + 710, 714, 723, 728, 729, 733, 738, 742, 746, 760, + 754, 780, 3602, 797, 2322, 2319, 0, 2302, 175, 2302, + 172, 2281, 179, 176, 186, 168, 2281, 2282, 2273, 266, + 2283, 2278, 285, 2256, 803, 268, 2238, 2238, 68, 173, + 774, 808, 3602, 814, 3602, 818, 289, 3602, 2269, 2254, + 2261, 2248, 2238, 2251, 2227, 2226, 2217, 2201, 279, 2201, + 2192, 2185, 2182, 2180, 2171, 2158, 2167, 2168, 2145, 2132, + + 2139, 2129, 275, 2107, 0, 0, 3602, 2092, 2093, 264, + 2086, 0, 187, 2092, 2079, 2102, 356, 2069, 2061, 3602, + 3602, 3602, 2083, 300, 0, 3602, 0, 2079, 428, 2047, + 2032, 255, 2005, 1998, 3602, 265, 1997, 822, 368, 3602, + 2041, 3602, 826, 831, 837, 842, 3602, 852, 860, 3602, + 865, 877, 881, 886, 891, 900, 904, 913, 927, 918, + 932, 936, 950, 956, 964, 968, 973, 977, 984, 1002, + 1009, 1016, 1020, 1024, 1036, 1059, 3602, 1031, 0, 1045, + 1063, 1070, 1074, 1079, 1083, 1087, 1091, 1106, 1115, 1123, + 922, 941, 1128, 1140, 3602, 1149, 1162, 3602, 945, 1099, + + 982, 1133, 1144, 1134, 1168, 1169, 1175, 1051, 1180, 1176, + 1185, 1186, 1193, 1192, 1194, 1212, 1221, 1228, 1229, 1230, + 1234, 1235, 1247, 1255, 3602, 1270, 1241, 0, 1279, 1287, + 1295, 1300, 1301, 1305, 1306, 1307, 1313, 1311, 1315, 1321, + 3602, 1357, 1361, 1347, 3602, 0, 2032, 2018, 2020, 2007, + 1998, 2012, 2000, 2001, 1992, 1977, 460, 1976, 1978, 1973, + 1970, 1964, 1961, 1952, 1961, 1956, 1943, 1928, 1940, 1928, + 422, 1365, 3602, 1899, 0, 423, 1899, 1893, 1917, 382, + 1883, 1877, 1342, 1352, 1369, 1376, 3602, 1381, 1386, 1391, + 1395, 3602, 1403, 1906, 1891, 1886, 1878, 1886, 1880, 1875, + + 1870, 1856, 1842, 1833, 1822, 462, 1832, 1822, 1814, 1789, + 1790, 1782, 1778, 1767, 1770, 444, 1750, 1754, 1757, 1733, + 1410, 480, 1726, 1733, 1715, 1711, 1711, 1415, 1419, 1429, + 3602, 1433, 1437, 3602, 1441, 1446, 1423, 1450, 1458, 1463, + 1471, 1482, 1486, 1492, 1498, 1506, 1510, 1521, 1514, 1534, + 1538, 1542, 1548, 1559, 1570, 1576, 1584, 1588, 1594, 1608, + 1599, 1604, 1628, 1633, 1640, 1644, 1648, 1652, 1656, 1662, + 3602, 1667, 1582, 1672, 1620, 1657, 1676, 1680, 1698, 1700, + 1704, 1712, 1714, 1723, 1724, 1729, 1469, 1722, 1736, 1741, + 1743, 1760, 1761, 1765, 1772, 1779, 1784, 1777, 1785, 1813, + + 1821, 1825, 1796, 1808, 1806, 1830, 1831, 1719, 1704, 1695, + 1689, 1699, 1688, 1685, 1695, 1684, 1666, 1668, 1662, 528, + 1669, 1657, 1643, 1634, 1627, 1611, 1611, 1596, 1598, 480, + 1577, 1578, 1576, 1546, 1835, 764, 1537, 1543, 1525, 1522, + 1849, 3602, 1853, 1541, 1543, 1523, 1534, 1521, 1518, 1519, + 1499, 1499, 1499, 1490, 1485, 1486, 1456, 1456, 1461, 1457, + 1452, 1431, 1431, 1430, 1412, 1392, 1378, 1390, 1390, 1381, + 1367, 1328, 1859, 3602, 995, 1325, 1297, 1302, 1451, 1325, + 1865, 3602, 1873, 1877, 3602, 1883, 1887, 1892, 1897, 1906, + 1910, 1916, 1932, 1944, 1948, 1953, 1957, 1961, 1966, 1976, + + 1989, 1993, 2002, 2011, 2015, 2025, 2030, 2036, 2050, 2057, + 2062, 2068, 2074, 2079, 2085, 2096, 2091, 2100, 2108, 2114, + 2119, 1937, 1888, 2120, 2125, 2127, 2142, 2156, 2132, 2168, + 2034, 2169, 2137, 2072, 2173, 2174, 2178, 2180, 2182, 2184, + 2196, 2216, 2218, 2222, 2223, 2224, 2234, 2236, 2240, 2242, + 2258, 2247, 2263, 2268, 2274, 2279, 1315, 1318, 1299, 1307, + 1291, 1284, 1283, 1263, 1268, 1264, 1256, 1257, 1260, 1251, + 1254, 1250, 1254, 1249, 1225, 1227, 1234, 1228, 1220, 1194, + 1211, 1204, 1192, 1181, 1158, 1154, 1164, 1565, 1170, 1166, + 1147, 1149, 1148, 1147, 3602, 1144, 1143, 1128, 1117, 1112, + + 1083, 1083, 282, 1078, 3602, 3602, 1075, 1068, 1085, 1078, + 1053, 1057, 1026, 3602, 1023, 1027, 1004, 3602, 1005, 1003, + 1792, 982, 1003, 2287, 2283, 2297, 2303, 2319, 2323, 2332, + 2337, 2341, 2357, 2361, 2366, 2375, 2346, 2380, 2384, 2389, + 2395, 2402, 2412, 2416, 2427, 2421, 2436, 2448, 2453, 2459, + 2464, 2468, 2472, 2477, 2482, 2491, 2496, 2500, 2504, 2407, + 2473, 2517, 2522, 2355, 2531, 2535, 2543, 2548, 2549, 2557, + 2562, 2567, 2566, 2523, 2571, 2572, 2583, 2584, 2588, 2603, + 2608, 2607, 2619, 2620, 2624, 2626, 2628, 2630, 2635, 2639, + 2643, 997, 1006, 987, 998, 990, 989, 984, 980, 978, + + 952, 951, 921, 913, 490, 904, 897, 883, 899, 895, + 879, 887, 866, 866, 867, 847, 847, 844, 866, 863, + 862, 3602, 3602, 3602, 3602, 3602, 3602, 3602, 3602, 859, + 513, 841, 839, 847, 846, 840, 3602, 3602, 834, 3602, + 826, 836, 820, 787, 791, 756, 3602, 792, 2648, 2675, + 2680, 2671, 2686, 2692, 2696, 2700, 2707, 2712, 2718, 2724, + 2735, 2728, 2739, 2744, 2760, 2771, 2776, 2780, 2784, 2788, + 2792, 2798, 2803, 2820, 2824, 2830, 2835, 2756, 2839, 2840, + 2664, 2752, 2812, 2841, 2848, 2852, 2856, 2858, 2866, 2864, + 2879, 2883, 2884, 2895, 2900, 2906, 2908, 2915, 2919, 2920, + + 2921, 2929, 2934, 2935, 2940, 2947, 782, 781, 779, 778, + 584, 761, 759, 766, 763, 762, 755, 746, 755, 744, + 710, 717, 707, 3602, 3602, 3602, 3602, 726, 729, 718, + 705, 3602, 3602, 3602, 709, 689, 3602, 698, 694, 1893, + 664, 693, 2955, 2961, 2972, 2981, 2987, 2996, 3000, 3004, + 3008, 3016, 3021, 3025, 3036, 3040, 3045, 3059, 3050, 3068, + 3031, 3057, 3063, 3072, 3074, 3076, 3081, 3086, 3082, 3088, + 3094, 3110, 3122, 3123, 3128, 3129, 3130, 3136, 667, 672, + 640, 631, 639, 618, 629, 623, 1972, 589, 602, 593, + 604, 586, 3602, 572, 3602, 535, 2200, 517, 2205, 3142, + + 3146, 3150, 3171, 3182, 3187, 3191, 3196, 3200, 3205, 3209, + 3192, 3210, 3216, 3236, 3227, 3234, 3247, 3252, 3256, 3258, + 3262, 540, 539, 550, 532, 508, 480, 3218, 504, 492, + 3602, 482, 3602, 448, 3602, 3268, 429, 3272, 3281, 3276, + 3290, 3299, 3315, 3319, 3324, 3328, 3333, 3334, 3270, 3335, + 3308, 3344, 3350, 3355, 3356, 444, 427, 424, 375, 3602, + 399, 3602, 365, 3602, 3360, 3382, 3394, 3398, 3405, 3378, + 3399, 3387, 3410, 3414, 393, 354, 3602, 332, 3416, 3421, + 3422, 3426, 260, 231, 3434, 3430, 166, 167, 3448, 3470, + 105, 3602, 3442, 3453, 3602, 3505, 3511, 3517, 3523, 3529, + + 3535, 3541, 3547, 3553, 3559, 3565, 3571, 3577, 3583, 3589, + 55, 3595 } ; -static yyconst flex_int16_t yy_def[1090] = +static yyconst flex_int16_t yy_def[1113] = { 0, - 1072, 1, 1073, 1074, 1075, 1075, 1076, 1076, 1072, 9, - 1072, 11, 1072, 13, 1077, 1077, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1078, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1079, 1072, 1080, 1072, 1072, 1081, - 1080, 1080, 1080, 1082, 1072, 1072, 1082, 1082, 1083, 1072, - 1072, 1084, 1072, 1072, 1072, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 43, 1085, 1084, - - 1084, 1084, 1084, 1084, 1084, 1084, 1086, 1072, 1072, 1072, - 1086, 1086, 1072, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 43, 1087, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1072, 1072, 1072, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1072, 1088, 43, 1088, 1088, 1088, 1088, 1088, - 1089, 1072, 1072, 1072, 1072, 1089, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - - 1072, 1072, 1072, 1072, 43, 1078, 1072, 1072, 1072, 1072, - 1072, 1078, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1080, 1072, 1080, 1072, 1080, 1080, - 1080, 1080, 1082, 1082, 1072, 1082, 1082, 1082, 1083, 1072, - 1072, 1072, 1084, 1084, 1084, 1072, 1072, 1072, 1072, 1072, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1072, 1084, 98, 1085, - 1085, 1085, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1086, 1086, 1086, 1072, 1072, 1072, 1072, 1072, 1086, 1086, - - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1072, 1072, 1086, 133, 1087, 1087, - 1087, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1072, - 1072, 1072, 1072, 1072, 1072, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1072, 1072, 1088, 165, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1089, 1089, 1089, 1072, 1072, 1072, 1072, 1072, - 1089, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1080, 1082, 1082, 1082, - 1072, 1072, 1084, 1072, 1072, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1085, 1084, 1084, 1084, 1084, 1084, 1084, 1086, - 1072, 1072, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1087, - - 1078, 1086, 1086, 1086, 1086, 1086, 1086, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1089, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1080, 1082, - 1072, 1072, 1082, 1072, 1072, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1080, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1080, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1088, 1088, 1088, 1088, 1088, - - 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1080, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1084, 1084, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1086, 1088, 1088, 1088, 1088, 1088, 1088, 1088, - 1088, 1088, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, - 1084, 1084, 1086, 1086, 1086, 1086, 1086, 1086, 1086, 1086, - - 1086, 1086, 1088, 1088, 1088, 1088, 1088, 1088, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1084, 1084, 1084, 1084, - 1084, 1084, 1084, 1084, 1086, 1086, 1086, 1086, 1086, 1086, - 1086, 1086, 1088, 1088, 1088, 1088, 1072, 1072, 1072, 1072, - 1072, 1084, 1084, 1084, 1084, 1084, 1086, 1086, 1086, 1086, - 1086, 1088, 1088, 1072, 1072, 1084, 1084, 1086, 1086, 1088, - 1072, 1084, 1086, 1088, 1072, 1084, 1086, 1088, 1072, 1084, - 1086, 0, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072 + 1095, 1, 1096, 1097, 1098, 1098, 1099, 1099, 1095, 9, + 1095, 11, 1095, 13, 1100, 1100, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1101, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1102, 1095, 1103, 1095, 1095, 1104, + 1103, 1103, 1103, 1105, 1095, 1095, 1105, 1105, 1106, 1095, + 1095, 1107, 1095, 1095, 1095, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 43, 1108, 1107, + + 1107, 1107, 1107, 1107, 1107, 1107, 1109, 1095, 1095, 1095, + 1109, 1109, 1095, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 43, 1110, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1095, 1095, 1095, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1095, 1111, 43, 1111, 1111, 1111, 1111, 1111, + 1112, 1095, 1095, 1095, 1095, 1112, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + + 1095, 1095, 1095, 1095, 43, 1101, 1095, 1095, 1095, 1095, + 1095, 1101, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1103, 1095, 1103, 1095, 1103, 1103, + 1103, 1103, 1105, 1105, 1095, 1105, 1105, 1105, 1106, 1095, + 1095, 1095, 1107, 1107, 1107, 1095, 1095, 1095, 1095, 1095, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1095, 1107, 98, 1108, + 1108, 1108, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1109, 1109, 1109, 1095, 1095, 1095, 1095, 1095, 1109, 1109, + + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1095, 1095, 1109, 133, 1110, 1110, + 1110, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1095, + 1095, 1095, 1095, 1095, 1095, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1095, 1095, 1111, 165, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1112, 1112, 1112, 1095, 1095, 1095, 1095, 1095, + 1112, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1103, 1105, 1105, 1105, + 1095, 1095, 1107, 1095, 1095, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1108, 1107, 1107, 1107, 1107, 1107, 1107, 1109, + 1095, 1095, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1110, + + 1101, 1109, 1109, 1109, 1109, 1109, 1109, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1112, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1103, + 1105, 1095, 1095, 1105, 1095, 1095, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1103, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1103, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + + 1109, 1109, 1109, 1109, 1109, 1109, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, + 1111, 1111, 1111, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1103, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1111, 1111, + 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1107, + + 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, + 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, 1109, + 1109, 1111, 1111, 1111, 1111, 1111, 1111, 1111, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1107, 1107, 1107, + 1107, 1107, 1107, 1107, 1107, 1107, 1109, 1109, 1109, 1109, + 1109, 1109, 1109, 1109, 1109, 1111, 1111, 1111, 1111, 1095, + 1095, 1095, 1095, 1095, 1107, 1107, 1107, 1107, 1107, 1109, + 1109, 1109, 1109, 1109, 1111, 1111, 1095, 1095, 1107, 1107, + 1109, 1109, 1111, 1095, 1107, 1109, 1111, 1095, 1107, 1109, + 1111, 1095, 1107, 1109, 0, 1095, 1095, 1095, 1095, 1095, + + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095 } ; -static yyconst flex_int16_t yy_nxt[3584] = +static yyconst flex_int16_t yy_nxt[3654] = { 0, 18, 19, 20, 21, 19, 18, 22, 23, 24, 23, 25, 26, 18, 27, 28, 29, 18, 30, 18, 18, 31, 18, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 18, 41, 18, 18, 42, 18, 18, 18, 18, + 40, 18, 18, 41, 18, 18, 42, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, - 43, 70, 71, 43, 44, 53, 54, 55, 56, 346, - 45, 52, 58, 59, 60, 61, 65, 66, 65, 66, - 70, 71, 177, 46, 181, 177, 62, 172, 173, 174, - 172, 182, 195, 184, 175, 187, 193, 191, 188, 47, - 185, 48, 189, 49, 200, 190, 50, 51, 192, 196, - - 194, 218, 236, 219, 63, 1069, 201, 237, 67, 176, - 67, 240, 241, 68, 1069, 68, 72, 73, 74, 75, - 73, 72, 76, 77, 78, 77, 79, 80, 72, 81, - 82, 83, 72, 84, 72, 72, 85, 72, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 72, 95, 96, - 72, 97, 72, 72, 72, 72, 72, 72, 72, 72, - 72, 72, 72, 72, 72, 72, 98, 213, 216, 98, - 99, 172, 173, 174, 172, 379, 100, 1068, 175, 349, - 231, 194, 221, 223, 224, 359, 350, 352, 217, 101, - 222, 226, 228, 229, 353, 380, 360, 361, 368, 372, - - 373, 372, 372, 176, 381, 102, 382, 103, 232, 104, - 369, 362, 105, 106, 107, 108, 109, 110, 108, 107, - 111, 112, 113, 112, 114, 115, 107, 116, 117, 118, - 107, 119, 107, 107, 120, 107, 121, 122, 123, 124, - 125, 126, 127, 128, 129, 107, 130, 131, 107, 132, - 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, - 107, 107, 107, 107, 133, 363, 376, 133, 134, 244, - 292, 244, 244, 292, 135, 403, 246, 247, 248, 246, - 362, 355, 364, 177, 356, 1065, 177, 136, 357, 404, - 418, 358, 218, 419, 219, 421, 408, 221, 223, 224, - - 1064, 245, 293, 137, 236, 138, 1061, 139, 249, 237, - 140, 141, 18, 142, 143, 144, 142, 18, 22, 23, - 24, 145, 146, 26, 147, 148, 149, 150, 147, 151, - 147, 147, 152, 147, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 147, 162, 163, 147, 164, 147, 147, - 147, 147, 147, 147, 147, 147, 147, 147, 147, 147, - 18, 18, 165, 240, 241, 165, 44, 248, 250, 248, - 248, 1060, 45, 1054, 244, 292, 244, 244, 292, 244, - 292, 244, 244, 292, 244, 166, 244, 244, 251, 244, - 517, 244, 244, 244, 532, 244, 244, 533, 251, 249, - - 231, 167, 216, 168, 518, 169, 245, 293, 170, 51, - 205, 245, 293, 205, 206, 244, 245, 244, 244, 379, - 207, 245, 217, 292, 1055, 245, 292, 244, 232, 244, - 244, 252, 299, 244, 292, 244, 244, 292, 244, 380, - 244, 244, 1054, 299, 556, 253, 1053, 245, 255, 208, - 1039, 209, 254, 535, 522, 293, 210, 211, 557, 245, - 256, 244, 666, 244, 244, 245, 293, 257, 824, 292, - 245, 244, 292, 244, 244, 244, 667, 244, 244, 901, - 244, 1052, 244, 244, 825, 300, 265, 263, 1037, 574, - 258, 267, 574, 245, 244, 902, 244, 244, 264, 916, - - 266, 293, 244, 245, 244, 244, 964, 245, 268, 1041, - 259, 1040, 245, 260, 1039, 917, 244, 261, 244, 244, - 262, 244, 965, 244, 244, 244, 245, 244, 244, 269, - 244, 1038, 244, 244, 245, 1037, 575, 244, 270, 244, - 244, 274, 1036, 272, 276, 277, 276, 276, 245, 1035, - 271, 1011, 275, 245, 1034, 273, 244, 245, 244, 244, - 1033, 1014, 245, 279, 247, 248, 279, 1013, 281, 245, - 281, 281, 244, 1012, 244, 244, 245, 1011, 244, 1010, - 244, 244, 244, 292, 244, 244, 292, 1009, 245, 283, - 244, 278, 244, 244, 244, 249, 244, 244, 303, 244, - - 282, 244, 244, 266, 245, 1008, 244, 1007, 244, 244, - 245, 226, 228, 229, 245, 293, 978, 286, 294, 295, - 296, 294, 245, 977, 1006, 292, 245, 284, 292, 1005, - 1004, 245, 285, 296, 298, 296, 296, 287, 245, 288, - 292, 289, 292, 292, 1003, 292, 290, 304, 292, 929, - 297, 292, 292, 292, 305, 292, 292, 293, 982, 313, - 301, 292, 979, 292, 292, 297, 292, 302, 307, 306, - 978, 308, 293, 314, 293, 309, 292, 311, 310, 292, - 293, 977, 319, 292, 293, 293, 292, 315, 312, 292, - 317, 292, 292, 293, 292, 293, 292, 292, 292, 292, - - 292, 292, 322, 976, 316, 318, 292, 320, 293, 292, - 330, 323, 212, 330, 975, 293, 974, 212, 973, 321, - 972, 293, 971, 293, 324, 325, 326, 324, 293, 293, - 293, 970, 327, 328, 295, 296, 328, 292, 293, 969, - 292, 292, 331, 292, 292, 924, 292, 292, 332, 292, - 292, 333, 292, 968, 922, 921, 293, 340, 341, 342, - 340, 920, 314, 967, 966, 297, 335, 915, 914, 293, - 913, 384, 912, 293, 384, 293, 929, 928, 927, 293, - 337, 293, 338, 334, 926, 925, 336, 924, 923, 343, - 344, 345, 344, 344, 922, 921, 339, 375, 341, 342, - - 375, 920, 919, 385, 386, 387, 388, 386, 390, 387, - 390, 390, 391, 392, 393, 391, 430, 431, 432, 430, - 918, 244, 343, 244, 244, 244, 915, 244, 244, 343, - 433, 434, 433, 433, 914, 913, 389, 912, 911, 910, - 389, 909, 908, 907, 385, 246, 247, 248, 246, 248, - 247, 248, 248, 245, 832, 906, 830, 245, 435, 277, - 435, 435, 245, 244, 428, 244, 244, 244, 829, 244, - 244, 244, 251, 244, 244, 905, 244, 249, 244, 244, - 904, 249, 437, 244, 903, 244, 244, 900, 292, 436, - 244, 292, 244, 244, 244, 245, 244, 244, 438, 245, - - 899, 440, 244, 245, 244, 244, 821, 820, 245, 439, - 819, 574, 818, 441, 574, 245, 244, 442, 244, 244, - 293, 244, 245, 244, 244, 817, 245, 244, 816, 244, - 244, 443, 815, 244, 245, 244, 244, 292, 445, 244, - 292, 244, 244, 244, 574, 244, 244, 574, 245, 814, - 444, 898, 446, 245, 244, 897, 244, 244, 575, 245, - 447, 448, 896, 839, 244, 245, 244, 244, 449, 293, - 244, 245, 244, 244, 244, 245, 244, 244, 838, 837, - 244, 450, 244, 244, 836, 835, 245, 244, 451, 244, - 244, 575, 244, 452, 244, 244, 245, 834, 455, 454, - - 833, 832, 245, 831, 453, 244, 245, 244, 244, 830, - 829, 456, 245, 244, 828, 244, 244, 827, 826, 245, - 244, 823, 244, 244, 245, 458, 244, 822, 244, 244, - 276, 277, 276, 276, 821, 457, 820, 245, 244, 460, - 244, 244, 461, 459, 281, 245, 281, 281, 281, 819, - 281, 281, 245, 463, 434, 463, 463, 244, 245, 244, - 244, 244, 245, 244, 244, 244, 818, 244, 244, 244, - 245, 244, 244, 817, 462, 244, 282, 244, 244, 244, - 282, 244, 244, 464, 450, 282, 467, 816, 244, 245, - 244, 244, 286, 245, 465, 815, 244, 245, 244, 244, - - 466, 245, 470, 471, 472, 470, 814, 245, 813, 812, - 811, 245, 287, 294, 295, 296, 294, 810, 468, 809, - 245, 296, 295, 296, 296, 808, 292, 807, 245, 292, - 292, 806, 469, 292, 293, 326, 325, 326, 326, 299, - 292, 292, 709, 292, 292, 297, 805, 292, 473, 292, - 292, 474, 292, 297, 292, 804, 292, 292, 293, 292, - 803, 292, 293, 475, 292, 477, 478, 292, 802, 801, - 292, 479, 293, 293, 292, 476, 480, 292, 800, 293, - 292, 293, 292, 292, 292, 292, 293, 292, 293, 702, - 701, 482, 292, 293, 292, 292, 481, 292, 799, 293, - - 292, 484, 798, 292, 485, 483, 293, 292, 292, 486, - 292, 292, 293, 797, 293, 796, 293, 292, 488, 487, - 292, 795, 292, 489, 293, 292, 293, 491, 492, 794, - 292, 292, 293, 292, 292, 292, 793, 490, 292, 293, - 293, 493, 292, 495, 292, 292, 792, 292, 791, 293, - 691, 790, 496, 789, 293, 324, 325, 326, 324, 788, - 494, 497, 293, 293, 498, 787, 786, 293, 326, 325, - 326, 326, 785, 718, 293, 330, 293, 212, 330, 715, - 499, 330, 212, 212, 330, 714, 713, 293, 212, 500, - 471, 501, 500, 712, 711, 292, 212, 292, 292, 292, - - 292, 292, 292, 292, 292, 292, 292, 331, 292, 710, - 709, 292, 505, 331, 292, 292, 708, 707, 292, 706, - 705, 331, 384, 502, 487, 384, 335, 293, 503, 293, - 704, 293, 703, 293, 504, 293, 702, 293, 340, 341, - 342, 340, 384, 293, 506, 384, 336, 293, 344, 341, - 344, 344, 701, 700, 385, 507, 372, 373, 372, 372, - 344, 699, 344, 344, 372, 373, 372, 372, 698, 390, - 343, 390, 390, 697, 385, 541, 542, 543, 541, 696, - 343, 386, 387, 388, 386, 390, 387, 390, 390, 695, - 694, 693, 343, 393, 392, 393, 393, 391, 392, 393, - - 391, 389, 393, 392, 393, 393, 692, 385, 572, 573, - 572, 572, 691, 389, 690, 689, 688, 389, 580, 581, - 582, 580, 583, 584, 585, 583, 687, 686, 685, 385, - 430, 431, 432, 430, 432, 431, 432, 432, 684, 433, - 434, 433, 433, 435, 277, 435, 435, 244, 683, 244, - 244, 244, 535, 244, 244, 682, 681, 244, 586, 244, - 244, 244, 680, 244, 244, 244, 428, 244, 244, 679, - 428, 245, 678, 677, 244, 587, 244, 244, 234, 245, - 676, 292, 588, 245, 292, 675, 674, 591, 673, 245, - 589, 590, 244, 245, 244, 244, 244, 245, 244, 244, - - 672, 244, 671, 244, 244, 621, 245, 593, 244, 716, - 244, 244, 716, 293, 670, 592, 594, 244, 669, 244, - 244, 668, 665, 244, 245, 244, 244, 244, 245, 244, - 244, 664, 244, 245, 244, 244, 595, 663, 598, 292, - 245, 596, 292, 662, 244, 600, 244, 244, 597, 245, - 620, 244, 599, 244, 244, 245, 717, 661, 244, 245, - 244, 244, 660, 659, 245, 601, 244, 658, 244, 244, - 657, 293, 244, 603, 244, 244, 245, 716, 604, 602, - 716, 656, 244, 245, 244, 244, 244, 605, 244, 244, - 245, 244, 655, 244, 244, 606, 654, 244, 245, 244, - - 244, 579, 578, 244, 245, 244, 244, 608, 607, 244, - 577, 244, 244, 244, 245, 244, 244, 244, 245, 244, - 244, 421, 576, 245, 717, 609, 611, 571, 570, 245, - 612, 610, 569, 568, 567, 245, 463, 434, 463, 463, - 615, 245, 244, 615, 716, 245, 613, 716, 566, 245, - 614, 573, 614, 614, 244, 565, 244, 244, 244, 564, - 244, 244, 244, 292, 244, 244, 292, 244, 282, 244, - 244, 563, 245, 470, 471, 472, 470, 472, 471, 472, - 472, 562, 245, 561, 464, 560, 245, 616, 622, 292, - 245, 717, 292, 617, 245, 293, 559, 558, 292, 245, - - 618, 292, 555, 292, 554, 293, 292, 619, 292, 292, - 553, 292, 292, 292, 292, 624, 292, 292, 623, 292, - 627, 293, 292, 292, 292, 625, 292, 292, 628, 292, - 293, 626, 292, 292, 552, 293, 292, 634, 551, 550, - 293, 293, 629, 630, 632, 293, 293, 549, 631, 292, - 635, 293, 292, 548, 292, 293, 293, 292, 633, 292, - 292, 293, 292, 292, 547, 293, 546, 292, 545, 637, - 292, 638, 544, 292, 540, 639, 292, 636, 539, 538, - 640, 293, 292, 537, 292, 292, 293, 292, 536, 534, - 292, 293, 293, 292, 292, 641, 531, 292, 642, 293, - - 292, 292, 530, 292, 292, 293, 501, 471, 501, 501, - 529, 645, 643, 646, 293, 528, 293, 649, 644, 527, - 649, 526, 293, 525, 292, 524, 293, 292, 500, 471, - 501, 500, 293, 293, 647, 212, 648, 573, 572, 648, - 292, 292, 292, 292, 292, 292, 523, 522, 521, 293, - 572, 573, 572, 572, 520, 519, 293, 516, 515, 514, - 331, 513, 980, 651, 650, 980, 502, 980, 293, 512, - 980, 511, 293, 293, 293, 541, 542, 543, 541, 652, - 510, 509, 653, 543, 542, 543, 543, 572, 573, 572, - 572, 580, 581, 582, 580, 582, 581, 582, 582, 583, - - 584, 585, 583, 585, 584, 585, 585, 385, 244, 981, - 244, 244, 508, 244, 981, 244, 244, 347, 244, 240, - 244, 244, 429, 428, 980, 719, 720, 980, 244, 1015, - 244, 244, 1015, 244, 234, 244, 244, 230, 427, 234, - 245, 244, 226, 244, 244, 245, 722, 234, 721, 244, - 245, 244, 244, 221, 426, 244, 724, 244, 244, 725, - 245, 723, 425, 424, 423, 245, 244, 422, 244, 244, - 220, 981, 244, 245, 244, 244, 1016, 244, 215, 244, - 244, 245, 214, 244, 726, 244, 244, 245, 244, 727, - 244, 244, 244, 728, 244, 244, 292, 420, 245, 292, - - 731, 417, 416, 415, 245, 729, 414, 413, 244, 245, - 244, 244, 412, 752, 730, 245, 244, 732, 244, 244, - 245, 411, 410, 244, 245, 244, 244, 409, 293, 733, - 408, 734, 244, 735, 244, 244, 244, 407, 244, 244, - 245, 244, 736, 244, 244, 406, 405, 244, 245, 244, - 244, 244, 402, 244, 244, 245, 244, 401, 244, 244, - 738, 400, 739, 399, 245, 398, 740, 397, 245, 737, - 396, 395, 741, 245, 244, 394, 244, 244, 244, 245, - 244, 244, 244, 245, 244, 244, 179, 244, 245, 244, - 244, 244, 743, 244, 244, 378, 744, 614, 573, 614, - - 614, 377, 615, 742, 244, 615, 245, 374, 292, 371, - 245, 292, 745, 244, 245, 244, 244, 370, 244, 245, - 244, 244, 244, 245, 244, 244, 755, 367, 366, 245, - 750, 365, 244, 750, 245, 292, 746, 354, 292, 292, - 293, 351, 292, 292, 292, 245, 292, 292, 753, 616, - 245, 348, 292, 347, 245, 292, 749, 347, 757, 242, - 747, 292, 245, 748, 292, 292, 238, 293, 292, 754, - 292, 293, 756, 292, 235, 293, 293, 751, 234, 230, - 758, 759, 761, 292, 293, 226, 292, 292, 760, 292, - 292, 292, 292, 293, 292, 292, 292, 293, 292, 292, - - 221, 220, 293, 215, 292, 292, 764, 292, 292, 292, - 767, 762, 292, 763, 768, 293, 765, 766, 214, 293, - 204, 293, 292, 293, 772, 292, 292, 293, 293, 292, - 203, 292, 769, 770, 292, 292, 293, 293, 292, 292, - 292, 293, 292, 292, 292, 292, 773, 292, 292, 292, - 771, 774, 292, 202, 293, 776, 649, 292, 293, 649, - 292, 292, 777, 293, 292, 778, 292, 293, 775, 292, - 783, 293, 293, 783, 199, 1015, 293, 293, 1015, 198, - 197, 293, 648, 573, 572, 648, 186, 292, 293, 293, - 292, 183, 180, 293, 779, 179, 1015, 871, 293, 1015, - - 782, 179, 293, 650, 780, 244, 781, 244, 244, 244, - 178, 244, 244, 244, 293, 244, 244, 784, 244, 293, - 244, 244, 1016, 244, 841, 244, 244, 1072, 843, 244, - 1072, 244, 244, 840, 1072, 1072, 1072, 245, 1072, 844, - 842, 245, 1072, 1016, 244, 245, 244, 244, 1072, 244, - 245, 244, 244, 1072, 845, 245, 1072, 1072, 1072, 846, - 244, 245, 244, 244, 244, 1072, 244, 244, 1072, 244, - 847, 244, 244, 1072, 848, 244, 245, 244, 244, 849, - 244, 245, 244, 244, 244, 850, 244, 244, 1072, 1072, - 1072, 244, 245, 244, 244, 244, 245, 244, 244, 1072, - - 244, 245, 244, 244, 853, 1072, 1072, 245, 851, 1072, - 1072, 852, 245, 1072, 1072, 244, 245, 244, 244, 1072, - 854, 292, 855, 245, 292, 1072, 244, 245, 244, 244, - 1072, 244, 245, 244, 244, 244, 869, 244, 244, 244, - 292, 244, 244, 292, 1072, 858, 1072, 245, 244, 859, - 244, 244, 1072, 293, 244, 856, 244, 244, 245, 244, - 857, 244, 244, 245, 861, 1072, 244, 245, 244, 244, - 860, 245, 293, 244, 1072, 244, 244, 1072, 1072, 244, - 245, 244, 244, 1072, 1072, 244, 245, 244, 244, 1072, - 244, 245, 244, 244, 1072, 862, 863, 244, 245, 244, - - 244, 750, 1072, 244, 750, 245, 244, 292, 244, 244, - 292, 245, 1072, 292, 1072, 1072, 292, 245, 864, 1072, - 1072, 1072, 245, 1072, 865, 1072, 1072, 1072, 1072, 245, - 866, 292, 1072, 245, 292, 868, 1072, 1072, 245, 293, - 870, 872, 1072, 1072, 292, 293, 292, 292, 751, 292, - 1072, 1072, 292, 867, 873, 292, 874, 292, 292, 1072, - 292, 292, 875, 293, 1072, 1072, 1072, 876, 877, 292, - 292, 292, 292, 292, 292, 1072, 293, 292, 293, 878, - 292, 1072, 292, 292, 293, 292, 292, 1072, 292, 293, - 293, 292, 1072, 292, 292, 881, 292, 292, 879, 1072, - - 1072, 293, 293, 293, 880, 292, 1072, 1072, 292, 293, - 883, 882, 1072, 292, 293, 293, 292, 1072, 292, 1072, - 293, 292, 884, 885, 292, 293, 293, 292, 886, 292, - 292, 1072, 292, 292, 887, 888, 1072, 293, 292, 889, - 292, 292, 1072, 292, 292, 293, 292, 292, 1072, 292, - 293, 292, 1072, 1072, 292, 783, 293, 292, 783, 890, - 292, 293, 293, 891, 244, 1072, 244, 244, 1072, 1072, - 293, 1072, 293, 1072, 930, 1072, 293, 892, 293, 244, - 893, 244, 244, 293, 894, 1072, 1072, 293, 244, 293, - 244, 244, 244, 1072, 244, 244, 245, 244, 931, 244, - - 244, 1072, 784, 244, 895, 244, 244, 932, 1072, 1072, - 244, 245, 244, 244, 244, 1072, 244, 244, 1072, 244, - 245, 244, 244, 244, 245, 244, 244, 1072, 244, 245, - 244, 244, 1072, 1072, 244, 245, 244, 244, 244, 1072, - 244, 244, 245, 1072, 933, 244, 245, 244, 244, 1072, - 244, 245, 244, 244, 244, 245, 244, 244, 934, 244, - 245, 244, 244, 936, 938, 244, 245, 244, 244, 937, - 245, 1072, 1072, 292, 935, 939, 292, 245, 244, 1072, - 244, 244, 245, 947, 1072, 1072, 245, 244, 940, 244, - 244, 245, 244, 1072, 244, 244, 244, 245, 244, 244, - - 1072, 244, 1072, 244, 244, 293, 244, 941, 244, 244, - 245, 942, 244, 292, 244, 244, 292, 1072, 1072, 245, - 244, 943, 244, 244, 245, 1072, 1072, 244, 245, 244, - 244, 1072, 244, 245, 244, 244, 292, 292, 245, 292, - 292, 1072, 1072, 1072, 245, 293, 948, 949, 292, 1072, - 292, 292, 245, 292, 292, 945, 944, 292, 292, 245, - 292, 292, 292, 292, 245, 292, 1072, 292, 293, 293, - 292, 946, 292, 292, 292, 292, 292, 292, 292, 1072, - 293, 292, 293, 950, 292, 951, 293, 292, 292, 1072, - 293, 292, 293, 954, 293, 1072, 1072, 292, 955, 293, - - 292, 952, 1072, 953, 293, 293, 293, 956, 292, 292, - 293, 292, 292, 1072, 292, 1072, 293, 292, 957, 292, - 293, 292, 292, 292, 292, 292, 292, 292, 292, 293, - 292, 959, 292, 292, 958, 292, 292, 1072, 960, 1072, - 293, 293, 244, 1072, 244, 244, 293, 244, 1072, 244, - 244, 293, 1072, 293, 1072, 293, 1072, 293, 244, 293, - 244, 244, 962, 1072, 293, 293, 1072, 1072, 244, 961, - 244, 244, 1072, 1072, 245, 1072, 963, 1072, 244, 245, - 244, 244, 244, 1072, 244, 244, 244, 1072, 244, 244, - 245, 244, 1072, 244, 244, 244, 1072, 244, 244, 1072, - - 245, 984, 244, 983, 244, 244, 1072, 1072, 985, 244, - 245, 244, 244, 986, 245, 1072, 1072, 292, 245, 244, - 292, 244, 244, 245, 1072, 1072, 1072, 245, 244, 987, - 244, 244, 1072, 244, 245, 244, 244, 244, 1072, 244, - 244, 245, 1072, 988, 990, 989, 244, 990, 1072, 293, - 244, 245, 244, 244, 292, 292, 292, 292, 292, 292, - 245, 1072, 1072, 292, 292, 245, 292, 292, 1072, 245, - 292, 292, 292, 292, 292, 292, 245, 292, 292, 1072, - 292, 292, 245, 1072, 1072, 992, 293, 293, 293, 993, - 994, 991, 995, 1072, 996, 293, 293, 292, 292, 1072, - - 292, 292, 293, 293, 293, 292, 1072, 997, 292, 293, - 293, 292, 1072, 1000, 292, 998, 1000, 292, 1072, 999, - 292, 1072, 244, 1072, 244, 244, 1072, 1072, 1072, 293, - 293, 244, 1072, 244, 244, 1072, 244, 293, 244, 244, - 1072, 1072, 1072, 293, 1017, 293, 1019, 1072, 244, 293, - 244, 244, 1002, 1018, 245, 244, 1072, 244, 244, 244, - 1001, 244, 244, 245, 244, 1072, 244, 244, 245, 990, - 1020, 244, 990, 244, 292, 244, 244, 292, 1072, 1023, - 245, 244, 1023, 1072, 1027, 292, 292, 245, 292, 292, - 292, 245, 292, 292, 1072, 292, 245, 292, 1021, 292, - - 292, 245, 292, 1072, 1072, 245, 293, 1025, 1026, 1072, - 1000, 245, 1028, 1000, 1072, 1072, 991, 293, 293, 1072, - 1022, 1072, 293, 1072, 293, 1072, 1024, 292, 1072, 293, - 292, 293, 1031, 1029, 244, 1031, 244, 244, 244, 1072, - 244, 244, 293, 244, 1042, 244, 244, 1072, 244, 1072, - 244, 244, 244, 1043, 244, 244, 1072, 1001, 1044, 293, - 244, 1072, 244, 244, 293, 1023, 245, 244, 1023, 244, - 245, 244, 244, 292, 1030, 245, 292, 1072, 292, 1032, - 245, 292, 292, 1047, 245, 292, 292, 1045, 292, 292, - 1072, 292, 245, 1048, 1072, 292, 1049, 245, 292, 1031, - - 292, 245, 1031, 292, 244, 293, 244, 244, 292, 1072, - 293, 292, 1024, 1072, 293, 1072, 1046, 1072, 293, 244, - 293, 244, 244, 1050, 1072, 292, 1072, 293, 292, 1056, - 292, 293, 293, 292, 1072, 244, 245, 244, 244, 244, - 293, 244, 244, 1072, 1072, 292, 1032, 1051, 292, 1072, - 244, 245, 244, 244, 1072, 1058, 292, 293, 244, 292, - 244, 244, 293, 244, 1072, 244, 244, 245, 1072, 292, - 292, 245, 292, 292, 1072, 1072, 244, 293, 244, 244, - 1057, 1072, 245, 292, 292, 1072, 292, 292, 293, 244, - 245, 244, 244, 292, 1071, 245, 292, 1059, 1072, 1070, - - 1072, 293, 293, 244, 1072, 244, 244, 1062, 245, 1072, - 1072, 1072, 1072, 1066, 1063, 293, 293, 1072, 1072, 1072, - 1067, 245, 1072, 1072, 1072, 293, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 245, 52, 52, 52, 52, - 52, 52, 57, 57, 57, 57, 57, 57, 64, 64, - 64, 64, 64, 64, 69, 69, 69, 69, 69, 69, - 171, 171, 171, 171, 171, 171, 212, 212, 1072, 212, - 212, 212, 222, 222, 222, 222, 222, 222, 225, 1072, - 1072, 1072, 225, 225, 227, 227, 227, 227, 227, 227, - 233, 233, 1072, 1072, 233, 233, 239, 239, 239, 239, - - 239, 239, 243, 243, 1072, 243, 243, 243, 280, 280, - 1072, 280, 280, 280, 291, 291, 1072, 1072, 1072, 291, - 329, 329, 1072, 329, 329, 329, 383, 383, 1072, 1072, - 1072, 383, 17, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072 + 18, 43, 70, 71, 43, 44, 53, 54, 55, 56, + 346, 45, 52, 58, 59, 60, 61, 65, 66, 65, + 66, 70, 71, 177, 46, 181, 177, 62, 172, 173, + 174, 172, 182, 184, 200, 175, 195, 216, 193, 191, + 185, 47, 379, 48, 187, 49, 201, 188, 50, 51, + + 192, 189, 194, 196, 190, 218, 63, 219, 217, 236, + 67, 176, 67, 380, 237, 68, 1092, 68, 72, 73, + 74, 75, 73, 72, 76, 77, 78, 77, 79, 80, + 72, 81, 82, 83, 72, 84, 72, 72, 85, 72, + 86, 87, 88, 89, 90, 91, 92, 93, 94, 72, + 72, 95, 96, 72, 97, 72, 72, 72, 72, 72, + 72, 72, 72, 72, 72, 72, 72, 72, 72, 98, + 213, 231, 98, 99, 172, 173, 174, 172, 1092, 100, + 363, 175, 240, 241, 194, 221, 223, 224, 222, 226, + 228, 229, 101, 359, 349, 352, 355, 364, 361, 356, + + 232, 350, 353, 357, 360, 1091, 358, 176, 381, 102, + 382, 103, 362, 104, 421, 408, 105, 106, 107, 108, + 109, 110, 108, 107, 111, 112, 113, 112, 114, 115, + 107, 116, 117, 118, 107, 119, 107, 107, 120, 107, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 107, + 107, 130, 131, 107, 132, 107, 107, 107, 107, 107, + 107, 107, 107, 107, 107, 107, 107, 107, 107, 133, + 1088, 231, 133, 134, 244, 292, 244, 244, 292, 135, + 376, 246, 247, 248, 246, 368, 372, 373, 372, 372, + 177, 403, 136, 177, 362, 418, 832, 369, 419, 218, + + 232, 219, 221, 223, 224, 404, 1087, 245, 293, 137, + 236, 138, 833, 139, 249, 237, 140, 141, 18, 142, + 143, 144, 142, 18, 22, 23, 24, 145, 146, 26, + 147, 148, 149, 150, 147, 151, 147, 147, 152, 147, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 147, + 147, 162, 163, 147, 164, 147, 147, 147, 147, 147, + 147, 147, 147, 147, 147, 147, 147, 18, 18, 165, + 240, 241, 165, 44, 248, 250, 248, 248, 1084, 45, + 216, 244, 292, 244, 244, 292, 244, 292, 244, 244, + 292, 244, 166, 244, 244, 251, 244, 1083, 244, 244, + + 244, 217, 244, 244, 1077, 251, 379, 249, 1078, 167, + 1077, 168, 1076, 169, 245, 293, 170, 51, 205, 245, + 293, 205, 206, 244, 245, 244, 244, 380, 207, 245, + 226, 228, 229, 245, 244, 1062, 244, 244, 244, 252, + 244, 244, 532, 1075, 292, 533, 244, 292, 244, 244, + 535, 522, 253, 255, 292, 1060, 245, 292, 208, 254, + 209, 244, 301, 244, 244, 210, 211, 245, 256, 302, + 300, 245, 517, 567, 556, 257, 568, 293, 1064, 245, + 244, 575, 244, 244, 575, 1063, 518, 293, 557, 244, + 258, 244, 244, 1062, 245, 244, 263, 244, 244, 244, + + 267, 244, 244, 244, 912, 244, 244, 264, 1061, 680, + 265, 259, 681, 245, 260, 1060, 1059, 268, 261, 1033, + 913, 262, 245, 244, 266, 244, 244, 928, 245, 576, + 269, 244, 245, 244, 244, 244, 245, 244, 244, 244, + 669, 244, 244, 929, 244, 270, 244, 244, 1058, 244, + 274, 244, 244, 272, 670, 281, 245, 281, 281, 275, + 271, 1031, 1057, 1056, 245, 273, 1035, 244, 245, 244, + 244, 1034, 245, 276, 277, 276, 276, 245, 279, 247, + 248, 279, 245, 1033, 244, 278, 244, 244, 282, 244, + 292, 244, 244, 292, 244, 283, 244, 244, 979, 299, + + 245, 244, 1032, 244, 244, 244, 245, 244, 244, 266, + 244, 249, 244, 244, 980, 1031, 1030, 245, 294, 295, + 296, 294, 245, 293, 286, 1029, 1028, 245, 296, 298, + 296, 296, 1027, 292, 245, 284, 292, 285, 245, 288, + 995, 289, 299, 245, 292, 287, 292, 292, 1026, 292, + 993, 297, 292, 292, 1025, 292, 292, 292, 290, 303, + 292, 297, 292, 1024, 322, 292, 293, 292, 304, 292, + 292, 292, 292, 307, 292, 305, 308, 293, 311, 293, + 309, 306, 313, 310, 292, 293, 293, 292, 292, 312, + 293, 292, 1023, 1022, 317, 293, 314, 942, 319, 315, + + 293, 999, 293, 996, 293, 292, 318, 292, 292, 995, + 292, 324, 325, 326, 324, 292, 316, 293, 292, 994, + 993, 293, 323, 320, 328, 295, 296, 328, 992, 330, + 292, 212, 330, 292, 292, 321, 212, 292, 293, 292, + 293, 991, 292, 292, 293, 332, 292, 292, 293, 990, + 292, 327, 989, 988, 987, 292, 986, 297, 292, 314, + 985, 292, 331, 293, 292, 575, 937, 293, 575, 984, + 335, 983, 293, 934, 933, 384, 293, 932, 384, 982, + 293, 340, 341, 342, 340, 333, 334, 981, 293, 927, + 926, 336, 925, 924, 293, 337, 942, 338, 344, 345, + + 344, 344, 941, 339, 375, 341, 342, 375, 385, 386, + 387, 388, 386, 576, 343, 390, 387, 390, 390, 391, + 392, 393, 391, 430, 431, 432, 430, 244, 940, 244, + 244, 343, 244, 939, 244, 244, 938, 343, 433, 434, + 433, 433, 389, 246, 247, 248, 246, 937, 389, 936, + 935, 934, 385, 248, 247, 248, 248, 933, 932, 931, + 245, 435, 277, 435, 435, 245, 244, 930, 244, 244, + 927, 245, 428, 926, 925, 251, 249, 924, 244, 923, + 244, 244, 244, 922, 244, 244, 249, 244, 921, 244, + 244, 920, 244, 437, 244, 244, 919, 918, 840, 245, + + 436, 244, 917, 244, 244, 244, 838, 244, 244, 438, + 837, 245, 440, 916, 244, 245, 244, 244, 439, 244, + 245, 244, 244, 292, 441, 245, 292, 915, 244, 442, + 244, 244, 914, 244, 245, 244, 244, 244, 245, 244, + 244, 911, 292, 443, 445, 292, 292, 245, 444, 292, + 910, 244, 245, 244, 244, 299, 293, 244, 446, 244, + 244, 245, 829, 828, 447, 244, 245, 244, 244, 244, + 245, 244, 244, 448, 244, 293, 244, 244, 244, 293, + 244, 244, 449, 292, 245, 244, 292, 244, 244, 827, + 245, 826, 450, 451, 474, 825, 575, 452, 245, 575, + + 824, 823, 245, 244, 454, 244, 244, 245, 453, 822, + 244, 245, 244, 244, 455, 909, 293, 244, 245, 244, + 244, 244, 908, 244, 244, 244, 907, 244, 244, 456, + 848, 847, 244, 458, 244, 244, 245, 244, 846, 244, + 244, 845, 459, 245, 576, 844, 281, 457, 281, 281, + 245, 843, 292, 842, 245, 292, 460, 841, 245, 461, + 276, 277, 276, 276, 281, 245, 281, 281, 840, 462, + 245, 463, 434, 463, 463, 244, 839, 244, 244, 282, + 244, 481, 244, 244, 244, 293, 244, 244, 244, 838, + 244, 244, 244, 245, 244, 244, 837, 282, 836, 467, + + 292, 464, 450, 292, 282, 835, 834, 244, 245, 244, + 244, 831, 830, 245, 465, 286, 244, 245, 244, 244, + 466, 245, 473, 829, 244, 245, 244, 244, 828, 470, + 471, 472, 470, 293, 292, 292, 287, 292, 292, 827, + 245, 294, 295, 296, 294, 292, 477, 468, 292, 245, + 296, 295, 296, 296, 826, 825, 475, 245, 824, 823, + 822, 469, 293, 326, 325, 326, 326, 293, 293, 292, + 292, 476, 292, 292, 297, 821, 292, 292, 293, 292, + 292, 292, 820, 297, 292, 479, 292, 292, 478, 292, + 292, 480, 482, 292, 292, 292, 292, 292, 292, 819, + + 818, 817, 293, 293, 484, 816, 483, 815, 485, 293, + 293, 814, 486, 292, 293, 714, 292, 488, 489, 293, + 293, 487, 292, 813, 812, 292, 293, 293, 293, 292, + 292, 292, 292, 292, 292, 292, 292, 811, 292, 292, + 492, 491, 292, 490, 810, 292, 293, 495, 292, 493, + 809, 292, 808, 496, 807, 293, 324, 325, 326, 324, + 706, 494, 293, 293, 293, 705, 806, 497, 293, 293, + 498, 326, 325, 326, 326, 293, 805, 804, 803, 499, + 330, 293, 212, 330, 802, 801, 800, 212, 330, 293, + 212, 330, 799, 798, 695, 212, 500, 471, 501, 500, + + 797, 292, 292, 212, 292, 292, 292, 292, 292, 292, + 292, 292, 292, 331, 292, 292, 292, 292, 505, 292, + 796, 331, 340, 341, 342, 340, 795, 502, 487, 331, + 794, 335, 793, 792, 293, 293, 503, 723, 720, 293, + 293, 293, 504, 384, 719, 293, 384, 293, 344, 293, + 344, 344, 336, 384, 506, 343, 384, 507, 344, 341, + 344, 344, 372, 373, 372, 372, 372, 373, 372, 372, + 541, 542, 543, 541, 718, 717, 385, 386, 387, 388, + 386, 343, 390, 387, 390, 390, 385, 393, 392, 393, + 393, 343, 390, 716, 390, 390, 391, 392, 393, 391, + + 715, 714, 713, 385, 393, 392, 393, 393, 712, 711, + 389, 573, 574, 573, 573, 389, 581, 582, 583, 581, + 584, 585, 586, 584, 244, 389, 244, 244, 710, 385, + 430, 431, 432, 430, 432, 431, 432, 432, 433, 434, + 433, 433, 435, 277, 435, 435, 709, 244, 588, 244, + 244, 244, 721, 244, 244, 721, 708, 245, 587, 244, + 707, 244, 244, 706, 244, 428, 244, 244, 705, 428, + 292, 245, 244, 292, 244, 244, 589, 704, 703, 234, + 245, 591, 702, 244, 245, 244, 244, 244, 590, 244, + 244, 637, 245, 244, 592, 244, 244, 245, 594, 244, + + 722, 244, 244, 293, 701, 245, 593, 244, 595, 244, + 244, 244, 700, 244, 244, 244, 245, 244, 244, 699, + 245, 698, 244, 697, 244, 244, 245, 596, 601, 696, + 695, 597, 245, 599, 694, 244, 598, 244, 244, 244, + 245, 244, 244, 244, 245, 244, 244, 600, 245, 244, + 693, 244, 244, 692, 691, 245, 602, 690, 604, 689, + 244, 605, 244, 244, 688, 687, 721, 603, 245, 721, + 535, 244, 245, 244, 244, 606, 245, 244, 686, 244, + 244, 685, 245, 292, 607, 244, 292, 244, 244, 244, + 684, 244, 244, 245, 622, 244, 683, 244, 244, 608, + + 244, 609, 244, 244, 245, 244, 682, 244, 244, 244, + 245, 244, 244, 614, 722, 679, 293, 610, 245, 678, + 611, 292, 245, 612, 292, 677, 613, 676, 245, 463, + 434, 463, 463, 245, 616, 574, 616, 616, 245, 615, + 675, 617, 245, 244, 617, 244, 624, 244, 244, 244, + 674, 244, 244, 244, 293, 244, 244, 244, 292, 244, + 244, 292, 282, 470, 471, 472, 470, 245, 472, 471, + 472, 472, 673, 292, 245, 464, 292, 292, 245, 672, + 292, 292, 245, 671, 292, 619, 245, 625, 668, 618, + 245, 293, 620, 667, 626, 666, 293, 623, 621, 292, + + 665, 292, 292, 627, 292, 292, 293, 664, 292, 663, + 293, 662, 629, 292, 293, 292, 292, 661, 292, 660, + 630, 659, 628, 292, 292, 292, 292, 292, 292, 658, + 292, 657, 293, 292, 293, 580, 634, 292, 293, 632, + 292, 631, 292, 636, 292, 292, 293, 292, 293, 633, + 635, 638, 639, 579, 640, 578, 293, 293, 293, 641, + 421, 292, 292, 293, 292, 292, 292, 577, 572, 292, + 293, 571, 570, 292, 642, 293, 292, 293, 292, 569, + 292, 292, 644, 292, 643, 292, 292, 566, 292, 292, + 565, 649, 564, 721, 293, 293, 721, 652, 563, 293, + + 652, 645, 648, 562, 646, 561, 293, 292, 647, 292, + 292, 293, 292, 293, 500, 471, 501, 500, 293, 293, + 650, 212, 501, 471, 501, 501, 651, 574, 573, 651, + 293, 292, 292, 502, 292, 292, 573, 574, 573, 573, + 293, 722, 293, 560, 559, 653, 558, 331, 555, 654, + 541, 542, 543, 541, 543, 542, 543, 543, 554, 293, + 573, 574, 573, 573, 293, 293, 581, 582, 583, 581, + 655, 553, 552, 656, 583, 582, 583, 583, 584, 585, + 586, 584, 551, 385, 586, 585, 586, 586, 244, 292, + 244, 244, 292, 244, 997, 244, 244, 997, 244, 550, + + 244, 244, 759, 549, 548, 724, 725, 244, 547, 244, + 244, 244, 546, 244, 244, 234, 545, 244, 544, 244, + 244, 245, 293, 540, 539, 727, 245, 234, 726, 538, + 537, 245, 729, 244, 536, 244, 244, 534, 292, 728, + 245, 292, 998, 730, 245, 244, 531, 244, 244, 244, + 245, 244, 244, 530, 244, 758, 244, 244, 244, 529, + 244, 244, 244, 528, 244, 244, 245, 244, 527, 244, + 244, 293, 732, 997, 731, 733, 997, 244, 245, 244, + 244, 526, 245, 525, 736, 524, 734, 245, 735, 523, + 244, 245, 244, 244, 244, 245, 244, 244, 522, 521, + + 245, 520, 737, 244, 519, 244, 244, 516, 515, 739, + 245, 738, 244, 740, 244, 244, 244, 514, 244, 244, + 513, 998, 741, 245, 512, 511, 244, 245, 244, 244, + 510, 244, 509, 244, 244, 292, 245, 244, 292, 244, + 244, 508, 347, 240, 742, 245, 744, 429, 428, 245, + 743, 244, 745, 244, 244, 234, 767, 230, 244, 245, + 244, 244, 427, 244, 245, 244, 244, 746, 293, 244, + 245, 244, 244, 292, 748, 244, 292, 244, 244, 749, + 244, 226, 244, 244, 245, 221, 244, 747, 244, 244, + 770, 245, 617, 750, 244, 617, 245, 616, 574, 616, + + 616, 244, 245, 244, 244, 751, 293, 426, 245, 244, + 425, 244, 244, 245, 424, 244, 423, 244, 244, 245, + 756, 292, 244, 756, 292, 245, 292, 422, 292, 292, + 245, 292, 752, 292, 245, 220, 292, 215, 292, 214, + 618, 292, 245, 292, 761, 420, 292, 417, 245, 753, + 755, 760, 416, 245, 293, 754, 762, 292, 763, 293, + 292, 293, 765, 415, 769, 414, 293, 764, 757, 292, + 292, 293, 292, 292, 292, 292, 293, 292, 292, 292, + 413, 292, 292, 292, 292, 292, 292, 412, 292, 411, + 293, 774, 766, 775, 773, 410, 772, 292, 768, 771, + + 292, 997, 293, 293, 997, 409, 1036, 293, 293, 1036, + 408, 407, 293, 776, 293, 406, 293, 292, 293, 292, + 292, 777, 292, 292, 292, 292, 292, 292, 292, 405, + 293, 402, 778, 401, 779, 292, 782, 292, 292, 780, + 292, 292, 400, 292, 292, 783, 292, 399, 652, 998, + 293, 652, 293, 781, 1037, 784, 293, 293, 293, 651, + 574, 573, 651, 398, 292, 397, 785, 292, 293, 292, + 293, 396, 292, 395, 293, 292, 293, 394, 292, 179, + 790, 293, 378, 790, 244, 377, 244, 244, 244, 786, + 244, 244, 293, 374, 371, 370, 653, 293, 244, 850, + + 244, 244, 293, 367, 244, 366, 244, 244, 293, 365, + 789, 354, 787, 293, 852, 788, 849, 245, 351, 348, + 244, 245, 244, 244, 244, 851, 244, 244, 791, 347, + 853, 245, 347, 244, 854, 244, 244, 245, 244, 242, + 244, 244, 244, 238, 244, 244, 235, 244, 855, 244, + 244, 234, 856, 245, 230, 226, 292, 245, 244, 292, + 244, 244, 244, 221, 244, 244, 245, 244, 857, 244, + 244, 245, 858, 220, 861, 245, 244, 859, 244, 244, + 245, 244, 215, 244, 244, 244, 214, 244, 244, 293, + 244, 245, 244, 244, 862, 245, 244, 204, 244, 244, + + 245, 203, 202, 244, 860, 244, 244, 199, 292, 245, + 863, 292, 864, 244, 245, 244, 244, 244, 245, 244, + 244, 198, 244, 245, 244, 244, 197, 867, 244, 245, + 244, 244, 865, 186, 183, 880, 245, 244, 868, 244, + 244, 293, 866, 180, 869, 179, 245, 870, 179, 244, + 245, 244, 244, 178, 244, 245, 244, 244, 1095, 1095, + 244, 245, 244, 244, 1095, 244, 1095, 244, 244, 244, + 245, 244, 244, 244, 292, 244, 244, 292, 244, 871, + 244, 244, 245, 244, 881, 244, 244, 245, 873, 872, + 1095, 1095, 756, 245, 244, 756, 1095, 244, 245, 244, + + 244, 292, 245, 1095, 292, 292, 245, 293, 292, 874, + 1095, 245, 1095, 875, 1095, 1095, 245, 876, 292, 1095, + 879, 292, 1095, 292, 292, 245, 292, 292, 882, 878, + 245, 1095, 292, 883, 293, 292, 292, 1095, 293, 292, + 757, 1095, 884, 1095, 292, 877, 885, 292, 1095, 292, + 292, 293, 292, 292, 886, 1095, 293, 293, 292, 887, + 888, 292, 1095, 292, 1095, 293, 292, 292, 292, 293, + 292, 292, 292, 292, 1095, 292, 292, 293, 1095, 1095, + 1095, 891, 293, 293, 292, 292, 889, 292, 292, 292, + 890, 293, 292, 1095, 893, 896, 293, 892, 1095, 897, + + 293, 293, 894, 1095, 292, 293, 293, 292, 292, 292, + 1095, 292, 292, 895, 1095, 1095, 1095, 293, 293, 899, + 292, 292, 293, 292, 292, 292, 898, 292, 292, 292, + 292, 292, 292, 1095, 292, 1095, 292, 293, 900, 292, + 790, 293, 293, 790, 292, 1095, 1095, 292, 902, 244, + 901, 244, 244, 293, 293, 1095, 1095, 1095, 293, 943, + 293, 1095, 293, 1095, 293, 292, 904, 903, 292, 293, + 905, 1095, 244, 293, 244, 244, 244, 293, 244, 244, + 1095, 244, 245, 244, 244, 1095, 944, 244, 791, 244, + 244, 945, 906, 244, 1095, 244, 244, 244, 293, 244, + + 244, 244, 1095, 244, 244, 245, 1095, 1095, 244, 245, + 244, 244, 1095, 244, 245, 244, 244, 1095, 1095, 244, + 245, 244, 244, 1095, 1095, 244, 245, 244, 244, 244, + 245, 244, 244, 1095, 245, 946, 244, 1095, 244, 244, + 244, 245, 244, 244, 1095, 244, 245, 244, 244, 947, + 1095, 1095, 245, 292, 949, 951, 292, 292, 245, 950, + 292, 244, 245, 244, 244, 948, 1095, 961, 1095, 245, + 1095, 952, 244, 245, 244, 244, 1095, 244, 245, 244, + 244, 244, 953, 244, 244, 244, 293, 244, 244, 244, + 293, 244, 244, 244, 245, 244, 244, 1095, 1095, 244, + + 954, 244, 244, 1095, 244, 245, 244, 244, 1095, 956, + 245, 1095, 1095, 292, 245, 955, 292, 1095, 245, 957, + 1095, 244, 245, 244, 244, 244, 245, 244, 244, 1095, + 1095, 244, 245, 244, 244, 1095, 244, 245, 244, 244, + 292, 292, 292, 292, 292, 292, 293, 1095, 1095, 292, + 962, 963, 292, 292, 245, 1095, 292, 292, 245, 292, + 292, 959, 292, 1095, 245, 292, 958, 292, 292, 245, + 292, 1095, 1095, 293, 293, 293, 960, 964, 965, 1095, + 292, 1095, 293, 292, 292, 292, 293, 292, 292, 1095, + 293, 1095, 293, 1095, 966, 969, 292, 1095, 293, 292, + + 293, 292, 1095, 968, 292, 967, 970, 292, 1095, 292, + 292, 971, 292, 293, 1095, 1095, 292, 293, 293, 292, + 292, 292, 292, 292, 292, 292, 1095, 1095, 1095, 293, + 292, 972, 974, 292, 293, 292, 292, 1095, 292, 292, + 293, 292, 293, 973, 292, 975, 1095, 1095, 292, 293, + 1095, 292, 1095, 293, 293, 293, 244, 1095, 244, 244, + 1095, 1095, 244, 293, 244, 244, 1095, 1095, 293, 293, + 1095, 1095, 977, 244, 293, 244, 244, 1095, 1095, 1095, + 976, 293, 244, 1095, 244, 244, 978, 1095, 244, 245, + 244, 244, 1095, 1095, 1095, 245, 1095, 244, 1095, 244, + + 244, 244, 1095, 244, 244, 244, 245, 244, 244, 244, + 1095, 244, 244, 1000, 1095, 245, 1001, 244, 1095, 244, + 244, 245, 244, 1002, 244, 244, 244, 1003, 244, 244, + 245, 1095, 292, 1095, 245, 292, 1004, 244, 245, 244, + 244, 244, 245, 244, 244, 1095, 244, 1095, 244, 244, + 245, 1008, 1095, 244, 1008, 245, 1006, 1095, 292, 245, + 244, 292, 244, 244, 292, 293, 1005, 292, 1007, 244, + 245, 244, 244, 292, 245, 292, 292, 292, 292, 245, + 292, 1095, 292, 292, 245, 292, 292, 292, 1095, 292, + 292, 293, 292, 245, 1095, 292, 1012, 293, 292, 1009, + + 1011, 1095, 245, 1095, 1013, 1010, 293, 1095, 293, 1014, + 293, 292, 1095, 1095, 292, 293, 293, 1095, 1095, 1095, + 293, 1015, 293, 292, 292, 1095, 292, 292, 293, 292, + 292, 1019, 292, 292, 1019, 1095, 1095, 292, 1018, 1017, + 292, 1095, 1095, 244, 293, 244, 244, 244, 1095, 244, + 244, 244, 1016, 244, 244, 1095, 293, 293, 1095, 1095, + 1095, 1040, 293, 293, 293, 1038, 1095, 1095, 1095, 1039, + 293, 1095, 244, 1021, 244, 244, 245, 1095, 1095, 1020, + 245, 1095, 1095, 244, 245, 244, 244, 1041, 244, 1095, + 244, 244, 244, 292, 244, 244, 292, 244, 1042, 244, + + 244, 1008, 1095, 244, 1008, 245, 244, 1095, 244, 244, + 1045, 292, 244, 1045, 292, 1047, 245, 292, 1095, 1036, + 292, 245, 1036, 1095, 1095, 245, 293, 1049, 292, 1095, + 245, 292, 1043, 1048, 245, 292, 1095, 292, 292, 245, + 292, 1095, 1095, 245, 293, 1051, 1095, 1095, 292, 1009, + 293, 292, 1050, 292, 1044, 1095, 292, 1019, 1046, 292, + 1019, 293, 292, 1054, 1095, 1095, 1054, 1037, 293, 1036, + 293, 292, 1036, 244, 292, 244, 244, 244, 1095, 244, + 244, 293, 244, 1065, 244, 244, 293, 1095, 1052, 1095, + 293, 244, 293, 244, 244, 1095, 293, 1066, 1095, 1095, + + 244, 1067, 244, 244, 293, 1020, 245, 1053, 1095, 292, + 245, 1055, 292, 1095, 1095, 245, 244, 1037, 244, 244, + 244, 1095, 244, 244, 245, 1045, 1095, 244, 1045, 244, + 1095, 244, 244, 245, 292, 292, 292, 292, 292, 292, + 1095, 1095, 293, 1095, 1070, 292, 1072, 1095, 292, 245, + 1071, 292, 1068, 245, 292, 1095, 1054, 292, 245, 1054, + 292, 244, 245, 244, 244, 1095, 1095, 293, 293, 293, + 1095, 1095, 1095, 1046, 1095, 1095, 1095, 1069, 293, 292, + 1095, 1073, 292, 244, 293, 244, 244, 1095, 292, 293, + 293, 292, 1095, 1079, 245, 244, 1095, 244, 244, 244, + + 292, 244, 244, 292, 1055, 1074, 244, 1095, 244, 244, + 1081, 292, 293, 1095, 292, 292, 245, 244, 292, 244, + 244, 293, 244, 292, 244, 244, 292, 292, 245, 1095, + 292, 292, 245, 293, 292, 244, 1095, 244, 244, 245, + 1095, 1080, 1095, 244, 293, 244, 244, 1095, 293, 244, + 245, 244, 244, 1082, 292, 245, 293, 292, 1095, 1093, + 293, 1095, 1095, 1095, 293, 1095, 1095, 1085, 245, 1090, + 1095, 292, 1086, 1089, 292, 1095, 245, 1095, 1095, 1095, + 1095, 1094, 245, 1095, 1095, 1095, 1095, 293, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + + 1095, 1095, 1095, 1095, 293, 52, 52, 52, 52, 52, + 52, 57, 57, 57, 57, 57, 57, 64, 64, 64, + 64, 64, 64, 69, 69, 69, 69, 69, 69, 171, + 171, 171, 171, 171, 171, 212, 212, 1095, 212, 212, + 212, 222, 222, 222, 222, 222, 222, 225, 1095, 1095, + 1095, 225, 225, 227, 227, 227, 227, 227, 227, 233, + 233, 1095, 1095, 233, 233, 239, 239, 239, 239, 239, + 239, 243, 243, 1095, 243, 243, 243, 280, 280, 1095, + 280, 280, 280, 291, 291, 1095, 1095, 1095, 291, 329, + 329, 1095, 329, 329, 329, 383, 383, 1095, 1095, 1095, + + 383, 17, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095 } ; -static yyconst flex_int16_t yy_chk[3584] = +static yyconst flex_int16_t yy_chk[3654] = { 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, 1, 1, - 2, 7, 7, 2, 2, 3, 3, 3, 3, 1088, - 2, 4, 4, 4, 4, 4, 5, 5, 6, 6, - 8, 8, 19, 2, 28, 19, 4, 15, 15, 15, - 15, 28, 35, 30, 15, 32, 34, 33, 32, 2, - 30, 2, 32, 2, 39, 32, 2, 2, 33, 35, - - 34, 50, 67, 50, 4, 1068, 39, 67, 5, 15, - 6, 69, 69, 5, 1065, 6, 9, 9, 9, 9, + 1, 2, 7, 7, 2, 2, 3, 3, 3, 3, + 1111, 2, 4, 4, 4, 4, 4, 5, 5, 6, + 6, 8, 8, 19, 2, 28, 19, 4, 15, 15, + 15, 15, 28, 30, 39, 15, 35, 49, 34, 33, + 30, 2, 169, 2, 32, 2, 39, 32, 2, 2, + + 33, 32, 34, 35, 32, 50, 4, 50, 49, 67, + 5, 15, 6, 169, 67, 5, 1091, 6, 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, 9, 9, 10, 46, 49, 10, - 10, 16, 16, 16, 16, 169, 10, 1064, 16, 149, - 63, 46, 55, 55, 55, 154, 149, 151, 49, 10, - 60, 60, 60, 60, 151, 169, 154, 155, 160, 163, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, + 46, 63, 10, 10, 16, 16, 16, 16, 1088, 10, + 156, 16, 69, 69, 46, 55, 55, 55, 60, 60, + 60, 60, 10, 154, 149, 151, 153, 156, 155, 153, - 163, 163, 163, 16, 170, 10, 170, 10, 63, 10, - 160, 155, 10, 10, 11, 11, 11, 11, 11, 11, + 63, 149, 151, 153, 154, 1087, 153, 16, 170, 10, + 170, 10, 155, 10, 213, 213, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, - 11, 11, 11, 11, 12, 156, 166, 12, 12, 72, - 107, 72, 72, 107, 12, 189, 73, 73, 73, 73, - 166, 153, 156, 177, 153, 1061, 177, 12, 153, 189, - 203, 153, 210, 203, 210, 213, 213, 224, 224, 224, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, + 1084, 232, 12, 12, 72, 107, 72, 72, 107, 12, + 166, 73, 73, 73, 73, 160, 163, 163, 163, 163, + 177, 189, 12, 177, 166, 203, 703, 160, 203, 210, - 1060, 72, 107, 12, 236, 12, 1055, 12, 73, 236, - 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, + 232, 210, 224, 224, 224, 189, 1083, 72, 107, 12, + 236, 12, 703, 12, 73, 236, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 14, 239, 239, 14, 14, 75, 75, 75, - 75, 1053, 14, 1052, 76, 111, 76, 76, 111, 77, - 115, 77, 77, 115, 78, 14, 78, 78, 77, 79, - 357, 79, 79, 80, 371, 80, 80, 371, 79, 75, - - 232, 14, 217, 14, 357, 14, 76, 111, 14, 14, - 43, 77, 115, 43, 43, 81, 78, 81, 81, 380, - 43, 79, 217, 112, 1040, 80, 112, 82, 232, 82, - 82, 81, 112, 83, 114, 83, 83, 114, 84, 380, - 84, 84, 1038, 114, 406, 82, 1036, 81, 83, 43, - 1035, 43, 82, 376, 376, 112, 43, 43, 406, 82, - 84, 85, 520, 85, 85, 83, 114, 84, 699, 116, - 84, 87, 116, 87, 87, 88, 520, 88, 88, 798, - 89, 1034, 89, 89, 699, 116, 88, 87, 1033, 422, - 85, 89, 422, 85, 86, 798, 86, 86, 87, 823, - - 88, 116, 90, 87, 90, 90, 900, 88, 89, 1016, - 86, 1013, 89, 86, 1012, 823, 91, 86, 91, 91, - 86, 92, 900, 92, 92, 93, 86, 93, 93, 90, - 94, 1010, 94, 94, 90, 1009, 422, 95, 91, 95, - 95, 94, 1007, 93, 96, 96, 96, 96, 91, 1006, - 92, 1005, 95, 92, 1004, 93, 97, 93, 97, 97, - 1003, 981, 94, 98, 98, 98, 98, 979, 99, 95, - 99, 99, 100, 976, 100, 100, 96, 975, 101, 974, - 101, 101, 102, 118, 102, 102, 118, 973, 97, 101, - 103, 97, 103, 103, 104, 98, 104, 104, 118, 106, - - 99, 106, 106, 101, 100, 972, 105, 970, 105, 105, - 101, 229, 229, 229, 102, 118, 969, 104, 108, 108, - 108, 108, 103, 968, 967, 119, 104, 102, 119, 966, - 965, 106, 103, 110, 110, 110, 110, 104, 105, 105, - 120, 105, 117, 120, 964, 117, 106, 119, 123, 929, - 108, 123, 121, 127, 119, 121, 127, 119, 928, 123, - 117, 122, 926, 125, 122, 110, 125, 117, 121, 120, - 925, 121, 120, 123, 117, 121, 124, 122, 121, 124, - 123, 923, 127, 126, 121, 127, 126, 124, 122, 128, - 125, 129, 128, 122, 129, 125, 130, 132, 135, 130, - - 132, 135, 129, 919, 124, 126, 137, 128, 124, 137, - 134, 130, 134, 134, 918, 126, 917, 134, 916, 128, - 911, 128, 910, 129, 131, 131, 131, 131, 130, 132, - 135, 909, 132, 133, 133, 133, 133, 136, 137, 908, - 136, 138, 134, 139, 138, 907, 139, 140, 136, 141, - 140, 137, 141, 906, 905, 904, 131, 142, 142, 142, - 142, 903, 136, 902, 901, 133, 139, 899, 898, 136, - 897, 171, 896, 138, 171, 139, 839, 837, 836, 140, - 140, 141, 140, 138, 835, 834, 139, 833, 831, 142, - 144, 144, 144, 144, 828, 827, 141, 165, 165, 165, - - 165, 826, 825, 171, 172, 172, 172, 172, 174, 174, - 174, 174, 176, 176, 176, 176, 238, 238, 238, 238, - 824, 243, 144, 243, 243, 244, 822, 244, 244, 165, - 245, 245, 245, 245, 813, 812, 172, 811, 810, 809, - 174, 808, 807, 806, 176, 246, 246, 246, 246, 248, - 248, 248, 248, 243, 805, 804, 803, 244, 249, 249, - 249, 249, 245, 251, 238, 251, 251, 252, 802, 252, - 252, 253, 251, 253, 253, 801, 254, 246, 254, 254, - 800, 248, 253, 255, 799, 255, 255, 797, 291, 252, - 256, 291, 256, 256, 257, 251, 257, 257, 254, 252, - - 796, 256, 258, 253, 258, 258, 795, 794, 254, 255, - 793, 536, 792, 257, 536, 255, 259, 258, 259, 259, - 291, 260, 256, 260, 260, 791, 257, 261, 790, 261, - 261, 259, 789, 262, 258, 262, 262, 292, 261, 263, - 292, 263, 263, 264, 574, 264, 264, 574, 259, 788, - 260, 787, 261, 260, 265, 786, 265, 265, 536, 261, - 262, 263, 785, 718, 266, 262, 266, 266, 264, 292, - 267, 263, 267, 267, 268, 264, 268, 268, 717, 715, - 269, 265, 269, 269, 714, 712, 265, 270, 266, 270, - 270, 574, 271, 267, 271, 271, 266, 711, 270, 269, - - 710, 708, 267, 707, 268, 272, 268, 272, 272, 706, - 705, 271, 269, 273, 704, 273, 273, 703, 700, 270, - 275, 698, 275, 275, 271, 273, 274, 697, 274, 274, - 276, 276, 276, 276, 696, 272, 695, 272, 278, 275, - 278, 278, 275, 274, 280, 273, 280, 280, 281, 694, - 281, 281, 275, 282, 282, 282, 282, 283, 274, 283, - 283, 284, 276, 284, 284, 285, 693, 285, 285, 287, - 278, 287, 287, 692, 278, 286, 280, 286, 286, 288, - 281, 288, 288, 283, 283, 282, 286, 690, 289, 283, - 289, 289, 287, 284, 284, 689, 290, 285, 290, 290, - - 285, 287, 293, 293, 293, 293, 688, 286, 687, 686, - 685, 288, 287, 294, 294, 294, 294, 683, 288, 682, - 289, 296, 296, 296, 296, 681, 300, 680, 290, 300, - 299, 679, 289, 299, 293, 297, 297, 297, 297, 299, - 301, 302, 678, 301, 302, 294, 677, 305, 300, 303, - 305, 301, 303, 296, 304, 676, 306, 304, 300, 306, - 675, 307, 299, 302, 307, 304, 305, 308, 674, 673, - 308, 306, 301, 302, 310, 303, 307, 310, 672, 305, - 309, 303, 311, 309, 312, 311, 304, 312, 306, 671, - 670, 309, 313, 307, 314, 313, 308, 314, 669, 308, - - 315, 310, 668, 315, 311, 309, 310, 316, 317, 312, - 316, 317, 309, 667, 311, 666, 312, 318, 314, 313, - 318, 665, 319, 315, 313, 319, 314, 317, 318, 664, - 320, 321, 315, 320, 321, 322, 663, 316, 322, 316, - 317, 319, 323, 321, 327, 323, 662, 327, 661, 318, - 660, 659, 322, 658, 319, 324, 324, 324, 324, 657, - 320, 323, 320, 321, 323, 656, 655, 322, 326, 326, - 326, 326, 654, 579, 323, 329, 327, 329, 329, 577, - 327, 330, 329, 330, 330, 576, 575, 324, 330, 331, - 331, 331, 331, 571, 570, 333, 331, 332, 333, 334, - - 332, 335, 334, 336, 335, 337, 336, 329, 337, 569, - 568, 338, 335, 330, 338, 339, 567, 566, 339, 565, - 564, 331, 383, 332, 332, 383, 336, 333, 333, 332, - 563, 334, 562, 335, 334, 336, 561, 337, 340, 340, - 340, 340, 384, 338, 337, 384, 336, 339, 342, 342, - 342, 342, 560, 559, 383, 338, 343, 343, 343, 343, - 344, 558, 344, 344, 372, 372, 372, 372, 557, 390, - 340, 390, 390, 556, 384, 385, 385, 385, 385, 555, - 342, 386, 386, 386, 386, 388, 388, 388, 388, 554, - 553, 552, 344, 389, 389, 389, 389, 391, 391, 391, - - 391, 390, 393, 393, 393, 393, 551, 385, 421, 421, - 421, 421, 550, 386, 549, 548, 547, 388, 428, 428, - 428, 428, 429, 429, 429, 429, 546, 545, 544, 391, - 430, 430, 430, 430, 432, 432, 432, 432, 540, 433, - 433, 433, 433, 435, 435, 435, 435, 436, 539, 436, - 436, 437, 538, 437, 437, 537, 534, 438, 436, 438, - 438, 439, 533, 439, 439, 441, 428, 441, 441, 532, - 429, 433, 531, 530, 440, 437, 440, 440, 430, 436, - 529, 474, 438, 437, 474, 528, 527, 441, 526, 438, - 439, 440, 442, 439, 442, 442, 443, 441, 443, 443, - - 525, 444, 524, 444, 444, 474, 440, 443, 445, 578, - 445, 445, 578, 474, 523, 442, 444, 446, 522, 446, - 446, 521, 519, 447, 442, 447, 447, 448, 443, 448, - 448, 518, 449, 444, 449, 449, 445, 517, 448, 473, - 445, 446, 473, 516, 450, 449, 450, 450, 447, 446, - 473, 451, 448, 451, 451, 447, 578, 515, 452, 448, - 452, 452, 514, 513, 449, 450, 453, 512, 453, 453, - 511, 473, 454, 452, 454, 454, 450, 684, 453, 451, - 684, 510, 455, 451, 455, 455, 456, 454, 456, 456, - 452, 457, 509, 457, 457, 455, 508, 458, 453, 458, - - 458, 427, 426, 459, 454, 459, 459, 457, 456, 460, - 425, 460, 460, 462, 455, 462, 462, 461, 456, 461, - 461, 424, 423, 457, 684, 458, 460, 420, 419, 458, - 461, 459, 418, 417, 416, 459, 463, 463, 463, 463, - 465, 460, 465, 465, 716, 462, 462, 716, 415, 461, - 464, 464, 464, 464, 466, 414, 466, 466, 467, 413, - 467, 467, 468, 475, 468, 468, 475, 469, 463, 469, - 469, 412, 465, 470, 470, 470, 470, 472, 472, 472, - 472, 411, 464, 410, 467, 409, 466, 465, 475, 476, - 467, 716, 476, 466, 468, 475, 408, 407, 477, 469, - - 468, 477, 405, 478, 404, 470, 478, 469, 479, 480, - 403, 479, 480, 481, 482, 477, 481, 482, 476, 483, - 480, 476, 483, 484, 486, 478, 484, 486, 481, 487, - 477, 479, 487, 485, 402, 478, 485, 486, 401, 400, - 479, 480, 482, 483, 485, 481, 482, 399, 484, 488, - 487, 483, 488, 398, 489, 484, 486, 489, 485, 490, - 491, 487, 490, 491, 397, 485, 396, 492, 395, 489, - 492, 490, 394, 493, 382, 491, 493, 488, 381, 379, - 492, 488, 494, 378, 495, 494, 489, 495, 377, 374, - 496, 490, 491, 496, 497, 493, 370, 497, 494, 492, - - 498, 499, 369, 498, 499, 493, 501, 501, 501, 501, - 368, 497, 495, 498, 494, 367, 495, 503, 496, 366, - 503, 365, 496, 364, 504, 363, 497, 504, 500, 500, - 500, 500, 498, 499, 499, 500, 502, 502, 502, 502, - 505, 506, 507, 505, 506, 507, 362, 361, 360, 503, - 535, 535, 535, 535, 359, 358, 504, 356, 355, 354, - 500, 353, 927, 504, 503, 927, 505, 971, 502, 352, - 971, 351, 505, 506, 507, 541, 541, 541, 541, 506, - 350, 349, 507, 543, 543, 543, 543, 572, 572, 572, - 572, 580, 580, 580, 580, 582, 582, 582, 582, 583, - - 583, 583, 583, 585, 585, 585, 585, 541, 586, 927, - 586, 586, 348, 587, 971, 587, 587, 347, 588, 241, - 588, 588, 237, 234, 980, 586, 587, 980, 589, 982, - 589, 589, 982, 590, 233, 590, 590, 231, 230, 580, - 586, 591, 228, 591, 591, 587, 589, 583, 588, 592, - 588, 592, 592, 223, 219, 593, 591, 593, 593, 592, - 589, 590, 218, 216, 215, 590, 594, 214, 594, 594, - 211, 980, 595, 591, 595, 595, 982, 596, 209, 596, - 596, 592, 208, 598, 593, 598, 598, 593, 597, 594, - 597, 597, 599, 595, 599, 599, 620, 204, 594, 620, - - 598, 202, 201, 200, 595, 596, 199, 198, 600, 596, - 600, 600, 197, 620, 597, 598, 601, 599, 601, 601, - 597, 196, 195, 602, 599, 602, 602, 194, 620, 600, - 193, 601, 603, 602, 603, 603, 605, 192, 605, 605, - 600, 604, 603, 604, 604, 191, 190, 606, 601, 606, - 606, 607, 188, 607, 607, 602, 608, 187, 608, 608, - 605, 186, 606, 185, 603, 184, 607, 183, 605, 604, - 182, 181, 608, 604, 609, 180, 609, 609, 611, 606, - 611, 611, 610, 607, 610, 610, 179, 612, 608, 612, - 612, 613, 610, 613, 613, 168, 611, 614, 614, 614, - - 614, 167, 615, 609, 615, 615, 609, 164, 623, 162, - 611, 623, 612, 616, 610, 616, 616, 161, 617, 612, - 617, 617, 618, 613, 618, 618, 623, 159, 158, 614, - 619, 157, 619, 619, 615, 621, 613, 152, 621, 622, - 623, 150, 622, 625, 624, 616, 625, 624, 621, 615, - 617, 148, 627, 146, 618, 627, 618, 145, 625, 71, - 616, 629, 619, 617, 629, 628, 68, 621, 628, 622, - 626, 622, 624, 626, 66, 625, 624, 619, 64, 62, - 626, 627, 629, 630, 627, 59, 630, 631, 628, 632, - 631, 633, 632, 629, 633, 635, 634, 628, 635, 634, - - 54, 51, 626, 48, 636, 638, 632, 636, 638, 640, - 635, 630, 640, 631, 636, 630, 633, 634, 47, 631, - 42, 632, 637, 633, 640, 637, 639, 635, 634, 639, - 41, 641, 637, 638, 641, 642, 636, 638, 642, 643, - 646, 640, 643, 646, 645, 644, 641, 645, 644, 647, - 639, 642, 647, 40, 637, 644, 649, 650, 639, 649, - 650, 651, 645, 641, 651, 646, 652, 642, 643, 652, - 653, 643, 646, 653, 38, 1008, 645, 644, 1008, 37, - 36, 647, 648, 648, 648, 648, 31, 755, 649, 650, - 755, 29, 27, 651, 647, 25, 1015, 755, 652, 1015, - - 652, 23, 653, 649, 650, 719, 651, 719, 719, 720, - 21, 720, 720, 721, 648, 721, 721, 653, 722, 755, - 722, 722, 1008, 725, 720, 725, 725, 17, 722, 723, - 0, 723, 723, 719, 0, 0, 0, 719, 0, 723, - 721, 720, 0, 1015, 724, 721, 724, 724, 0, 726, - 722, 726, 726, 0, 724, 725, 0, 0, 0, 726, - 727, 723, 727, 727, 728, 0, 728, 728, 0, 729, - 727, 729, 729, 0, 728, 730, 724, 730, 730, 729, - 731, 726, 731, 731, 732, 730, 732, 732, 0, 0, - 0, 733, 727, 733, 733, 734, 728, 734, 734, 0, - - 735, 729, 735, 735, 733, 0, 0, 730, 731, 0, - 0, 732, 731, 0, 0, 736, 732, 736, 736, 0, - 733, 753, 734, 733, 753, 0, 737, 734, 737, 737, - 0, 738, 735, 738, 738, 739, 753, 739, 739, 740, - 758, 740, 740, 758, 0, 739, 0, 736, 741, 740, - 741, 741, 0, 753, 742, 737, 742, 742, 737, 743, - 738, 743, 743, 738, 742, 0, 744, 739, 744, 744, - 741, 740, 758, 745, 0, 745, 745, 0, 0, 746, - 741, 746, 746, 0, 0, 747, 742, 747, 747, 0, - 748, 743, 748, 748, 0, 744, 745, 749, 744, 749, - - 749, 750, 0, 750, 750, 745, 751, 752, 751, 751, - 752, 746, 0, 754, 0, 0, 754, 747, 746, 0, - 0, 0, 748, 0, 748, 0, 0, 0, 0, 749, - 749, 756, 0, 750, 756, 752, 0, 0, 751, 752, - 754, 756, 0, 0, 757, 754, 759, 757, 750, 759, - 0, 0, 760, 751, 757, 760, 759, 761, 762, 0, - 761, 762, 760, 756, 0, 0, 0, 761, 762, 763, - 764, 768, 763, 764, 768, 0, 757, 765, 759, 763, - 765, 0, 766, 767, 760, 766, 767, 0, 769, 761, - 762, 769, 0, 770, 771, 766, 770, 771, 764, 0, - - 0, 763, 764, 768, 765, 776, 0, 0, 776, 765, - 767, 766, 0, 774, 766, 767, 774, 0, 772, 0, - 769, 772, 770, 771, 773, 770, 771, 773, 772, 775, - 777, 0, 775, 777, 773, 774, 0, 776, 779, 775, - 778, 779, 0, 778, 780, 774, 781, 780, 0, 781, - 772, 782, 0, 0, 782, 783, 773, 784, 783, 777, - 784, 775, 777, 778, 840, 0, 840, 840, 0, 0, - 779, 0, 778, 0, 840, 0, 780, 779, 781, 843, - 781, 843, 843, 782, 782, 0, 0, 783, 841, 784, - 841, 841, 844, 0, 844, 844, 840, 842, 841, 842, - - 842, 0, 783, 845, 784, 845, 845, 842, 0, 0, - 846, 843, 846, 846, 847, 0, 847, 847, 0, 848, - 841, 848, 848, 849, 844, 849, 849, 0, 850, 842, - 850, 850, 0, 0, 851, 845, 851, 851, 853, 0, - 853, 853, 846, 0, 851, 852, 847, 852, 852, 0, - 854, 848, 854, 854, 855, 849, 855, 855, 852, 858, - 850, 858, 858, 853, 855, 856, 851, 856, 856, 854, - 853, 0, 0, 868, 852, 856, 868, 852, 857, 0, - 857, 857, 854, 868, 0, 0, 855, 859, 857, 859, - 859, 858, 860, 0, 860, 860, 861, 856, 861, 861, - - 0, 862, 0, 862, 862, 868, 863, 860, 863, 863, - 857, 862, 864, 871, 864, 864, 871, 0, 0, 859, - 865, 863, 865, 865, 860, 0, 0, 866, 861, 866, - 866, 0, 867, 862, 867, 867, 869, 870, 863, 869, - 870, 0, 0, 0, 864, 871, 869, 870, 872, 0, - 873, 872, 865, 873, 874, 865, 864, 874, 875, 866, - 876, 875, 877, 876, 867, 877, 0, 878, 869, 870, - 878, 866, 880, 879, 882, 880, 879, 882, 881, 0, - 872, 881, 873, 879, 886, 880, 874, 886, 883, 0, - 875, 883, 876, 882, 877, 0, 0, 884, 883, 878, - - 884, 880, 0, 881, 880, 879, 882, 884, 885, 887, - 881, 885, 887, 0, 889, 0, 886, 889, 885, 888, - 883, 890, 888, 891, 890, 892, 891, 893, 892, 884, - 893, 890, 894, 895, 888, 894, 895, 0, 891, 0, - 885, 887, 930, 0, 930, 930, 889, 931, 0, 931, - 931, 888, 0, 890, 0, 891, 0, 892, 932, 893, - 932, 932, 893, 0, 894, 895, 0, 0, 933, 892, - 933, 933, 0, 0, 930, 0, 894, 0, 934, 931, - 934, 934, 935, 0, 935, 935, 936, 0, 936, 936, - 932, 937, 0, 937, 937, 938, 0, 938, 938, 0, - - 933, 935, 939, 934, 939, 939, 0, 0, 936, 940, - 934, 940, 940, 937, 935, 0, 0, 947, 936, 941, - 947, 941, 941, 937, 0, 0, 0, 938, 942, 941, - 942, 942, 0, 943, 939, 943, 943, 944, 0, 944, - 944, 940, 0, 943, 945, 944, 945, 945, 0, 947, - 946, 941, 946, 946, 948, 949, 950, 948, 949, 950, - 942, 0, 0, 955, 951, 943, 955, 951, 0, 944, - 953, 952, 954, 953, 952, 954, 945, 956, 957, 0, - 956, 957, 946, 0, 0, 946, 948, 949, 950, 951, - 952, 945, 953, 0, 954, 955, 951, 958, 959, 0, - - 958, 959, 953, 952, 954, 960, 0, 958, 960, 956, - 957, 961, 0, 962, 961, 960, 962, 963, 0, 961, - 963, 0, 983, 0, 983, 983, 0, 0, 0, 958, - 959, 984, 0, 984, 984, 0, 985, 960, 985, 985, - 0, 0, 0, 961, 983, 962, 985, 0, 987, 963, - 987, 987, 963, 984, 983, 986, 0, 986, 986, 988, - 962, 988, 988, 984, 989, 0, 989, 989, 985, 990, - 986, 990, 990, 991, 995, 991, 991, 995, 0, 992, - 987, 992, 992, 0, 995, 993, 994, 986, 993, 994, - 997, 988, 998, 997, 0, 998, 989, 996, 989, 999, - - 996, 990, 999, 0, 0, 991, 995, 993, 994, 0, - 1000, 992, 996, 1000, 0, 0, 990, 993, 994, 0, - 991, 0, 997, 0, 998, 0, 992, 1001, 0, 996, - 1001, 999, 1002, 999, 1017, 1002, 1017, 1017, 1018, 0, - 1018, 1018, 1000, 1019, 1017, 1019, 1019, 0, 1020, 0, - 1020, 1020, 1021, 1018, 1021, 1021, 0, 1000, 1020, 1001, - 1022, 0, 1022, 1022, 1002, 1023, 1017, 1023, 1023, 1024, - 1018, 1024, 1024, 1025, 1001, 1019, 1025, 0, 1026, 1002, - 1020, 1026, 1027, 1025, 1021, 1027, 1028, 1021, 1029, 1028, - 0, 1029, 1022, 1026, 0, 1030, 1028, 1023, 1030, 1031, - - 1032, 1024, 1031, 1032, 1042, 1025, 1042, 1042, 1047, 0, - 1026, 1047, 1023, 0, 1027, 0, 1024, 0, 1028, 1043, - 1029, 1043, 1043, 1029, 0, 1049, 0, 1030, 1049, 1043, - 1051, 1031, 1032, 1051, 0, 1044, 1042, 1044, 1044, 1045, - 1047, 1045, 1045, 0, 0, 1048, 1031, 1032, 1048, 0, - 1046, 1043, 1046, 1046, 0, 1048, 1050, 1049, 1056, 1050, - 1056, 1056, 1051, 1057, 0, 1057, 1057, 1044, 0, 1058, - 1059, 1045, 1058, 1059, 0, 0, 1062, 1048, 1062, 1062, - 1045, 0, 1046, 1063, 1067, 0, 1063, 1067, 1050, 1066, - 1056, 1066, 1066, 1071, 1067, 1057, 1071, 1050, 0, 1066, - - 0, 1058, 1059, 1070, 0, 1070, 1070, 1057, 1062, 0, - 0, 0, 0, 1062, 1059, 1063, 1067, 0, 0, 0, - 1063, 1066, 0, 0, 0, 1071, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1070, 1073, 1073, 1073, 1073, - 1073, 1073, 1074, 1074, 1074, 1074, 1074, 1074, 1075, 1075, - 1075, 1075, 1075, 1075, 1076, 1076, 1076, 1076, 1076, 1076, - 1077, 1077, 1077, 1077, 1077, 1077, 1078, 1078, 0, 1078, - 1078, 1078, 1079, 1079, 1079, 1079, 1079, 1079, 1080, 0, - 0, 0, 1080, 1080, 1081, 1081, 1081, 1081, 1081, 1081, - 1082, 1082, 0, 0, 1082, 1082, 1083, 1083, 1083, 1083, - - 1083, 1083, 1084, 1084, 0, 1084, 1084, 1084, 1085, 1085, - 0, 1085, 1085, 1085, 1086, 1086, 0, 0, 0, 1086, - 1087, 1087, 0, 1087, 1087, 1087, 1089, 1089, 0, 0, - 0, 1089, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, - 1072, 1072, 1072 + 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, + 239, 239, 14, 14, 75, 75, 75, 75, 1078, 14, + 217, 76, 111, 76, 76, 111, 77, 115, 77, 77, + 115, 78, 14, 78, 78, 77, 79, 1076, 79, 79, + + 80, 217, 80, 80, 1075, 79, 380, 75, 1063, 14, + 1061, 14, 1059, 14, 76, 111, 14, 14, 43, 77, + 115, 43, 43, 81, 78, 81, 81, 380, 43, 79, + 229, 229, 229, 80, 82, 1058, 82, 82, 83, 81, + 83, 83, 371, 1057, 117, 371, 84, 117, 84, 84, + 376, 376, 82, 83, 116, 1056, 81, 116, 43, 82, + 43, 85, 117, 85, 85, 43, 43, 82, 84, 117, + 116, 83, 357, 416, 406, 84, 416, 117, 1037, 84, + 87, 422, 87, 87, 422, 1034, 357, 116, 406, 89, + 85, 89, 89, 1032, 85, 86, 87, 86, 86, 88, + + 89, 88, 88, 90, 805, 90, 90, 87, 1030, 530, + 88, 86, 530, 87, 86, 1029, 1027, 89, 86, 1026, + 805, 86, 89, 91, 88, 91, 91, 831, 86, 422, + 90, 92, 88, 92, 92, 93, 90, 93, 93, 94, + 520, 94, 94, 831, 95, 91, 95, 95, 1025, 97, + 94, 97, 97, 93, 520, 99, 91, 99, 99, 95, + 92, 1024, 1023, 1022, 92, 93, 998, 100, 93, 100, + 100, 996, 94, 96, 96, 96, 96, 95, 98, 98, + 98, 98, 97, 994, 101, 97, 101, 101, 99, 102, + 112, 102, 102, 112, 103, 101, 103, 103, 911, 112, + + 100, 104, 992, 104, 104, 105, 96, 105, 105, 101, + 106, 98, 106, 106, 911, 991, 990, 101, 108, 108, + 108, 108, 102, 112, 104, 989, 988, 103, 110, 110, + 110, 110, 986, 114, 104, 102, 114, 103, 105, 105, + 985, 105, 114, 106, 118, 104, 119, 118, 984, 119, + 983, 108, 120, 129, 982, 120, 129, 121, 106, 118, + 121, 110, 122, 981, 129, 122, 114, 125, 119, 127, + 125, 123, 127, 121, 123, 119, 121, 118, 122, 119, + 121, 120, 123, 121, 126, 120, 129, 126, 124, 122, + 121, 124, 980, 979, 125, 122, 123, 942, 127, 124, + + 125, 941, 127, 939, 123, 128, 126, 130, 128, 938, + 130, 131, 131, 131, 131, 132, 124, 126, 132, 936, + 935, 124, 130, 128, 133, 133, 133, 133, 931, 134, + 135, 134, 134, 135, 136, 128, 134, 136, 128, 137, + 130, 930, 137, 138, 131, 136, 138, 139, 132, 929, + 139, 132, 928, 923, 922, 141, 921, 133, 141, 136, + 920, 140, 134, 135, 140, 536, 919, 136, 536, 918, + 139, 917, 137, 916, 915, 171, 138, 914, 171, 913, + 139, 142, 142, 142, 142, 137, 138, 912, 141, 910, + 909, 139, 908, 907, 140, 140, 848, 140, 144, 144, + + 144, 144, 846, 141, 165, 165, 165, 165, 171, 172, + 172, 172, 172, 536, 142, 174, 174, 174, 174, 176, + 176, 176, 176, 238, 238, 238, 238, 243, 845, 243, + 243, 144, 244, 844, 244, 244, 843, 165, 245, 245, + 245, 245, 172, 246, 246, 246, 246, 842, 174, 841, + 839, 836, 176, 248, 248, 248, 248, 835, 834, 833, + 243, 249, 249, 249, 249, 244, 251, 832, 251, 251, + 830, 245, 238, 821, 820, 251, 246, 819, 252, 818, + 252, 252, 253, 817, 253, 253, 248, 254, 816, 254, + 254, 815, 255, 253, 255, 255, 814, 813, 812, 251, + + 252, 256, 811, 256, 256, 257, 810, 257, 257, 254, + 809, 252, 256, 808, 258, 253, 258, 258, 255, 260, + 254, 260, 260, 291, 257, 255, 291, 807, 259, 258, + 259, 259, 806, 261, 256, 261, 261, 262, 257, 262, + 262, 804, 292, 259, 261, 292, 299, 258, 260, 299, + 803, 263, 260, 263, 263, 299, 291, 264, 261, 264, + 264, 259, 802, 801, 262, 265, 261, 265, 265, 266, + 262, 266, 266, 263, 267, 292, 267, 267, 268, 299, + 268, 268, 264, 301, 263, 269, 301, 269, 269, 800, + 264, 799, 265, 266, 301, 798, 575, 267, 265, 575, + + 797, 796, 266, 270, 269, 270, 270, 267, 268, 795, + 271, 268, 271, 271, 270, 794, 301, 272, 269, 272, + 272, 273, 793, 273, 273, 274, 792, 274, 274, 271, + 723, 722, 278, 273, 278, 278, 270, 275, 720, 275, + 275, 719, 274, 271, 575, 717, 280, 272, 280, 280, + 272, 716, 308, 715, 273, 308, 275, 713, 274, 275, + 276, 276, 276, 276, 281, 278, 281, 281, 712, 278, + 275, 282, 282, 282, 282, 283, 711, 283, 283, 280, + 284, 308, 284, 284, 285, 308, 285, 285, 286, 710, + 286, 286, 287, 276, 287, 287, 709, 281, 708, 286, + + 300, 283, 283, 300, 282, 707, 704, 288, 283, 288, + 288, 702, 701, 284, 284, 287, 289, 285, 289, 289, + 285, 286, 300, 700, 290, 287, 290, 290, 699, 293, + 293, 293, 293, 300, 302, 304, 287, 302, 304, 698, + 288, 294, 294, 294, 294, 303, 304, 288, 303, 289, + 296, 296, 296, 296, 697, 696, 302, 290, 694, 693, + 692, 289, 293, 297, 297, 297, 297, 302, 304, 305, + 306, 303, 305, 306, 294, 691, 307, 310, 303, 307, + 310, 309, 690, 296, 309, 306, 311, 312, 305, 311, + 312, 307, 309, 314, 313, 315, 314, 313, 315, 689, + + 687, 686, 305, 306, 310, 685, 309, 684, 311, 307, + 310, 683, 312, 316, 309, 682, 316, 314, 315, 311, + 312, 313, 317, 681, 680, 317, 314, 313, 315, 318, + 319, 320, 318, 319, 320, 321, 322, 679, 321, 322, + 318, 317, 327, 316, 678, 327, 316, 321, 323, 319, + 677, 323, 676, 322, 675, 317, 324, 324, 324, 324, + 674, 320, 318, 319, 320, 673, 672, 323, 321, 322, + 323, 326, 326, 326, 326, 327, 671, 670, 669, 327, + 329, 323, 329, 329, 668, 667, 666, 329, 330, 324, + 330, 330, 665, 664, 663, 330, 331, 331, 331, 331, + + 662, 332, 333, 331, 332, 333, 334, 335, 336, 334, + 335, 336, 338, 329, 337, 338, 339, 337, 335, 339, + 661, 330, 340, 340, 340, 340, 660, 332, 332, 331, + 659, 336, 658, 657, 332, 333, 333, 580, 578, 334, + 335, 336, 334, 383, 577, 338, 383, 337, 344, 339, + 344, 344, 336, 384, 337, 340, 384, 338, 342, 342, + 342, 342, 343, 343, 343, 343, 372, 372, 372, 372, + 385, 385, 385, 385, 576, 572, 383, 386, 386, 386, + 386, 344, 388, 388, 388, 388, 384, 389, 389, 389, + 389, 342, 390, 571, 390, 390, 391, 391, 391, 391, + + 570, 569, 568, 385, 393, 393, 393, 393, 567, 566, + 386, 421, 421, 421, 421, 388, 428, 428, 428, 428, + 429, 429, 429, 429, 437, 390, 437, 437, 565, 391, + 430, 430, 430, 430, 432, 432, 432, 432, 433, 433, + 433, 433, 435, 435, 435, 435, 564, 436, 437, 436, + 436, 438, 579, 438, 438, 579, 563, 437, 436, 439, + 562, 439, 439, 561, 440, 428, 440, 440, 560, 429, + 487, 433, 441, 487, 441, 441, 438, 559, 558, 430, + 436, 440, 557, 442, 438, 442, 442, 443, 439, 443, + 443, 487, 439, 444, 441, 444, 444, 440, 443, 445, + + 579, 445, 445, 487, 556, 441, 442, 446, 444, 446, + 446, 447, 555, 447, 447, 449, 442, 449, 449, 554, + 443, 553, 448, 552, 448, 448, 444, 445, 449, 551, + 550, 446, 445, 448, 549, 450, 447, 450, 450, 451, + 446, 451, 451, 452, 447, 452, 452, 448, 449, 453, + 548, 453, 453, 547, 546, 448, 450, 545, 452, 544, + 454, 453, 454, 454, 540, 539, 688, 451, 450, 688, + 538, 455, 451, 455, 455, 454, 452, 456, 537, 456, + 456, 534, 453, 473, 455, 457, 473, 457, 457, 458, + 533, 458, 458, 454, 473, 459, 532, 459, 459, 456, + + 461, 457, 461, 461, 455, 462, 531, 462, 462, 460, + 456, 460, 460, 461, 688, 529, 473, 458, 457, 528, + 458, 475, 458, 459, 475, 527, 460, 526, 459, 463, + 463, 463, 463, 461, 464, 464, 464, 464, 462, 462, + 525, 465, 460, 465, 465, 466, 475, 466, 466, 467, + 524, 467, 467, 468, 475, 468, 468, 469, 476, 469, + 469, 476, 463, 470, 470, 470, 470, 464, 472, 472, + 472, 472, 523, 474, 465, 467, 474, 477, 466, 522, + 477, 478, 467, 521, 478, 466, 468, 476, 519, 465, + 469, 476, 468, 518, 477, 517, 470, 474, 469, 479, + + 516, 480, 479, 478, 480, 481, 474, 515, 481, 514, + 477, 513, 480, 482, 478, 483, 482, 512, 483, 511, + 481, 510, 479, 488, 484, 485, 488, 484, 485, 509, + 486, 508, 479, 486, 480, 427, 485, 489, 481, 483, + 489, 482, 490, 486, 491, 490, 482, 491, 483, 484, + 485, 488, 489, 426, 490, 425, 488, 484, 485, 491, + 424, 492, 493, 486, 492, 493, 494, 423, 420, 494, + 489, 419, 418, 495, 492, 490, 495, 491, 498, 417, + 496, 498, 494, 496, 493, 497, 499, 415, 497, 499, + 414, 498, 413, 721, 492, 493, 721, 503, 412, 494, + + 503, 495, 497, 411, 495, 410, 495, 505, 496, 504, + 505, 498, 504, 496, 500, 500, 500, 500, 497, 499, + 499, 500, 501, 501, 501, 501, 502, 502, 502, 502, + 503, 506, 507, 505, 506, 507, 535, 535, 535, 535, + 505, 721, 504, 409, 408, 503, 407, 500, 405, 504, + 541, 541, 541, 541, 543, 543, 543, 543, 404, 502, + 573, 573, 573, 573, 506, 507, 581, 581, 581, 581, + 506, 403, 402, 507, 583, 583, 583, 583, 584, 584, + 584, 584, 401, 541, 586, 586, 586, 586, 587, 623, + 587, 587, 623, 588, 940, 588, 588, 940, 589, 400, + + 589, 589, 623, 399, 398, 587, 588, 590, 397, 590, + 590, 591, 396, 591, 591, 581, 395, 592, 394, 592, + 592, 587, 623, 382, 381, 590, 588, 584, 589, 379, + 378, 589, 592, 593, 377, 593, 593, 374, 622, 591, + 590, 622, 940, 593, 591, 594, 370, 594, 594, 595, + 592, 595, 595, 369, 596, 622, 596, 596, 597, 368, + 597, 597, 598, 367, 598, 598, 593, 599, 366, 599, + 599, 622, 595, 987, 594, 596, 987, 600, 594, 600, + 600, 365, 595, 364, 599, 363, 597, 596, 598, 362, + 601, 597, 601, 601, 602, 598, 602, 602, 361, 360, + + 599, 359, 600, 603, 358, 603, 603, 356, 355, 602, + 600, 601, 604, 603, 604, 604, 605, 354, 605, 605, + 353, 987, 604, 601, 352, 351, 606, 602, 606, 606, + 350, 607, 349, 607, 607, 631, 603, 608, 631, 608, + 608, 348, 347, 241, 605, 604, 607, 237, 234, 605, + 606, 609, 608, 609, 609, 233, 631, 231, 610, 606, + 610, 610, 230, 611, 607, 611, 611, 609, 631, 612, + 608, 612, 612, 634, 611, 613, 634, 613, 613, 612, + 614, 228, 614, 614, 609, 223, 615, 610, 615, 615, + 634, 610, 617, 613, 617, 617, 611, 616, 616, 616, + + 616, 618, 612, 618, 618, 614, 634, 219, 613, 619, + 218, 619, 619, 614, 216, 620, 215, 620, 620, 615, + 621, 624, 621, 621, 624, 617, 625, 214, 626, 625, + 616, 626, 615, 629, 618, 211, 629, 209, 633, 208, + 617, 633, 619, 627, 625, 204, 627, 202, 620, 618, + 620, 624, 201, 621, 624, 619, 626, 628, 627, 625, + 628, 626, 629, 200, 633, 199, 629, 628, 621, 630, + 632, 633, 630, 632, 635, 636, 627, 635, 636, 637, + 198, 638, 637, 639, 638, 640, 639, 197, 640, 196, + 628, 638, 630, 639, 637, 195, 636, 641, 632, 635, + + 641, 997, 630, 632, 997, 194, 999, 635, 636, 999, + 193, 192, 637, 640, 638, 191, 639, 642, 640, 643, + 642, 641, 643, 644, 645, 646, 644, 645, 646, 190, + 641, 188, 642, 187, 643, 647, 646, 648, 647, 644, + 648, 649, 186, 650, 649, 647, 650, 185, 652, 997, + 642, 652, 643, 645, 999, 648, 644, 645, 646, 651, + 651, 651, 651, 184, 653, 183, 649, 653, 647, 654, + 648, 182, 654, 181, 649, 655, 650, 180, 655, 179, + 656, 652, 168, 656, 725, 167, 725, 725, 724, 650, + 724, 724, 651, 164, 162, 161, 652, 653, 726, 725, + + 726, 726, 654, 159, 727, 158, 727, 727, 655, 157, + 655, 152, 653, 656, 727, 654, 724, 725, 150, 148, + 728, 724, 728, 728, 729, 726, 729, 729, 656, 146, + 728, 726, 145, 730, 729, 730, 730, 727, 731, 71, + 731, 731, 732, 68, 732, 732, 66, 737, 731, 737, + 737, 64, 732, 728, 62, 59, 764, 729, 733, 764, + 733, 733, 734, 54, 734, 734, 730, 735, 733, 735, + 735, 731, 734, 51, 737, 732, 736, 735, 736, 736, + 737, 738, 48, 738, 738, 739, 47, 739, 739, 764, + 740, 733, 740, 740, 738, 734, 741, 42, 741, 741, + + 735, 41, 40, 742, 736, 742, 742, 38, 760, 736, + 738, 760, 739, 743, 738, 743, 743, 744, 739, 744, + 744, 37, 746, 740, 746, 746, 36, 744, 745, 741, + 745, 745, 742, 31, 29, 760, 742, 747, 745, 747, + 747, 760, 743, 27, 746, 25, 743, 747, 23, 748, + 744, 748, 748, 21, 749, 746, 749, 749, 17, 0, + 750, 745, 750, 750, 0, 751, 0, 751, 751, 752, + 747, 752, 752, 753, 761, 753, 753, 761, 754, 748, + 754, 754, 748, 755, 761, 755, 755, 749, 751, 750, + 0, 0, 756, 750, 756, 756, 0, 757, 751, 757, + + 757, 758, 752, 0, 758, 759, 753, 761, 759, 752, + 0, 754, 0, 754, 0, 0, 755, 755, 762, 0, + 759, 762, 0, 763, 774, 756, 763, 774, 762, 758, + 757, 0, 765, 763, 758, 765, 766, 0, 759, 766, + 756, 0, 765, 0, 767, 757, 766, 767, 0, 768, + 769, 762, 768, 769, 767, 0, 763, 774, 770, 768, + 769, 770, 0, 771, 0, 765, 771, 773, 772, 766, + 773, 772, 775, 776, 0, 775, 776, 767, 0, 0, + 0, 772, 768, 769, 777, 778, 770, 777, 778, 779, + 771, 770, 779, 0, 773, 778, 771, 772, 0, 779, + + 773, 772, 776, 0, 780, 775, 776, 780, 782, 781, + 0, 782, 781, 777, 0, 0, 0, 777, 778, 781, + 783, 784, 779, 783, 784, 785, 780, 786, 785, 787, + 786, 788, 787, 0, 788, 0, 789, 780, 782, 789, + 790, 782, 781, 790, 791, 0, 0, 791, 785, 849, + 784, 849, 849, 783, 784, 0, 0, 0, 785, 849, + 786, 0, 787, 0, 788, 881, 788, 786, 881, 789, + 789, 0, 852, 790, 852, 852, 850, 791, 850, 850, + 0, 851, 849, 851, 851, 0, 850, 853, 790, 853, + 853, 851, 791, 854, 0, 854, 854, 855, 881, 855, + + 855, 856, 0, 856, 856, 852, 0, 0, 857, 850, + 857, 857, 0, 858, 851, 858, 858, 0, 0, 859, + 853, 859, 859, 0, 0, 860, 854, 860, 860, 862, + 855, 862, 862, 0, 856, 860, 861, 0, 861, 861, + 863, 857, 863, 863, 0, 864, 858, 864, 864, 861, + 0, 0, 859, 882, 862, 864, 882, 878, 860, 863, + 878, 865, 862, 865, 865, 861, 0, 878, 0, 861, + 0, 865, 866, 863, 866, 866, 0, 867, 864, 867, + 867, 868, 866, 868, 868, 869, 882, 869, 869, 870, + 878, 870, 870, 871, 865, 871, 871, 0, 0, 872, + + 869, 872, 872, 0, 873, 866, 873, 873, 0, 872, + 867, 0, 0, 883, 868, 871, 883, 0, 869, 873, + 0, 874, 870, 874, 874, 875, 871, 875, 875, 0, + 0, 876, 872, 876, 876, 0, 877, 873, 877, 877, + 879, 880, 884, 879, 880, 884, 883, 0, 0, 885, + 879, 880, 885, 886, 874, 0, 886, 887, 875, 888, + 887, 875, 888, 0, 876, 890, 874, 889, 890, 877, + 889, 0, 0, 879, 880, 884, 876, 889, 890, 0, + 891, 0, 885, 891, 892, 893, 886, 892, 893, 0, + 887, 0, 888, 0, 890, 893, 894, 0, 890, 894, + + 889, 895, 0, 892, 895, 891, 894, 896, 0, 897, + 896, 895, 897, 891, 0, 0, 898, 892, 893, 898, + 899, 900, 901, 899, 900, 901, 0, 0, 0, 894, + 902, 898, 901, 902, 895, 903, 904, 0, 903, 904, + 896, 905, 897, 900, 905, 902, 0, 0, 906, 898, + 0, 906, 0, 899, 900, 901, 943, 0, 943, 943, + 0, 0, 944, 902, 944, 944, 0, 0, 903, 904, + 0, 0, 904, 945, 905, 945, 945, 0, 0, 0, + 903, 906, 946, 0, 946, 946, 905, 0, 947, 943, + 947, 947, 0, 0, 0, 944, 0, 948, 0, 948, + + 948, 949, 0, 949, 949, 950, 945, 950, 950, 951, + 0, 951, 951, 947, 0, 946, 948, 952, 0, 952, + 952, 947, 953, 949, 953, 953, 954, 950, 954, 954, + 948, 0, 961, 0, 949, 961, 954, 955, 950, 955, + 955, 956, 951, 956, 956, 0, 957, 0, 957, 957, + 952, 959, 0, 959, 959, 953, 957, 0, 962, 954, + 958, 962, 958, 958, 963, 961, 955, 963, 958, 960, + 955, 960, 960, 964, 956, 965, 964, 966, 965, 957, + 966, 0, 967, 969, 959, 967, 969, 968, 0, 970, + 968, 962, 970, 958, 0, 971, 966, 963, 971, 959, + + 965, 0, 960, 0, 967, 960, 964, 0, 965, 968, + 966, 972, 0, 0, 972, 967, 969, 0, 0, 0, + 968, 972, 970, 973, 974, 0, 973, 974, 971, 975, + 976, 977, 975, 976, 977, 0, 0, 978, 976, 975, + 978, 0, 0, 1000, 972, 1000, 1000, 1001, 0, 1001, + 1001, 1002, 973, 1002, 1002, 0, 973, 974, 0, 0, + 0, 1002, 975, 976, 977, 1000, 0, 0, 0, 1001, + 978, 0, 1003, 978, 1003, 1003, 1000, 0, 0, 977, + 1001, 0, 0, 1004, 1002, 1004, 1004, 1003, 1005, 0, + 1005, 1005, 1006, 1011, 1006, 1006, 1011, 1007, 1005, 1007, + + 1007, 1008, 0, 1008, 1008, 1003, 1009, 0, 1009, 1009, + 1010, 1012, 1010, 1010, 1012, 1011, 1004, 1013, 0, 1028, + 1013, 1005, 1028, 0, 0, 1006, 1011, 1013, 1015, 0, + 1007, 1015, 1007, 1012, 1008, 1016, 0, 1014, 1016, 1009, + 1014, 0, 0, 1010, 1012, 1016, 0, 0, 1017, 1008, + 1013, 1017, 1014, 1018, 1009, 0, 1018, 1019, 1010, 1020, + 1019, 1015, 1020, 1021, 0, 0, 1021, 1028, 1016, 1036, + 1014, 1049, 1036, 1038, 1049, 1038, 1038, 1040, 0, 1040, + 1040, 1017, 1039, 1038, 1039, 1039, 1018, 0, 1018, 0, + 1019, 1041, 1020, 1041, 1041, 0, 1021, 1039, 0, 0, + + 1042, 1041, 1042, 1042, 1049, 1019, 1038, 1020, 0, 1051, + 1040, 1021, 1051, 0, 0, 1039, 1043, 1036, 1043, 1043, + 1044, 0, 1044, 1044, 1041, 1045, 0, 1045, 1045, 1046, + 0, 1046, 1046, 1042, 1047, 1048, 1050, 1047, 1048, 1050, + 0, 0, 1051, 0, 1047, 1052, 1050, 0, 1052, 1043, + 1048, 1053, 1043, 1044, 1053, 0, 1054, 1055, 1045, 1054, + 1055, 1065, 1046, 1065, 1065, 0, 0, 1047, 1048, 1050, + 0, 0, 0, 1045, 0, 0, 0, 1046, 1052, 1070, + 0, 1052, 1070, 1066, 1053, 1066, 1066, 0, 1072, 1054, + 1055, 1072, 0, 1066, 1065, 1067, 0, 1067, 1067, 1068, + + 1071, 1068, 1068, 1071, 1054, 1055, 1069, 0, 1069, 1069, + 1071, 1073, 1070, 0, 1073, 1074, 1066, 1079, 1074, 1079, + 1079, 1072, 1080, 1081, 1080, 1080, 1081, 1082, 1067, 0, + 1082, 1086, 1068, 1071, 1086, 1085, 0, 1085, 1085, 1069, + 0, 1068, 0, 1093, 1073, 1093, 1093, 0, 1074, 1089, + 1079, 1089, 1089, 1073, 1094, 1080, 1081, 1094, 0, 1089, + 1082, 0, 0, 0, 1086, 0, 0, 1080, 1085, 1086, + 0, 1090, 1082, 1085, 1090, 0, 1093, 0, 0, 0, + 0, 1090, 1089, 0, 0, 0, 0, 1094, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 1090, 1096, 1096, 1096, 1096, 1096, + 1096, 1097, 1097, 1097, 1097, 1097, 1097, 1098, 1098, 1098, + 1098, 1098, 1098, 1099, 1099, 1099, 1099, 1099, 1099, 1100, + 1100, 1100, 1100, 1100, 1100, 1101, 1101, 0, 1101, 1101, + 1101, 1102, 1102, 1102, 1102, 1102, 1102, 1103, 0, 0, + 0, 1103, 1103, 1104, 1104, 1104, 1104, 1104, 1104, 1105, + 1105, 0, 0, 1105, 1105, 1106, 1106, 1106, 1106, 1106, + 1106, 1107, 1107, 0, 1107, 1107, 1107, 1108, 1108, 0, + 1108, 1108, 1108, 1109, 1109, 0, 0, 0, 1109, 1110, + 1110, 0, 1110, 1110, 1110, 1112, 1112, 0, 0, 0, + + 1112, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, 1095, + 1095, 1095, 1095 } ; /* Table of booleans, true if rule could match eol. */ -static yyconst flex_int32_t yy_rule_can_match_eol[81] = +static yyconst flex_int32_t yy_rule_can_match_eol[82] = { 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, - 0, }; + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, }; static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; @@ -1734,7 +1766,7 @@ static void cattext(bool trim_right = false, int strip_trailing = 0) -#line 1738 "levcomp.lex.cc" +#line 1770 "levcomp.lex.cc" #define INITIAL 0 #define MAPDEF 1 @@ -1759,35 +1791,6 @@ static void cattext(bool trim_right = false, int strip_trailing = 0) static int yy_init_globals (void ); -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy (void ); - -int yyget_debug (void ); - -void yyset_debug (int debug_flag ); - -YY_EXTRA_TYPE yyget_extra (void ); - -void yyset_extra (YY_EXTRA_TYPE user_defined ); - -FILE *yyget_in (void ); - -void yyset_in (FILE * in_str ); - -FILE *yyget_out (void ); - -void yyset_out (FILE * out_str ); - -int yyget_leng (void ); - -char *yyget_text (void ); - -int yyget_lineno (void ); - -void yyset_lineno (int line_number ); - /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -1830,7 +1833,7 @@ static int input (void ); /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ -#define ECHO fwrite( yytext, yyleng, 1, yyout ) +#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -1841,7 +1844,7 @@ static int input (void ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -1929,7 +1932,7 @@ YY_DECL #line 133 "levcomp.lpp" -#line 1933 "levcomp.lex.cc" +#line 1936 "levcomp.lex.cc" if ( !(yy_init) ) { @@ -1983,13 +1986,13 @@ 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 >= 1073 ) + if ( yy_current_state >= 1096 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_current_state != 1072 ); + while ( yy_current_state != 1095 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); @@ -2435,40 +2438,40 @@ YY_RULE_SETUP YY_BREAK case 72: YY_RULE_SETUP -#line 265 "levcomp.lpp" -return COMMA; +#line 264 "levcomp.lpp" +{ CBEGIN(ARGUMENT); return SUBVAULT; } YY_BREAK case 73: YY_RULE_SETUP -#line 267 "levcomp.lpp" -return COLON; +#line 266 "levcomp.lpp" +return COMMA; YY_BREAK case 74: YY_RULE_SETUP -#line 269 "levcomp.lpp" -return PERC; +#line 268 "levcomp.lpp" +return COLON; YY_BREAK case 75: YY_RULE_SETUP -#line 271 "levcomp.lpp" +#line 270 "levcomp.lpp" +return PERC; + YY_BREAK +case 76: +YY_RULE_SETUP +#line 272 "levcomp.lpp" { clean(); yylval.i = atoi(yytext); return INTEGER; } YY_BREAK -case 76: -YY_RULE_SETUP -#line 277 "levcomp.lpp" -; - YY_BREAK case 77: -/* rule 77 can match eol */ YY_RULE_SETUP #line 278 "levcomp.lpp" ; YY_BREAK case 78: +/* rule 78 can match eol */ YY_RULE_SETUP #line 279 "levcomp.lpp" ; @@ -2476,14 +2479,19 @@ YY_RULE_SETUP case 79: YY_RULE_SETUP #line 280 "levcomp.lpp" -return CHARACTER; +; YY_BREAK case 80: YY_RULE_SETUP -#line 282 "levcomp.lpp" +#line 281 "levcomp.lpp" +return CHARACTER; + YY_BREAK +case 81: +YY_RULE_SETUP +#line 283 "levcomp.lpp" ECHO; YY_BREAK -#line 2487 "levcomp.lex.cc" +#line 2495 "levcomp.lex.cc" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(MAPDEF): case YY_STATE_EOF(LUA): @@ -2722,7 +2730,7 @@ static int yy_get_next_buffer (void) /* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), (size_t) num_to_read ); + (yy_n_chars), num_to_read ); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } @@ -2746,14 +2754,6 @@ static int yy_get_next_buffer (void) else ret_val = EOB_ACT_CONTINUE_SCAN; - if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - } - (yy_n_chars) += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; @@ -2784,7 +2784,7 @@ static int yy_get_next_buffer (void) 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 >= 1073 ) + if ( yy_current_state >= 1096 ) yy_c = yy_meta[(unsigned int) yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; @@ -2812,11 +2812,11 @@ static int yy_get_next_buffer (void) 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 >= 1073 ) + if ( yy_current_state >= 1096 ) 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 == 1072); + yy_is_jam = (yy_current_state == 1095); return yy_is_jam ? 0 : yy_current_state; } @@ -2910,7 +2910,7 @@ static int yy_get_next_buffer (void) case EOB_ACT_END_OF_FILE: { if ( yywrap( ) ) - return EOF; + return 0; if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; @@ -3176,9 +3176,7 @@ static void yyensure_buffer_stack (void) (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; @@ -3196,8 +3194,6 @@ static void yyensure_buffer_stack (void) ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); /* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); @@ -3242,7 +3238,7 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) /** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan + * @param str a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use @@ -3499,7 +3495,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 282 "levcomp.lpp" +#line 283 "levcomp.lpp" diff --git a/crawl-ref/source/prebuilt/levcomp.tab.cc b/crawl-ref/source/prebuilt/levcomp.tab.cc index 0fd21dd9dd..5c3e88f475 100644 --- a/crawl-ref/source/prebuilt/levcomp.tab.cc +++ b/crawl-ref/source/prebuilt/levcomp.tab.cc @@ -99,16 +99,17 @@ LROCKTILE = 288, FTILE = 289, RTILE = 290, - COMMA = 291, - COLON = 292, - PERC = 293, - INTEGER = 294, - CHARACTER = 295, - STRING = 296, - MAP_LINE = 297, - MONSTER_NAME = 298, - ITEM_INFO = 299, - LUA_LINE = 300 + SUBVAULT = 291, + COMMA = 292, + COLON = 293, + PERC = 294, + INTEGER = 295, + CHARACTER = 296, + STRING = 297, + MAP_LINE = 298, + MONSTER_NAME = 299, + ITEM_INFO = 300, + LUA_LINE = 301 }; #endif /* Tokens. */ @@ -145,16 +146,17 @@ #define LROCKTILE 288 #define FTILE 289 #define RTILE 290 -#define COMMA 291 -#define COLON 292 -#define PERC 293 -#define INTEGER 294 -#define CHARACTER 295 -#define STRING 296 -#define MAP_LINE 297 -#define MONSTER_NAME 298 -#define ITEM_INFO 299 -#define LUA_LINE 300 +#define SUBVAULT 291 +#define COMMA 292 +#define COLON 293 +#define PERC 294 +#define INTEGER 295 +#define CHARACTER 296 +#define STRING 297 +#define MAP_LINE 298 +#define MONSTER_NAME 299 +#define ITEM_INFO 300 +#define LUA_LINE 301 @@ -230,8 +232,8 @@ typedef union YYSTYPE const char *text; raw_range range; } -/* Line 187 of yacc.c. */ -#line 235 "levcomp.tab.c" +/* Line 193 of yacc.c. */ +#line 237 "levcomp.tab.c" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 @@ -244,7 +246,7 @@ typedef union YYSTYPE /* Line 216 of yacc.c. */ -#line 248 "levcomp.tab.c" +#line 250 "levcomp.tab.c" #ifdef short # undef short @@ -294,7 +296,7 @@ typedef short int yytype_int16; #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) #ifndef YY_ -# if YYENABLE_NLS +# if defined YYENABLE_NLS && YYENABLE_NLS # if ENABLE_NLS # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ # define YY_(msgid) dgettext ("bison-runtime", msgid) @@ -459,20 +461,20 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 3 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 106 +#define YYLAST 107 /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 46 +#define YYNTOKENS 47 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 75 +#define YYNNTS 78 /* YYNRULES -- Number of rules. */ -#define YYNRULES 142 +#define YYNRULES 147 /* YYNRULES -- Number of states. */ -#define YYNSTATES 167 +#define YYNSTATES 174 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 -#define YYMAXUTOK 300 +#define YYMAXUTOK 301 #define YYTRANSLATE(YYX) \ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) @@ -510,7 +512,7 @@ static const yytype_uint8 yytranslate[] = 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 + 45, 46 }; #if YYDEBUG @@ -523,56 +525,57 @@ static const yytype_uint16 yyprhs[] = 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, - 103, 104, 107, 109, 112, 113, 116, 118, 121, 122, - 125, 127, 130, 131, 134, 136, 139, 140, 143, 145, - 147, 150, 152, 155, 157, 160, 162, 165, 167, 170, - 173, 175, 179, 181, 184, 185, 188, 190, 193, 196, - 199, 202, 204, 207, 209, 212, 214, 217, 219, 222, - 225, 227, 231, 233, 236, 238, 242, 244, 246, 250, - 252, 255, 257, 261, 263, 266, 268, 272, 274, 276, - 279, 283, 285, 287, 289, 292, 296, 298, 300, 303, - 305, 308, 314, 319, 323, 326, 329, 331, 334, 337, - 339, 342, 344 + 102, 105, 106, 109, 111, 114, 115, 118, 120, 123, + 124, 127, 129, 132, 133, 136, 138, 141, 142, 145, + 147, 149, 152, 154, 157, 159, 162, 164, 167, 169, + 172, 175, 177, 181, 183, 186, 187, 190, 192, 195, + 198, 201, 204, 206, 209, 211, 214, 216, 219, 221, + 224, 227, 229, 233, 235, 238, 240, 244, 246, 248, + 252, 254, 257, 259, 263, 265, 268, 270, 274, 276, + 278, 281, 285, 287, 289, 291, 294, 298, 300, 302, + 305, 307, 310, 316, 321, 325, 328, 331, 333, 336, + 339, 341, 344, 346, 348, 351, 353, 357 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int8 yyrhs[] = { - 47, 0, -1, 48, -1, -1, 48, 49, -1, 51, - -1, 53, -1, 40, -1, 52, -1, 58, -1, 3, - 41, -1, 56, 54, -1, -1, 54, 55, -1, 57, - -1, 118, -1, 12, 41, -1, 112, -1, 113, -1, - 114, -1, 115, -1, 116, -1, 117, -1, 109, -1, - 106, -1, 86, -1, 103, -1, 100, -1, 87, -1, - 88, -1, 89, -1, 90, -1, 91, -1, 92, -1, - 95, -1, 78, -1, 81, -1, 84, -1, 85, -1, - 73, -1, 75, -1, 74, -1, 76, -1, 77, -1, - 61, -1, 70, -1, 64, -1, 67, -1, 50, -1, - 23, 59, -1, -1, 59, 60, -1, 45, -1, 23, - 62, -1, -1, 62, 63, -1, 45, -1, 24, 65, - -1, -1, 65, 66, -1, 45, -1, 25, 68, -1, - -1, 68, 69, -1, 45, -1, 22, 71, -1, -1, - 71, 72, -1, 45, -1, 7, -1, 7, 41, -1, - 9, -1, 9, 41, -1, 8, -1, 8, 41, -1, - 10, -1, 10, 41, -1, 11, -1, 11, 41, -1, - 4, 79, -1, 80, -1, 79, 36, 80, -1, 44, - -1, 6, 82, -1, -1, 82, 83, -1, 41, -1, - 28, 41, -1, 29, 41, -1, 20, 41, -1, 21, - 98, -1, 30, -1, 30, 41, -1, 31, -1, 31, - 41, -1, 32, -1, 32, 41, -1, 33, -1, 33, - 41, -1, 34, 93, -1, 94, -1, 93, 36, 94, - -1, 44, -1, 35, 96, -1, 97, -1, 96, 36, - 97, -1, 44, -1, 99, -1, 98, 36, 99, -1, - 44, -1, 26, 101, -1, 102, -1, 101, 36, 102, - -1, 44, -1, 5, 104, -1, 105, -1, 105, 36, - 104, -1, 44, -1, 19, -1, 19, 107, -1, 107, - 36, 108, -1, 108, -1, 44, -1, 18, -1, 18, - 110, -1, 111, 36, 110, -1, 111, -1, 43, -1, - 15, 41, -1, 13, -1, 13, 41, -1, 16, 39, - 37, 39, 38, -1, 16, 39, 37, 39, -1, 16, - 39, 38, -1, 16, 39, -1, 17, 39, -1, 14, - -1, 14, 41, -1, 27, 41, -1, 119, -1, 119, - 120, -1, 120, -1, 42, -1 + 48, 0, -1, 49, -1, -1, 49, 50, -1, 52, + -1, 54, -1, 41, -1, 53, -1, 59, -1, 3, + 42, -1, 57, 55, -1, -1, 55, 56, -1, 58, + -1, 119, -1, 12, 42, -1, 113, -1, 114, -1, + 115, -1, 116, -1, 117, -1, 118, -1, 110, -1, + 107, -1, 87, -1, 104, -1, 101, -1, 88, -1, + 89, -1, 90, -1, 91, -1, 92, -1, 93, -1, + 96, -1, 79, -1, 82, -1, 85, -1, 86, -1, + 74, -1, 76, -1, 75, -1, 77, -1, 78, -1, + 122, -1, 62, -1, 71, -1, 65, -1, 68, -1, + 51, -1, 23, 60, -1, -1, 60, 61, -1, 46, + -1, 23, 63, -1, -1, 63, 64, -1, 46, -1, + 24, 66, -1, -1, 66, 67, -1, 46, -1, 25, + 69, -1, -1, 69, 70, -1, 46, -1, 22, 72, + -1, -1, 72, 73, -1, 46, -1, 7, -1, 7, + 42, -1, 9, -1, 9, 42, -1, 8, -1, 8, + 42, -1, 10, -1, 10, 42, -1, 11, -1, 11, + 42, -1, 4, 80, -1, 81, -1, 80, 37, 81, + -1, 45, -1, 6, 83, -1, -1, 83, 84, -1, + 42, -1, 28, 42, -1, 29, 42, -1, 20, 42, + -1, 21, 99, -1, 30, -1, 30, 42, -1, 31, + -1, 31, 42, -1, 32, -1, 32, 42, -1, 33, + -1, 33, 42, -1, 34, 94, -1, 95, -1, 94, + 37, 95, -1, 45, -1, 35, 97, -1, 98, -1, + 97, 37, 98, -1, 45, -1, 100, -1, 99, 37, + 100, -1, 45, -1, 26, 102, -1, 103, -1, 102, + 37, 103, -1, 45, -1, 5, 105, -1, 106, -1, + 106, 37, 105, -1, 45, -1, 19, -1, 19, 108, + -1, 108, 37, 109, -1, 109, -1, 45, -1, 18, + -1, 18, 111, -1, 112, 37, 111, -1, 112, -1, + 44, -1, 15, 42, -1, 13, -1, 13, 42, -1, + 16, 40, 38, 40, 39, -1, 16, 40, 38, 40, + -1, 16, 40, 39, -1, 16, 40, -1, 17, 40, + -1, 14, -1, 14, 42, -1, 27, 42, -1, 120, + -1, 120, 121, -1, 121, -1, 43, -1, 36, 123, + -1, 124, -1, 123, 37, 124, -1, 42, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ @@ -582,17 +585,17 @@ static const yytype_uint16 yyrline[] = 87, 97, 119, 120, 123, 124, 127, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, - 174, 175, 176, 177, 178, 179, 180, 181, 182, 185, - 187, 188, 191, 196, 198, 199, 202, 207, 209, 210, - 213, 218, 220, 221, 224, 229, 231, 232, 235, 240, - 241, 249, 250, 258, 259, 267, 268, 276, 277, 285, - 288, 289, 292, 300, 303, 304, 307, 316, 325, 334, - 367, 370, 371, 379, 380, 388, 389, 397, 398, 407, - 410, 411, 414, 423, 426, 427, 430, 439, 440, 443, - 452, 455, 456, 459, 468, 471, 472, 475, 484, 485, - 488, 489, 492, 500, 501, 504, 505, 508, 517, 526, - 527, 536, 543, 550, 557, 565, 573, 574, 583, 592, - 595, 596, 599 + 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, + 186, 188, 189, 192, 197, 199, 200, 203, 208, 210, + 211, 214, 219, 221, 222, 225, 230, 232, 233, 236, + 241, 242, 250, 251, 259, 260, 268, 269, 277, 278, + 286, 289, 290, 293, 301, 304, 305, 308, 317, 326, + 335, 368, 371, 372, 380, 381, 389, 390, 398, 399, + 408, 411, 412, 415, 424, 427, 428, 431, 440, 441, + 444, 453, 456, 457, 460, 469, 472, 473, 476, 485, + 486, 489, 490, 493, 501, 502, 505, 506, 509, 518, + 527, 528, 537, 544, 551, 558, 566, 574, 575, 584, + 593, 596, 597, 600, 609, 612, 613, 616 }; #endif @@ -606,12 +609,12 @@ static const char *const yytname[] = "ORIENT", "PLACE", "CHANCE", "WEIGHT", "MONS", "ITEM", "MARKER", "COLOUR", "PRELUDE", "MAIN", "VALIDATE", "VETO", "NSUBST", "WELCOME", "LFLAGS", "BFLAGS", "LFLOORCOL", "LROCKCOL", "LFLOORTILE", "LROCKTILE", - "FTILE", "RTILE", "COMMA", "COLON", "PERC", "INTEGER", "CHARACTER", - "STRING", "MAP_LINE", "MONSTER_NAME", "ITEM_INFO", "LUA_LINE", "$accept", - "file", "definitions", "definition", "error_seq", "def", "defdepth", - "level", "map_specs", "map_spec", "name", "metaline", "global_lua", - "global_lua_lines", "global_lua_line", "main_lua", "main_lua_lines", - "main_lua_line", "validate_lua", "validate_lua_lines", + "FTILE", "RTILE", "SUBVAULT", "COMMA", "COLON", "PERC", "INTEGER", + "CHARACTER", "STRING", "MAP_LINE", "MONSTER_NAME", "ITEM_INFO", + "LUA_LINE", "$accept", "file", "definitions", "definition", "error_seq", + "def", "defdepth", "level", "map_specs", "map_spec", "name", "metaline", + "global_lua", "global_lua_lines", "global_lua_line", "main_lua", + "main_lua_lines", "main_lua_line", "validate_lua", "validate_lua_lines", "validate_lua_line", "veto_lua", "veto_lua_lines", "veto_lua_line", "prelude_lua", "prelude_lua_lines", "prelude_lua_line", "kfeat", "kmons", "kitem", "kmask", "kprop", "shuffle", "shuffle_specifiers", @@ -622,7 +625,8 @@ static const char *const yytname[] = "colour_specifier", "nsubst", "nsubst_specifiers", "nsubst_spec", "subst", "subst_specifiers", "subst_spec", "items", "item_specifiers", "item_specifier", "mons", "mnames", "mname", "place", "depth", "chance", - "weight", "orientation", "welcome", "map_def", "map_lines", "map_line", 0 + "weight", "orientation", "welcome", "map_def", "map_lines", "map_line", + "subvault", "subvault_specifiers", "subvault_specifier", 0 }; #endif @@ -635,28 +639,28 @@ static const yytype_uint16 yytoknum[] = 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, - 295, 296, 297, 298, 299, 300 + 295, 296, 297, 298, 299, 300, 301 }; # endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ static const yytype_uint8 yyr1[] = { - 0, 46, 47, 48, 48, 49, 49, 50, 51, 51, - 52, 53, 54, 54, 55, 55, 56, 57, 57, 57, - 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, - 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, - 57, 57, 57, 57, 57, 57, 57, 57, 57, 58, - 59, 59, 60, 61, 62, 62, 63, 64, 65, 65, - 66, 67, 68, 68, 69, 70, 71, 71, 72, 73, - 73, 74, 74, 75, 75, 76, 76, 77, 77, 78, - 79, 79, 80, 81, 82, 82, 83, 84, 85, 86, - 87, 88, 88, 89, 89, 90, 90, 91, 91, 92, - 93, 93, 94, 95, 96, 96, 97, 98, 98, 99, - 100, 101, 101, 102, 103, 104, 104, 105, 106, 106, - 107, 107, 108, 109, 109, 110, 110, 111, 112, 113, - 113, 114, 114, 114, 114, 115, 116, 116, 117, 118, - 119, 119, 120 + 0, 47, 48, 49, 49, 50, 50, 51, 52, 52, + 53, 54, 55, 55, 56, 56, 57, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, + 59, 60, 60, 61, 62, 63, 63, 64, 65, 66, + 66, 67, 68, 69, 69, 70, 71, 72, 72, 73, + 74, 74, 75, 75, 76, 76, 77, 77, 78, 78, + 79, 80, 80, 81, 82, 83, 83, 84, 85, 86, + 87, 88, 89, 89, 90, 90, 91, 91, 92, 92, + 93, 94, 94, 95, 96, 97, 97, 98, 99, 99, + 100, 101, 102, 102, 103, 104, 105, 105, 106, 107, + 107, 108, 108, 109, 110, 110, 111, 111, 112, 113, + 114, 114, 115, 115, 115, 115, 116, 117, 117, 118, + 119, 120, 120, 121, 122, 123, 123, 124 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -666,17 +670,17 @@ static const yytype_uint8 yyr2[] = 2, 2, 0, 2, 1, 1, 2, 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, - 0, 2, 1, 2, 0, 2, 1, 2, 0, 2, - 1, 2, 0, 2, 1, 2, 0, 2, 1, 1, - 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, - 1, 3, 1, 2, 0, 2, 1, 2, 2, 2, - 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, - 1, 3, 1, 2, 1, 3, 1, 1, 3, 1, - 2, 1, 3, 1, 2, 1, 3, 1, 1, 2, - 3, 1, 1, 1, 2, 3, 1, 1, 2, 1, - 2, 5, 4, 3, 2, 2, 1, 2, 2, 1, - 2, 1, 1 + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 0, 2, 1, 2, 0, 2, 1, 2, 0, + 2, 1, 2, 0, 2, 1, 2, 0, 2, 1, + 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 2, 1, 3, 1, 2, 0, 2, 1, 2, 2, + 2, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 2, 1, 3, 1, 2, 1, 3, 1, 1, 3, + 1, 2, 1, 3, 1, 2, 1, 3, 1, 1, + 2, 3, 1, 1, 1, 2, 3, 1, 1, 2, + 1, 2, 5, 4, 3, 2, 2, 1, 2, 2, + 1, 2, 1, 1, 2, 1, 3, 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -684,73 +688,75 @@ static const yytype_uint8 yyr2[] = means the default is an error. */ static const yytype_uint8 yydefact[] = { - 3, 0, 2, 1, 0, 0, 50, 4, 5, 8, - 6, 12, 9, 10, 16, 49, 11, 52, 51, 0, - 0, 84, 69, 73, 71, 75, 77, 129, 136, 0, - 0, 0, 123, 118, 0, 0, 66, 54, 58, 62, - 0, 0, 0, 0, 91, 93, 95, 97, 0, 0, - 7, 142, 48, 13, 14, 44, 46, 47, 45, 39, - 41, 40, 42, 43, 35, 36, 37, 38, 25, 28, - 29, 30, 31, 32, 33, 34, 27, 26, 24, 23, - 17, 18, 19, 20, 21, 22, 15, 139, 141, 82, - 79, 80, 117, 114, 115, 83, 70, 74, 72, 76, - 78, 130, 137, 128, 134, 135, 127, 124, 126, 122, - 119, 121, 89, 109, 90, 107, 65, 53, 57, 61, - 113, 110, 111, 138, 87, 88, 92, 94, 96, 98, - 102, 99, 100, 106, 103, 104, 140, 0, 0, 86, - 85, 0, 133, 0, 0, 0, 68, 67, 56, 55, - 60, 59, 64, 63, 0, 0, 0, 81, 116, 132, - 125, 120, 108, 112, 101, 105, 131 + 3, 0, 2, 1, 0, 0, 51, 4, 5, 8, + 6, 12, 9, 10, 16, 50, 11, 53, 52, 0, + 0, 85, 70, 74, 72, 76, 78, 130, 137, 0, + 0, 0, 124, 119, 0, 0, 67, 55, 59, 63, + 0, 0, 0, 0, 92, 94, 96, 98, 0, 0, + 0, 7, 143, 49, 13, 14, 45, 47, 48, 46, + 39, 41, 40, 42, 43, 35, 36, 37, 38, 25, + 28, 29, 30, 31, 32, 33, 34, 27, 26, 24, + 23, 17, 18, 19, 20, 21, 22, 15, 140, 142, + 44, 83, 80, 81, 118, 115, 116, 84, 71, 75, + 73, 77, 79, 131, 138, 129, 135, 136, 128, 125, + 127, 123, 120, 122, 90, 110, 91, 108, 66, 54, + 58, 62, 114, 111, 112, 139, 88, 89, 93, 95, + 97, 99, 103, 100, 101, 107, 104, 105, 147, 144, + 145, 141, 0, 0, 87, 86, 0, 134, 0, 0, + 0, 69, 68, 57, 56, 61, 60, 65, 64, 0, + 0, 0, 0, 82, 117, 133, 126, 121, 109, 113, + 102, 106, 146, 132 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 1, 2, 7, 52, 8, 9, 10, 16, 53, - 11, 54, 12, 15, 18, 55, 117, 149, 56, 118, - 151, 57, 119, 153, 58, 116, 147, 59, 60, 61, - 62, 63, 64, 90, 91, 65, 95, 140, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 131, 132, 75, - 134, 135, 114, 115, 76, 121, 122, 77, 93, 94, - 78, 110, 111, 79, 107, 108, 80, 81, 82, 83, - 84, 85, 86, 87, 88 + -1, 1, 2, 7, 53, 8, 9, 10, 16, 54, + 11, 55, 12, 15, 18, 56, 119, 154, 57, 120, + 156, 58, 121, 158, 59, 118, 152, 60, 61, 62, + 63, 64, 65, 92, 93, 66, 97, 145, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 133, 134, 76, + 136, 137, 116, 117, 77, 123, 124, 78, 95, 96, + 79, 112, 113, 80, 109, 110, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 139, 140 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -89 +#define YYPACT_NINF -93 static const yytype_int8 yypact[] = { - -89, 8, 29, -89, -8, -2, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -5, -4, -89, -89, -7, - -1, -89, 1, 3, 4, 5, 6, 7, 9, 10, - 14, 15, 12, 13, 17, 16, -89, -89, -89, -89, - 18, 20, 22, 23, 24, 25, 26, 27, 28, 30, - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, 31, -89, -89, - 33, -89, -89, -89, 34, 35, -89, -89, -89, -89, - -89, -89, -89, -89, -3, -89, -89, -89, 39, -89, - 41, -89, -89, -89, 42, -89, 11, 36, 37, 38, - -89, 43, -89, -89, -89, -89, -89, -89, -89, -89, - -89, 44, -89, -89, 48, -89, -89, -7, -1, -89, - -89, 32, -89, 12, 13, 16, -89, -89, -89, -89, - -89, -89, -89, -89, 18, 28, 30, -89, -89, 21, - -89, -89, -89, -89, -89, -89, -89 + -93, 8, 30, -93, -8, -2, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -5, -4, -93, -93, -7, + -1, -93, 1, 3, 4, 5, 6, 7, 9, 10, + 14, 15, 12, 13, 17, 16, -93, -93, -93, -93, + 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, + 33, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, 34, -93, + -93, -93, 35, -93, -93, -93, 39, 36, -93, -93, + -93, -93, -93, -93, -93, -93, -3, -93, -93, -93, + 42, -93, 43, -93, -93, -93, 44, -93, 11, 37, + 38, 40, -93, 45, -93, -93, -93, -93, -93, -93, + -93, -93, -93, 48, -93, -93, 50, -93, -93, 51, + -93, -93, -7, -1, -93, -93, 31, -93, 12, 13, + 16, -93, -93, -93, -93, -93, -93, -93, -93, 18, + 28, 29, 33, -93, -93, 21, -93, -93, -93, -93, + -93, -93, -93, -93 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int8 yypgoto[] = { - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -88, -89, -89, -89, -89, -89, - -89, -89, -89, -89, -89, -89, -89, -89, -70, -89, - -89, -69, -89, -59, -89, -89, -66, -89, -49, -89, - -89, -89, -54, -89, -52, -89, -89, -89, -89, -89, - -89, -89, -89, -89, 19 + -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -92, -93, -93, -93, -93, -93, + -93, -93, -93, -93, -93, -93, -93, -93, -90, -93, + -93, -72, -93, -60, -93, -93, -68, -93, -51, -93, + -93, -93, -56, -93, -54, -93, -93, -93, -93, -93, + -93, -93, -93, -93, 19, -93, -93, -67 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If @@ -763,14 +769,14 @@ static const yytype_uint8 yytable[] = 19, 20, 21, 22, 23, 24, 25, 26, 3, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 4, 13, 141, 142, 50, 89, 51, 14, - 17, 5, 96, 92, 97, 98, 99, 100, 101, 157, - 102, 103, 6, 104, 105, 106, 146, 109, 112, 166, - 113, 123, 120, 124, 125, 126, 127, 128, 129, 137, - 138, 159, 130, 51, 133, 143, 139, 144, 145, 154, - 155, 148, 150, 152, 156, 164, 162, 165, 163, 158, - 161, 160, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 136 + 48, 49, 50, 4, 13, 146, 147, 51, 91, 52, + 14, 17, 5, 98, 94, 99, 100, 101, 102, 103, + 163, 104, 105, 6, 106, 107, 108, 151, 111, 114, + 173, 115, 125, 122, 126, 127, 128, 129, 130, 131, + 170, 165, 142, 132, 135, 138, 143, 52, 144, 148, + 149, 150, 159, 153, 155, 160, 157, 161, 162, 171, + 168, 169, 164, 167, 166, 172, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 141 }; static const yytype_int16 yycheck[] = @@ -778,37 +784,38 @@ static const yytype_int16 yycheck[] = 4, 5, 6, 7, 8, 9, 10, 11, 0, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, - 34, 35, 3, 41, 37, 38, 40, 44, 42, 41, - 45, 12, 41, 44, 41, 41, 41, 41, 41, 137, - 41, 41, 23, 39, 39, 43, 45, 44, 41, 38, - 44, 41, 44, 41, 41, 41, 41, 41, 41, 36, - 36, 39, 44, 42, 44, 36, 41, 36, 36, 36, - 36, 45, 45, 45, 36, 155, 145, 156, 154, 138, - 144, 143, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 87 + 34, 35, 36, 3, 42, 38, 39, 41, 45, 43, + 42, 46, 12, 42, 45, 42, 42, 42, 42, 42, + 142, 42, 42, 23, 40, 40, 44, 46, 45, 42, + 39, 45, 42, 45, 42, 42, 42, 42, 42, 42, + 160, 40, 37, 45, 45, 42, 37, 43, 42, 37, + 37, 37, 37, 46, 46, 37, 46, 37, 37, 161, + 150, 159, 143, 149, 148, 162, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 88 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ static const yytype_uint8 yystos[] = { - 0, 47, 48, 0, 3, 12, 23, 49, 51, 52, - 53, 56, 58, 41, 41, 59, 54, 45, 60, 4, + 0, 48, 49, 0, 3, 12, 23, 50, 52, 53, + 54, 57, 59, 42, 42, 60, 55, 46, 61, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 40, 42, 50, 55, 57, 61, 64, 67, 70, 73, - 74, 75, 76, 77, 78, 81, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 95, 100, 103, 106, 109, - 112, 113, 114, 115, 116, 117, 118, 119, 120, 44, - 79, 80, 44, 104, 105, 82, 41, 41, 41, 41, - 41, 41, 41, 41, 39, 39, 43, 110, 111, 44, - 107, 108, 41, 44, 98, 99, 71, 62, 65, 68, - 44, 101, 102, 41, 41, 41, 41, 41, 41, 41, - 44, 93, 94, 44, 96, 97, 120, 36, 36, 41, - 83, 37, 38, 36, 36, 36, 45, 72, 45, 63, - 45, 66, 45, 69, 36, 36, 36, 80, 104, 39, - 110, 108, 99, 102, 94, 97, 38 + 36, 41, 43, 51, 56, 58, 62, 65, 68, 71, + 74, 75, 76, 77, 78, 79, 82, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 96, 101, 104, 107, + 110, 113, 114, 115, 116, 117, 118, 119, 120, 121, + 122, 45, 80, 81, 45, 105, 106, 83, 42, 42, + 42, 42, 42, 42, 42, 42, 40, 40, 44, 111, + 112, 45, 108, 109, 42, 45, 99, 100, 72, 63, + 66, 69, 45, 102, 103, 42, 42, 42, 42, 42, + 42, 42, 45, 94, 95, 45, 97, 98, 42, 123, + 124, 121, 37, 37, 42, 84, 38, 39, 37, 37, + 37, 46, 73, 46, 64, 46, 67, 46, 70, 37, + 37, 37, 37, 81, 105, 40, 111, 109, 100, 103, + 95, 98, 124, 39 }; #define yyerrok (yyerrstatus = 0) @@ -882,7 +889,7 @@ while (YYID (0)) we won't break user code: when these are the locations we know. */ #ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL +# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL # define YY_LOCATION_PRINT(File, Loc) \ fprintf (File, "%d.%d-%d.%d", \ (Loc).first_line, (Loc).first_column, \ @@ -1743,18 +1750,13 @@ yyreduce: } break; - case 48: -#line 182 "levcomp.ypp" - {} - break; - case 49: -#line 185 "levcomp.ypp" - { } +#line 183 "levcomp.ypp" + {} break; case 50: -#line 187 "levcomp.ypp" +#line 186 "levcomp.ypp" { } break; @@ -1764,19 +1766,19 @@ yyreduce: break; case 52: -#line 192 "levcomp.ypp" - { - lc_global_prelude.add(yylineno, (yyvsp[(1) - (1)].text)); - } +#line 189 "levcomp.ypp" + { } break; case 53: -#line 196 "levcomp.ypp" - { } +#line 193 "levcomp.ypp" + { + lc_global_prelude.add(yylineno, (yyvsp[(1) - (1)].text)); + } break; case 54: -#line 198 "levcomp.ypp" +#line 197 "levcomp.ypp" { } break; @@ -1786,19 +1788,19 @@ yyreduce: break; case 56: -#line 203 "levcomp.ypp" - { - lc_map.main.add(yylineno, (yyvsp[(1) - (1)].text)); - } +#line 200 "levcomp.ypp" + { } break; case 57: -#line 207 "levcomp.ypp" - { } +#line 204 "levcomp.ypp" + { + lc_map.main.add(yylineno, (yyvsp[(1) - (1)].text)); + } break; case 58: -#line 209 "levcomp.ypp" +#line 208 "levcomp.ypp" { } break; @@ -1808,19 +1810,19 @@ yyreduce: break; case 60: -#line 214 "levcomp.ypp" - { - lc_map.validate.add(yylineno, (yyvsp[(1) - (1)].text)); - } +#line 211 "levcomp.ypp" + { } break; case 61: -#line 218 "levcomp.ypp" - { } +#line 215 "levcomp.ypp" + { + lc_map.validate.add(yylineno, (yyvsp[(1) - (1)].text)); + } break; case 62: -#line 220 "levcomp.ypp" +#line 219 "levcomp.ypp" { } break; @@ -1830,19 +1832,19 @@ yyreduce: break; case 64: -#line 225 "levcomp.ypp" - { - lc_map.veto.add(yylineno, (yyvsp[(1) - (1)].text)); - } +#line 222 "levcomp.ypp" + { } break; case 65: -#line 229 "levcomp.ypp" - { } +#line 226 "levcomp.ypp" + { + lc_map.veto.add(yylineno, (yyvsp[(1) - (1)].text)); + } break; case 66: -#line 231 "levcomp.ypp" +#line 230 "levcomp.ypp" { } break; @@ -1852,19 +1854,24 @@ yyreduce: break; case 68: -#line 236 "levcomp.ypp" +#line 233 "levcomp.ypp" + { } + break; + + case 69: +#line 237 "levcomp.ypp" { lc_map.prelude.add(yylineno, (yyvsp[(1) - (1)].text)); } break; - case 69: -#line 240 "levcomp.ypp" + case 70: +#line 241 "levcomp.ypp" { } break; - case 70: -#line 242 "levcomp.ypp" + case 71: +#line 243 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1873,13 +1880,13 @@ yyreduce: } break; - case 71: -#line 249 "levcomp.ypp" + case 72: +#line 250 "levcomp.ypp" { } break; - case 72: -#line 251 "levcomp.ypp" + case 73: +#line 252 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1888,13 +1895,13 @@ yyreduce: } break; - case 73: -#line 258 "levcomp.ypp" + case 74: +#line 259 "levcomp.ypp" { } break; - case 74: -#line 260 "levcomp.ypp" + case 75: +#line 261 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1903,13 +1910,13 @@ yyreduce: } break; - case 75: -#line 267 "levcomp.ypp" + case 76: +#line 268 "levcomp.ypp" { } break; - case 76: -#line 269 "levcomp.ypp" + case 77: +#line 270 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1918,13 +1925,13 @@ yyreduce: } break; - case 77: -#line 276 "levcomp.ypp" + case 78: +#line 277 "levcomp.ypp" { } break; - case 78: -#line 278 "levcomp.ypp" + case 79: +#line 279 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1933,13 +1940,13 @@ yyreduce: } break; - case 79: -#line 285 "levcomp.ypp" + case 80: +#line 286 "levcomp.ypp" {} break; - case 82: -#line 293 "levcomp.ypp" + case 83: +#line 294 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1948,13 +1955,13 @@ yyreduce: } break; - case 83: -#line 300 "levcomp.ypp" + case 84: +#line 301 "levcomp.ypp" {} break; - case 86: -#line 308 "levcomp.ypp" + case 87: +#line 309 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1963,8 +1970,8 @@ yyreduce: } break; - case 87: -#line 317 "levcomp.ypp" + case 88: +#line 318 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1973,8 +1980,8 @@ yyreduce: } break; - case 88: -#line 326 "levcomp.ypp" + case 89: +#line 327 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -1983,8 +1990,8 @@ yyreduce: } break; - case 89: -#line 335 "levcomp.ypp" + case 90: +#line 336 "levcomp.ypp" { std::string key, arg; int sep(0); @@ -2017,18 +2024,18 @@ yyreduce: } break; - case 90: -#line 367 "levcomp.ypp" + case 91: +#line 368 "levcomp.ypp" { } break; - case 91: -#line 370 "levcomp.ypp" + case 92: +#line 371 "levcomp.ypp" { } break; - case 92: -#line 372 "levcomp.ypp" + case 93: +#line 373 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2037,13 +2044,13 @@ yyreduce: } break; - case 93: -#line 379 "levcomp.ypp" + case 94: +#line 380 "levcomp.ypp" { } break; - case 94: -#line 381 "levcomp.ypp" + case 95: +#line 382 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2052,13 +2059,13 @@ yyreduce: } break; - case 95: -#line 388 "levcomp.ypp" + case 96: +#line 389 "levcomp.ypp" { } break; - case 96: -#line 390 "levcomp.ypp" + case 97: +#line 391 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2067,13 +2074,13 @@ yyreduce: } break; - case 97: -#line 397 "levcomp.ypp" + case 98: +#line 398 "levcomp.ypp" { } break; - case 98: -#line 399 "levcomp.ypp" + case 99: +#line 400 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2082,8 +2089,8 @@ yyreduce: } break; - case 102: -#line 415 "levcomp.ypp" + case 103: +#line 416 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2092,8 +2099,8 @@ yyreduce: } break; - case 106: -#line 431 "levcomp.ypp" + case 107: +#line 432 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2102,18 +2109,18 @@ yyreduce: } break; - case 107: -#line 439 "levcomp.ypp" - { } - break; - case 108: #line 440 "levcomp.ypp" { } break; case 109: -#line 444 "levcomp.ypp" +#line 441 "levcomp.ypp" + { } + break; + + case 110: +#line 445 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2122,13 +2129,8 @@ yyreduce: } break; - case 110: -#line 452 "levcomp.ypp" - { } - break; - case 111: -#line 455 "levcomp.ypp" +#line 453 "levcomp.ypp" { } break; @@ -2138,7 +2140,12 @@ yyreduce: break; case 113: -#line 460 "levcomp.ypp" +#line 457 "levcomp.ypp" + { } + break; + + case 114: +#line 461 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2147,13 +2154,13 @@ yyreduce: } break; - case 114: -#line 468 "levcomp.ypp" + case 115: +#line 469 "levcomp.ypp" { } break; - case 117: -#line 476 "levcomp.ypp" + case 118: +#line 477 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2162,18 +2169,18 @@ yyreduce: } break; - case 118: -#line 484 "levcomp.ypp" + case 119: +#line 485 "levcomp.ypp" {} break; - case 119: -#line 485 "levcomp.ypp" + case 120: +#line 486 "levcomp.ypp" {} break; - case 122: -#line 493 "levcomp.ypp" + case 123: +#line 494 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2182,18 +2189,18 @@ yyreduce: } break; - case 123: -#line 500 "levcomp.ypp" + case 124: +#line 501 "levcomp.ypp" {} break; - case 124: -#line 501 "levcomp.ypp" + case 125: +#line 502 "levcomp.ypp" {} break; - case 127: -#line 509 "levcomp.ypp" + case 128: +#line 510 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2202,8 +2209,8 @@ yyreduce: } break; - case 128: -#line 518 "levcomp.ypp" + case 129: +#line 519 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2212,13 +2219,13 @@ yyreduce: } break; - case 129: -#line 526 "levcomp.ypp" + case 130: +#line 527 "levcomp.ypp" {} break; - case 130: -#line 528 "levcomp.ypp" + case 131: +#line 529 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2227,8 +2234,8 @@ yyreduce: } break; - case 131: -#line 537 "levcomp.ypp" + case 132: +#line 538 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2236,8 +2243,8 @@ yyreduce: } break; - case 132: -#line 544 "levcomp.ypp" + case 133: +#line 545 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2245,8 +2252,8 @@ yyreduce: } break; - case 133: -#line 551 "levcomp.ypp" + case 134: +#line 552 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2254,8 +2261,8 @@ yyreduce: } break; - case 134: -#line 558 "levcomp.ypp" + case 135: +#line 559 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2263,8 +2270,8 @@ yyreduce: } break; - case 135: -#line 566 "levcomp.ypp" + case 136: +#line 567 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2272,13 +2279,13 @@ yyreduce: } break; - case 136: -#line 573 "levcomp.ypp" + case 137: +#line 574 "levcomp.ypp" {} break; - case 137: -#line 575 "levcomp.ypp" + case 138: +#line 576 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2287,8 +2294,8 @@ yyreduce: } break; - case 138: -#line 584 "levcomp.ypp" + case 139: +#line 585 "levcomp.ypp" { lc_map.main.add( yylineno, @@ -2297,8 +2304,8 @@ yyreduce: } break; - case 142: -#line 600 "levcomp.ypp" + case 143: +#line 601 "levcomp.ypp" { lc_map.mapchunk.add( yylineno, @@ -2307,9 +2314,19 @@ yyreduce: } break; + case 147: +#line 617 "levcomp.ypp" + { + lc_map.main.add( + yylineno, + make_stringf("subvault(\"%s\")", + quote_lua_string((yyvsp[(1) - (1)].text)).c_str())); + } + break; + /* Line 1267 of yacc.c. */ -#line 2313 "levcomp.tab.c" +#line 2330 "levcomp.tab.c" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); @@ -2523,6 +2540,6 @@ yyreturn: } -#line 608 "levcomp.ypp" +#line 625 "levcomp.ypp" diff --git a/crawl-ref/source/prebuilt/levcomp.tab.h b/crawl-ref/source/prebuilt/levcomp.tab.h index 30f13807eb..6d66e054bb 100644 --- a/crawl-ref/source/prebuilt/levcomp.tab.h +++ b/crawl-ref/source/prebuilt/levcomp.tab.h @@ -72,16 +72,17 @@ LROCKTILE = 288, FTILE = 289, RTILE = 290, - COMMA = 291, - COLON = 292, - PERC = 293, - INTEGER = 294, - CHARACTER = 295, - STRING = 296, - MAP_LINE = 297, - MONSTER_NAME = 298, - ITEM_INFO = 299, - LUA_LINE = 300 + SUBVAULT = 291, + COMMA = 292, + COLON = 293, + PERC = 294, + INTEGER = 295, + CHARACTER = 296, + STRING = 297, + MAP_LINE = 298, + MONSTER_NAME = 299, + ITEM_INFO = 300, + LUA_LINE = 301 }; #endif /* Tokens. */ @@ -118,16 +119,17 @@ #define LROCKTILE 288 #define FTILE 289 #define RTILE 290 -#define COMMA 291 -#define COLON 292 -#define PERC 293 -#define INTEGER 294 -#define CHARACTER 295 -#define STRING 296 -#define MAP_LINE 297 -#define MONSTER_NAME 298 -#define ITEM_INFO 299 -#define LUA_LINE 300 +#define SUBVAULT 291 +#define COMMA 292 +#define COLON 293 +#define PERC 294 +#define INTEGER 295 +#define CHARACTER 296 +#define STRING 297 +#define MAP_LINE 298 +#define MONSTER_NAME 299 +#define ITEM_INFO 300 +#define LUA_LINE 301 @@ -140,8 +142,8 @@ typedef union YYSTYPE const char *text; raw_range range; } -/* Line 1489 of yacc.c. */ -#line 145 "levcomp.tab.h" +/* Line 1529 of yacc.c. */ +#line 147 "levcomp.tab.h" YYSTYPE; # define yystype YYSTYPE /* obsolescent; will be withdrawn */ # define YYSTYPE_IS_DECLARED 1 diff --git a/crawl-ref/source/util/levcomp.lpp b/crawl-ref/source/util/levcomp.lpp index dc2ea7ca6f..151ef1418e 100644 --- a/crawl-ref/source/util/levcomp.lpp +++ b/crawl-ref/source/util/levcomp.lpp @@ -261,6 +261,7 @@ KITEM: { CBEGIN(ARGUMENT); return KITEM; } KMONS: { CBEGIN(ARGUMENT); return KMONS; } KMASK: { CBEGIN(ARGUMENT); return KMASK; } KPROP: { CBEGIN(ARGUMENT); return KPROP; } +SUBVAULT: { CBEGIN(ARGUMENT); return SUBVAULT; } , return COMMA; diff --git a/crawl-ref/source/util/levcomp.ypp b/crawl-ref/source/util/levcomp.ypp index 500006b2fd..f13f102da0 100644 --- a/crawl-ref/source/util/levcomp.ypp +++ b/crawl-ref/source/util/levcomp.ypp @@ -54,7 +54,7 @@ level_range set_range(const char *s, int start, int end) %token <i> DEFAULT_DEPTH SHUFFLE SUBST TAGS KFEAT KITEM KMONS KMASK KPROP %token <i> NAME DEPTH ORIENT PLACE CHANCE WEIGHT MONS ITEM MARKER COLOUR %token <i> PRELUDE MAIN VALIDATE VETO NSUBST WELCOME LFLAGS BFLAGS -%token <i> LFLOORCOL LROCKCOL LFLOORTILE LROCKTILE FTILE RTILE +%token <i> LFLOORCOL LROCKCOL LFLOORTILE LROCKTILE FTILE RTILE SUBVAULT %token <i> COMMA COLON PERC INTEGER CHARACTER @@ -175,6 +175,7 @@ metaline : place | kmons | kmask | kprop + | subvault | main_lua | prelude_lua | validate_lua @@ -605,4 +606,20 @@ map_line : MAP_LINE } ; +subvault : SUBVAULT subvault_specifiers + ; + +subvault_specifiers: subvault_specifier + | subvault_specifiers COMMA subvault_specifier + ; + +subvault_specifier : STRING + { + lc_map.main.add( + yylineno, + make_stringf("subvault(\"%s\")", + quote_lua_string($1).c_str())); + } + ; + %% |