aboutsummaryrefslogtreecommitdiff
path: root/project/src
diff options
context:
space:
mode:
Diffstat (limited to 'project/src')
-rw-r--r--project/src/addr_port.inc13
-rw-r--r--project/src/db-mkw.c539
-rw-r--r--project/src/db-mkw.h2
-rw-r--r--project/src/lib-checksum.c8
-rw-r--r--project/src/lib-file.c4
-rw-r--r--project/src/lib-image.h8
-rw-r--r--project/src/lib-image2.c43
-rw-r--r--project/src/lib-lecode.c48
-rw-r--r--project/src/lib-lecode.h21
-rw-r--r--project/src/lib-ledis.c162
-rw-r--r--project/src/lib-ledis.h27
-rw-r--r--project/src/lib-lex.c237
-rw-r--r--project/src/lib-lex.h46
-rw-r--r--project/src/lib-std.c50
-rw-r--r--project/src/lib-std.h10
-rw-r--r--project/src/lib-szs-create.c7
-rw-r--r--project/src/lib-szs.c15
-rw-r--r--project/src/prefix.inc207
-rw-r--r--project/src/ui/tab-wlect.inc4
-rw-r--r--project/src/ui/tab-wszst.inc16
-rw-r--r--project/src/ui/ui-wlect.c4
-rw-r--r--project/src/ui/ui-wszst.c34
-rw-r--r--project/src/ui/ui.def36
-rw-r--r--project/src/wlect.c70
-rw-r--r--project/src/wszst.c1
25 files changed, 1148 insertions, 464 deletions
diff --git a/project/src/addr_port.inc b/project/src/addr_port.inc
index 9d90de3..2e93fcf 100644
--- a/project/src/addr_port.inc
+++ b/project/src/addr_port.inc
@@ -3,12 +3,12 @@ static addr_port_version_t addr_port_version =
{
.magic = "PORT-DB",
.db_version = 1,
- .revision = 8780,
- .timestamp = 1679746178,
- .n_records = 1684
+ .revision = 8897,
+ .timestamp = 1697192690,
+ .n_records = 1683
};
-static const addr_port_t addr_port_0[1684] =
+static const addr_port_t addr_port_0[1683] =
{
{{ 0x80000000, 0x80000000, 0x80000000, 0x80000000 }, 0x8040|0, 0x8040|0 }, // HEAD
{{ 0x80008114, 0x800080d4, 0x80008070, 0x80008188 }, 0xbc|2, 0xbc|2 }, // T1
@@ -885,7 +885,7 @@ static const addr_port_t addr_port_0[1684] =
{{ 0x8089ae38, 0x80896440, 0x80899f98, 0x80889298 }, 0x84|2, 0x84|2 }, // REL4
{{ 0x8089aec0, 0x80897070, 0x8089a020, 0x80889320 }, 0x1c|2, 0x1c|2 }, // REL4
{{ 0x8089aee0, 0x808964c8, 0x8089a040, 0x80889340 }, 0x878|2, 0x878|2 }, // REL4
- {{ 0x8089b760, 0x80897090, 0x8089a8c0, 0x80889bc0 }, 0x3ca4|2, 0x3ca4|2 }, // REL4
+ {{ 0x8089b760, 0x80897090, 0x8089a8c0, 0x80889bc0 }, 0x3ca4|0, 0x3ca4|0 }, // REL4
{{ 0x8089f408, 0x8089bb68, 0x8089e568, 0x8088d868 }, 0x98|2, 0x98|2 }, // REL4
{{ 0x8089f4a4, 0x8089ad34, 0x8089e604, 0x8088d904 }, 0xfc|2, 0xfc|2 }, // REL4
{{ 0x8089f5a0, 0x8089bc08, 0x8089e700, 0x8088da00 }, 0x1a0|2, 0x1a0|2 }, // REL4
@@ -978,7 +978,6 @@ static const addr_port_t addr_port_0[1684] =
{{ 0x808a759c, 0x808a2864, 0x808a66fc, 0x808959fc }, 0x34|2, 0x34|2 }, // REL4
{{ 0x808a75d8, 0x808a30b0, 0x808a6738, 0x80895a38 }, 0x4c|2, 0x4c|2 }, // REL4
{{ 0x808a7624, 0x808a289c, 0x808a6784, 0x80895a84 }, 0x54|2, 0x54|2 }, // REL4
- {{ 0x808a7678, 0x8089aa14, 0x808a67d8, 0x80895ad8 }, 0x4|3, 0x4|3 }, // REL4
{{ 0x808a7688, 0x808a28f8, 0x808a67e8, 0x80895ae8 }, 0x150|2, 0x150|2 }, // REL4
{{ 0x808a77d8, 0x808a9090, 0x808a6938, 0x80895c38 }, 0x600|0, 0x600|0 }, // REL4
{{ 0x808a7de0, 0x808a3108, 0x808a6f40, 0x80896240 }, 0x90c|0, 0x90c|0 }, // REL4
@@ -1694,5 +1693,5 @@ static const addr_port_t addr_port_0[1684] =
{{ 0x809c38bc, 0x809bf0b4, 0x809c291c, 0x809b1efc }, 0x8|0, 0x8|0 }, // MEM1
{{ 0x80ae9544, 0x80ae4d84, 0x80ae85a4, 0x80ad7b84 }, 0x4|0, 0x4|0 }, // MEM1
{{ 0xcd000000, 0xcd000000, 0xcd000000, 0xcd000000 }, 0x8000|0, 0x8000|0 }, // GPU
-}; // 1684 records
+}; // 1683 records
diff --git a/project/src/db-mkw.c b/project/src/db-mkw.c
index c4b2a6b..2c46673 100644
--- a/project/src/db-mkw.c
+++ b/project/src/db-mkw.c
@@ -475,290 +475,447 @@ const TrackInfo_t track_info[32] =
const KeywordTab_t track_name_tab[] =
{
{ 0, "2.1", "21", 0 },
- { 0, "CASTLECOURSE.SZS", "MARIOCIRCUIT", 0 },
- { 0, "MARIOSPISTE", "MC", 0 },
- { 0, "T2.1", "T21", 0 },
+ { 0, "CASTLECOURSE", "CASTLECOURSE.SZS", 0 },
+ { 0, "CASTLE_COURSE", "CASTLE_COURSE.SZS", 0 },
+ { 0, "MARIO CIRCUIT", "MARIOCIRCUIT", 0 },
+ { 0, "MARIOS PISTE", "MARIOSPISTE", 0 },
+ { 0, "MC", "T2.1", 0 },
+ { 0, "T21", 0, 0 },
{ 1, "1.2", "12", 0 },
- { 1, "FARMCOURSE.SZS", "KUHMUH", 0 },
- { 1, "KUHMUHWEIDE", "MEADOWS", 0 },
- { 1, "MMM", "MOO", 0 },
+ { 1, "FARMCOURSE", "FARMCOURSE.SZS", 0 },
+ { 1, "FARM_COURSE", "FARM_COURSE.SZS", 0 },
+ { 1, "KUHMUH", "KUHMUH WEIDE", 0 },
+ { 1, "KUHMUH-WEIDE", "KUHMUHWEIDE", 0 },
+ { 1, "MEADOWS", "MMM", 0 },
+ { 1, "MOO", "MOO MEADOWS", 0 },
+ { 1, "MOO MOO", "MOO MOO MEADOWS", 0 },
{ 1, "MOOMEADOWS", "MOOMOO", 0 },
{ 1, "MOOMOOMEADOWS", "NFARMF.BRSTM", 0 },
- { 1, "NFARMN.BRSTM", "T1.2", 0 },
+ { 1, "NFARMN.BRSTM", "N_FARM_F.BRSTM", 0 },
+ { 1, "N_FARM_N.BRSTM", "T1.2", 0 },
{ 1, "T12", "WEIDE", 0 },
{ 2, "1.3", "13", 0 },
- { 2, "GORGE", "KINOKOCOURSE.SZS", 0 },
- { 2, "MG", "MUSHROOM", 0 },
+ { 2, "GORGE", "KINOKOCOURSE", 0 },
+ { 2, "KINOKOCOURSE.SZS", "KINOKO_COURSE", 0 },
+ { 2, "KINOKO_COURSE.SZS", "MG", 0 },
+ { 2, "MUSHROOM", "MUSHROOM GORGE", 0 },
{ 2, "MUSHROOMGORGE", "NKINOKOF.BRSTM", 0 },
- { 2, "NKINOKON.BRSTM", "PILZ", 0 },
+ { 2, "NKINOKON.BRSTM", "N_KINOKO_F.BRSTM", 0 },
+ { 2, "N_KINOKO_N.BRSTM", "PILZ", 0 },
+ { 2, "PILZ SCHLUCHT", "PILZ-SCHLUCHT", 0 },
{ 2, "PILZSCHLUCHT", "SCHLUCHT", 0 },
{ 2, "T1.3", "T13", 0 },
{ 3, "3.4", "34", 0 },
- { 3, "GRUMBLE", "GRUMBLEVOLCANO", 0 },
- { 3, "GV", "NVOLCANO32F.BRSTM", 0 },
- { 3, "NVOLCANO32N.BRSTM", "T3.4", 0 },
- { 3, "T34", "VOLCANO", 0 },
- { 3, "VOLCANOCOURSE.SZS", "VULKANGROLLEN", 0 },
+ { 3, "GRUMBLE", "GRUMBLE VOLCANO", 0 },
+ { 3, "GRUMBLEVOLCANO", "GV", 0 },
+ { 3, "NVOLCANO32F.BRSTM", "NVOLCANO32N.BRSTM", 0 },
+ { 3, "N_VOLCANO32_F.BRSTM", "N_VOLCANO32_N.BRSTM", 0 },
+ { 3, "T3.4", "T34", 0 },
+ { 3, "VOLCANO", "VOLCANOCOURSE", 0 },
+ { 3, "VOLCANOCOURSE.SZS", "VOLCANO_COURSE", 0 },
+ { 3, "VOLCANO_COURSE.SZS", "VULKANGROLLEN", 0 },
{ 4, "1.4", "14", 0 },
{ 4, "FABRIK", "FACTORY", 0 },
- { 4, "FACTORYCOURSE.SZS", "STRMNFACTORYF.BRSTM", 0 },
- { 4, "STRMNFACTORYN.BRSTM", "T1.4", 0 },
- { 4, "T14", "TF", 0 },
- { 4, "TOADS", "TOADSFABRIK", 0 },
+ { 4, "FACTORYCOURSE", "FACTORYCOURSE.SZS", 0 },
+ { 4, "FACTORY_COURSE", "FACTORY_COURSE.SZS", 0 },
+ { 4, "STRMNFACTORYF.BRSTM", "STRMNFACTORYN.BRSTM", 0 },
+ { 4, "STRM_N_FACTORY_F.BRSTM", "STRM_N_FACTORY_N.BRSTM", 0 },
+ { 4, "T1.4", "T14", 0 },
+ { 4, "TF", "TOAD-S", 0 },
+ { 4, "TOAD-S FACTORY", "TOADS", 0 },
+ { 4, "TOADS FABRIK", "TOADSFABRIK", 0 },
{ 4, "TOADSFACTORY", 0, 0 },
{ 5, "2.2", "22", 0 },
{ 5, "CM", "COCONUT", 0 },
- { 5, "COCONUTMALL", "KOKOS", 0 },
- { 5, "KOKOSPROMENADE", "MALL", 0 },
- { 5, "NSHOPPING32F.BRSTM", "NSHOPPING32N.BRSTM", 0 },
- { 5, "PROMENADE", "SHOPPINGCOURSE.SZS", 0 },
+ { 5, "COCONUT MALL", "COCONUTMALL", 0 },
+ { 5, "KOKOS", "KOKOS PROMENADE", 0 },
+ { 5, "KOKOS-PROMENADE", "KOKOSPROMENADE", 0 },
+ { 5, "MALL", "NSHOPPING32F.BRSTM", 0 },
+ { 5, "NSHOPPING32N.BRSTM", "N_SHOPPING32_F.BRSTM", 0 },
+ { 5, "N_SHOPPING32_N.BRSTM", "PROMENADE", 0 },
+ { 5, "SHOPPINGCOURSE", "SHOPPINGCOURSE.SZS", 0 },
+ { 5, "SHOPPING_COURSE", "SHOPPING_COURSE.SZS", 0 },
{ 5, "T2.2", "T22", 0 },
{ 6, "2.3", "23", 0 },
- { 6, "BOARDCROSSCOURSE.SZS", "DKS", 0 },
- { 6, "DKSKIKANE", "DKSUMMIT", 0 },
- { 6, "DS", "NSNOWBOARD32F.BRSTM", 0 },
- { 6, "NSNOWBOARD32N.BRSTM", "SKIKANE", 0 },
- { 6, "SUMMIT", "T2.3", 0 },
- { 6, "T23", 0, 0 },
+ { 6, "BOARDCROSSCOURSE", "BOARDCROSSCOURSE.SZS", 0 },
+ { 6, "BOARDCROSS_COURSE", "BOARDCROSS_COURSE.SZS", 0 },
+ { 6, "DK SKIKANE", "DK SUMMIT", 0 },
+ { 6, "DKS", "DKSKIKANE", 0 },
+ { 6, "DKSUMMIT", "DS", 0 },
+ { 6, "NSNOWBOARD32F.BRSTM", "NSNOWBOARD32N.BRSTM", 0 },
+ { 6, "N_SNOWBOARD32_F.BRSTM", "N_SNOWBOARD32_N.BRSTM", 0 },
+ { 6, "SKIKANE", "SUMMIT", 0 },
+ { 6, "T2.3", "T23", 0 },
{ 7, "2.4", "24", 0 },
- { 7, "GOLD", "GOLDMINE", 0 },
- { 7, "MINE", "STRMNTRUCKF.BRSTM", 0 },
- { 7, "STRMNTRUCKN.BRSTM", "T2.4", 0 },
- { 7, "T24", "TRUCKCOURSE.SZS", 0 },
- { 7, "WARIOS", "WARIOSGOLD", 0 },
+ { 7, "GOLD", "GOLD MINE", 0 },
+ { 7, "GOLDMINE", "MINE", 0 },
+ { 7, "STRMNTRUCKF.BRSTM", "STRMNTRUCKN.BRSTM", 0 },
+ { 7, "STRM_N_TRUCK_F.BRSTM", "STRM_N_TRUCK_N.BRSTM", 0 },
+ { 7, "T2.4", "T24", 0 },
+ { 7, "TRUCKCOURSE", "TRUCKCOURSE.SZS", 0 },
+ { 7, "TRUCK_COURSE", "TRUCK_COURSE.SZS", 0 },
+ { 7, "WARIO-S", "WARIO-S GOLD", 0 },
+ { 7, "WARIO-S GOLD MINE", "WARIOS", 0 },
+ { 7, "WARIOS GOLDMINE", "WARIOSGOLD", 0 },
{ 7, "WARIOSGOLDMINE", "WGM", 0 },
{ 8, "1.1", "11", 0 },
- { 8, "BEGINNERCOURSE.SZS", "LC", 0 },
- { 8, "LUIGI", "LUIGICIRCUIT", 0 },
- { 8, "LUIGIS", "LUIGISPISTE", 0 },
- { 8, "T1.1", "T11", 0 },
+ { 8, "BEGINNERCOURSE", "BEGINNERCOURSE.SZS", 0 },
+ { 8, "BEGINNER_COURSE", "BEGINNER_COURSE.SZS", 0 },
+ { 8, "LC", "LUIGI", 0 },
+ { 8, "LUIGI CIRCUIT", "LUIGICIRCUIT", 0 },
+ { 8, "LUIGIS", "LUIGIS PISTE", 0 },
+ { 8, "LUIGISPISTE", "T1.1", 0 },
+ { 8, "T11", 0, 0 },
{ 9, "3.1", "31", 0 },
- { 9, "DAISY", "DAISYCIRCUIT", 0 },
- { 9, "DAISYS", "DAISYSPISTE", 0 },
+ { 9, "DAISY", "DAISY CIRCUIT", 0 },
+ { 9, "DAISYCIRCUIT", "DAISYS", 0 },
+ { 9, "DAISYS PISTE", "DAISYSPISTE", 0 },
{ 9, "DC", "NDAISY32F.BRSTM", 0 },
- { 9, "NDAISY32N.BRSTM", "SENIORCOURSE.SZS", 0 },
- { 9, "T3.1", "T31", 0 },
+ { 9, "NDAISY32N.BRSTM", "N_DAISY32_F.BRSTM", 0 },
+ { 9, "N_DAISY32_N.BRSTM", "SENIORCOURSE", 0 },
+ { 9, "SENIORCOURSE.SZS", "SENIOR_COURSE", 0 },
+ { 9, "SENIOR_COURSE.SZS", "T3.1", 0 },
+ { 9, "T31", 0, 0 },
{ 10, "4.2", "42", 0 },
{ 10, "HIGHWAY", "MH", 0 },
{ 10, "MONDBLICKSTRASSE", "MOONVIEW", 0 },
- { 10, "MOONVIEWHIGHWAY", "MVH", 0 },
- { 10, "RIDGEHIGHWAYCOURSE.SZS", "STRMNRIDGEHIGHWAYF.BRSTM", 0 },
- { 10, "STRMNRIDGEHIGHWAYN.BRSTM", "T4.2", 0 },
+ { 10, "MOONVIEW HIGHWAY", "MOONVIEWHIGHWAY", 0 },
+ { 10, "MVH", "RIDGEHIGHWAYCOURSE", 0 },
+ { 10, "RIDGEHIGHWAYCOURSE.SZS", "RIDGEHIGHWAY_COURSE", 0 },
+ { 10, "RIDGEHIGHWAY_COURSE.SZS", "STRMNRIDGEHIGHWAYF.BRSTM", 0 },
+ { 10, "STRMNRIDGEHIGHWAYN.BRSTM", "STRM_N_RIDGEHIGHWAY_F.BRSTM", 0 },
+ { 10, "STRM_N_RIDGEHIGHWAY_N.BRSTM", "T4.2", 0 },
{ 10, "T42", 0, 0 },
{ 11, "3.3", "33", 0 },
{ 11, "BLAETTERWALD", "MAPLE", 0 },
- { 11, "MAPLETREEWAY", "MT", 0 },
- { 11, "NMAPLEF.BRSTM", "NMAPLEN.BRSTM", 0 },
- { 11, "T3.3", "T33", 0 },
- { 11, "TREEHOUSECOURSE.SZS", "TREEWAY", 0 },
+ { 11, "MAPLE TREEWAY", "MAPLETREEWAY", 0 },
+ { 11, "MT", "NMAPLEF.BRSTM", 0 },
+ { 11, "NMAPLEN.BRSTM", "N_MAPLE_F.BRSTM", 0 },
+ { 11, "N_MAPLE_N.BRSTM", "T3.3", 0 },
+ { 11, "T33", "TREEHOUSECOURSE", 0 },
+ { 11, "TREEHOUSECOURSE.SZS", "TREEHOUSE_COURSE", 0 },
+ { 11, "TREEHOUSE_COURSE.SZS", "TREEWAY", 0 },
{ 12, "4.3", "43", 0 },
{ 12, "BC", "BOW.FESTUNG", 0 },
+ { 12, "BOWSER-S CASTLE", "BOWSERS FESTUNG", 0 },
{ 12, "BOWSERSCASTLE", "BOWSERSFESTUNG", 0 },
- { 12, "KOOPACOURSE.SZS", "STRMNKOOPAF.BRSTM", 0 },
- { 12, "STRMNKOOPAN.BRSTM", "T4.3", 0 },
- { 12, "T43", 0, 0 },
+ { 12, "KOOPACOURSE", "KOOPACOURSE.SZS", 0 },
+ { 12, "KOOPA_COURSE", "KOOPA_COURSE.SZS", 0 },
+ { 12, "STRMNKOOPAF.BRSTM", "STRMNKOOPAN.BRSTM", 0 },
+ { 12, "STRM_N_KOOPA_F.BRSTM", "STRM_N_KOOPA_N.BRSTM", 0 },
+ { 12, "T4.3", "T43", 0 },
{ 13, "4.4", "44", 0 },
{ 13, "BLVD", "NRAINBOW32F.BRSTM", 0 },
- { 13, "NRAINBOW32N.BRSTM", "RAINBOW", 0 },
+ { 13, "NRAINBOW32N.BRSTM", "N_RAINBOW32_F.BRSTM", 0 },
+ { 13, "N_RAINBOW32_N.BRSTM", "RAINBOW", 0 },
+ { 13, "RAINBOW ROAD", "RAINBOWCOURSE", 0 },
{ 13, "RAINBOWCOURSE.SZS", "RAINBOWROAD", 0 },
- { 13, "REGENBOGEN", "REGENBOGENBLVD", 0 },
- { 13, "REGENBOGENBOULEVARD", "ROAD", 0 },
- { 13, "RR", "T4.4", 0 },
- { 13, "T44", 0, 0 },
+ { 13, "RAINBOW_COURSE", "RAINBOW_COURSE.SZS", 0 },
+ { 13, "REGENBOGEN", "REGENBOGEN BLVD", 0 },
+ { 13, "REGENBOGEN-BLVD", "REGENBOGEN-BOULEVARD", 0 },
+ { 13, "REGENBOGENBLVD", "REGENBOGENBOULEVARD", 0 },
+ { 13, "ROAD", "RR", 0 },
+ { 13, "T4.4", "T44", 0 },
{ 14, "4.1", "41", 0 },
- { 14, "DDR", "DESERTCOURSE.SZS", 0 },
- { 14, "DRY", "DRYDRY", 0 },
+ { 14, "DDR", "DESERTCOURSE", 0 },
+ { 14, "DESERTCOURSE.SZS", "DESERT_COURSE", 0 },
+ { 14, "DESERT_COURSE.SZS", "DRY", 0 },
+ { 14, "DRY DRY", "DRY DRY RUINS", 0 },
+ { 14, "DRY RUINS", "DRYDRY", 0 },
{ 14, "DRYDRYRUINS", "DRYRUINS", 0 },
{ 14, "RUINEN", "RUINS", 0 },
- { 14, "STAUBTROCKENE", "STAUBTROCKENERUINEN", 0 },
- { 14, "STRMNDESERTF.BRSTM", "STRMNDESERTN.BRSTM", 0 },
- { 14, "T4.1", "T41", 0 },
- { 14, "TROCKENE", "TROCKENERUINEN", 0 },
+ { 14, "STAUBTROCKENE", "STAUBTROCKENE RUINEN", 0 },
+ { 14, "STAUBTROCKENERUINEN", "STRMNDESERTF.BRSTM", 0 },
+ { 14, "STRMNDESERTN.BRSTM", "STRM_N_DESERT_F.BRSTM", 0 },
+ { 14, "STRM_N_DESERT_N.BRSTM", "T4.1", 0 },
+ { 14, "T41", "TROCKENE", 0 },
+ { 14, "TROCKENE RUINEN", "TROCKENERUINEN", 0 },
{ 15, "3.2", "32", 0 },
{ 15, "CAPE", "KAP", 0 },
{ 15, "KC", "KOOPA", 0 },
- { 15, "KOOPACAPE", "KOOPAKAP", 0 },
- { 15, "STRMNWATERF.BRSTM", "STRMNWATERN.BRSTM", 0 },
- { 15, "T3.2", "T32", 0 },
- { 15, "WATERCOURSE.SZS", 0, 0 },
+ { 15, "KOOPA CAPE", "KOOPA KAP", 0 },
+ { 15, "KOOPA-KAP", "KOOPACAPE", 0 },
+ { 15, "KOOPAKAP", "STRMNWATERF.BRSTM", 0 },
+ { 15, "STRMNWATERN.BRSTM", "STRM_N_WATER_F.BRSTM", 0 },
+ { 15, "STRM_N_WATER_N.BRSTM", "T3.2", 0 },
+ { 15, "T32", "WATERCOURSE", 0 },
+ { 15, "WATERCOURSE.SZS", "WATER_COURSE", 0 },
+ { 15, "WATER_COURSE.SZS", 0, 0 },
{ 16, "5.1", "51", 0 },
+ { 16, "GCN PEACH", "GCN PEACH BEACH", 0 },
{ 16, "GCNPEACH", "GCNPEACHBEACH", 0 },
- { 16, "GPB", "OLDPEACHGC.SZS", 0 },
+ { 16, "GPB", "OLDPEACHGC", 0 },
+ { 16, "OLDPEACHGC.SZS", "OLD_PEACH_GC", 0 },
+ { 16, "OLD_PEACH_GC.SZS", "PEACH BEACH", 0 },
{ 16, "PEACHBEACH", "RGCBEACH32F.BRSTM", 0 },
{ 16, "RGCBEACH32N.BRSTM", "RPB", 0 },
+ { 16, "R_GC_BEACH32_F.BRSTM", "R_GC_BEACH32_N.BRSTM", 0 },
{ 16, "T5.1", "T51", 0 },
{ 17, "7.4", "74", 0 },
- { 17, "GC", "GCMARIOS", 0 },
- { 17, "GCMARIOSPISTE", "GCNMARIO", 0 },
+ { 17, "GC", "GC MARIOS", 0 },
+ { 17, "GC MARIOS PISTE", "GCMARIOS", 0 },
+ { 17, "GCMARIOSPISTE", "GCN MARIO", 0 },
+ { 17, "GCN MARIO CIRCUIT", "GCN MARIOS", 0 },
+ { 17, "GCN MARIOS PISTE", "GCNMARIO", 0 },
{ 17, "GCNMARIOCIRCUIT", "GCNMARIOS", 0 },
{ 17, "GCNMARIOSPISTE", "GMC", 0 },
- { 17, "OLDMARIOGC.SZS", "RGCCIRCUIT32F.BRSTM", 0 },
- { 17, "RGCCIRCUIT32N.BRSTM", "RMC", 0 },
- { 17, "T7.4", "T74", 0 },
+ { 17, "OLDMARIOGC", "OLDMARIOGC.SZS", 0 },
+ { 17, "OLD_MARIO_GC", "OLD_MARIO_GC.SZS", 0 },
+ { 17, "RGCCIRCUIT32F.BRSTM", "RGCCIRCUIT32N.BRSTM", 0 },
+ { 17, "RMC", "R_GC_CIRCUIT32_F.BRSTM", 0 },
+ { 17, "R_GC_CIRCUIT32_N.BRSTM", "T7.4", 0 },
+ { 17, "T74", 0, 0 },
{ 18, "6.4", "64", 0 },
- { 18, "ARENA", "GCNWALUIGI", 0 },
- { 18, "GCNWALUIGIARENA", "GCNWALUIGISTADIUM", 0 },
- { 18, "GWS", "OLDWALUIGIGC.SZS", 0 },
+ { 18, "ARENA", "GCN WALUIGI", 0 },
+ { 18, "GCN WALUIGI STADIUM", "GCN WALUIGI-ARENA", 0 },
+ { 18, "GCNWALUIGI", "GCNWALUIGIARENA", 0 },
+ { 18, "GCNWALUIGISTADIUM", "GWS", 0 },
+ { 18, "OLDWALUIGIGC", "OLDWALUIGIGC.SZS", 0 },
+ { 18, "OLD_WALUIGI_GC", "OLD_WALUIGI_GC.SZS", 0 },
{ 18, "RGCSTADIUM32F.BRSTM", "RGCSTADIUM32N.BRSTM", 0 },
- { 18, "RWS", "STADIUM", 0 },
+ { 18, "RWS", "R_GC_STADIUM32_F.BRSTM", 0 },
+ { 18, "R_GC_STADIUM32_N.BRSTM", "STADIUM", 0 },
{ 18, "T6.4", "T64", 0 },
- { 18, "WALUIGI", "WALUIGIARENA", 0 },
- { 18, "WALUIGISTADIUM", 0, 0 },
+ { 18, "WALUIGI", "WALUIGI ARENA", 0 },
+ { 18, "WALUIGI STADIUM", "WALUIGI-ARENA", 0 },
+ { 18, "WALUIGIARENA", "WALUIGISTADIUM", 0 },
{ 19, "8.3", "83", 0 },
- { 19, "BERGLAND", "DKBERGLAND", 0 },
- { 19, "DKMOUNTAIN", "GCNDK", 0 },
- { 19, "GCNDKBERGLAND", "GCNDKMOUNTAIN", 0 },
- { 19, "GDKM", "MOUNTAIN", 0 },
- { 19, "OLDDONKEYGC.SZS", "RDKM", 0 },
+ { 19, "BERGLAND", "DK BERGLAND", 0 },
+ { 19, "DK MOUNTAIN", "DKBERGLAND", 0 },
+ { 19, "DKMOUNTAIN", "GCN DK", 0 },
+ { 19, "GCN DK BERGLAND", "GCN DK MOUNTAIN", 0 },
+ { 19, "GCNDK", "GCNDKBERGLAND", 0 },
+ { 19, "GCNDKMOUNTAIN", "GDKM", 0 },
+ { 19, "MOUNTAIN", "OLDDONKEYGC", 0 },
+ { 19, "OLDDONKEYGC.SZS", "OLD_DONKEY_GC", 0 },
+ { 19, "OLD_DONKEY_GC.SZS", "RDKM", 0 },
{ 19, "RGCMOUNTAIN32F.BRSTM", "RGCMOUNTAIN32N.BRSTM", 0 },
+ { 19, "R_GC_MOUNTAIN32_F.BRSTM", "R_GC_MOUNTAIN32_N.BRSTM", 0 },
{ 19, "T8.3", "T83", 0 },
{ 20, "5.2", "52", 0 },
- { 20, "DSYOSHI", "DSYOSHIFALLS", 0 },
- { 20, "DSYOSHIKASKADEN", "DYF", 0 },
- { 20, "FALLS", "KASKADEN", 0 },
- { 20, "OLDFALLSDS.SZS", "RDSJUNGLE32F.BRSTM", 0 },
+ { 20, "DS YOSHI", "DS YOSHI FALLS", 0 },
+ { 20, "DS YOSHI-KASKADEN", "DSYOSHI", 0 },
+ { 20, "DSYOSHIFALLS", "DSYOSHIKASKADEN", 0 },
+ { 20, "DYF", "FALLS", 0 },
+ { 20, "KASKADEN", "OLDFALLSDS", 0 },
+ { 20, "OLDFALLSDS.SZS", "OLD_FALLS_DS", 0 },
+ { 20, "OLD_FALLS_DS.SZS", "RDSJUNGLE32F.BRSTM", 0 },
{ 20, "RDSJUNGLE32N.BRSTM", "RYF", 0 },
+ { 20, "R_DS_JUNGLE32_F.BRSTM", "R_DS_JUNGLE32_N.BRSTM", 0 },
{ 20, "T5.2", "T52", 0 },
- { 20, "YOSHI", "YOSHIFALLS", 0 },
- { 20, "YOSHIKASKADEN", 0, 0 },
+ { 20, "YOSHI", "YOSHI FALLS", 0 },
+ { 20, "YOSHI KASKADEN", "YOSHI-KASKADEN", 0 },
+ { 20, "YOSHIFALLS", "YOSHIKASKADEN", 0 },
{ 21, "7.1", "71", 0 },
{ 21, "DDH", "DESERT", 0 },
- { 21, "DESERTHILLS", "DSDESERT", 0 },
- { 21, "DSDESERTHILLS", "DSGLUEHHEISSE", 0 },
- { 21, "DSGLUEHHEISSEWUESTE", "GLUEHHEISSE", 0 },
+ { 21, "DESERT HILLS", "DESERTHILLS", 0 },
+ { 21, "DS DESERT", "DS DESERT HILLS", 0 },
+ { 21, "DS GLUEHHEISSE", "DS GLUEHHEISSE WUESTE", 0 },
+ { 21, "DSDESERT", "DSDESERTHILLS", 0 },
+ { 21, "DSGLUEHHEISSE", "DSGLUEHHEISSEWUESTE", 0 },
+ { 21, "GLUEHHEISSE", "GLUEHHEISSE WUESTE", 0 },
{ 21, "GLUEHHEISSEWUESTE", "HEISSE", 0 },
- { 21, "HEISSEWUESTE", "HILLS", 0 },
- { 21, "OLDDESERTDS.SZS", "RDH", 0 },
+ { 21, "HEISSE WUESTE", "HEISSEWUESTE", 0 },
+ { 21, "HILLS", "OLDDESERTDS", 0 },
+ { 21, "OLDDESERTDS.SZS", "OLD_DESERT_DS", 0 },
+ { 21, "OLD_DESERT_DS.SZS", "RDH", 0 },
{ 21, "RDSDESERT32F.BRSTM", "RDSDESERT32N.BRSTM", 0 },
+ { 21, "R_DS_DESERT32_F.BRSTM", "R_DS_DESERT32_N.BRSTM", 0 },
{ 21, "T7.1", "T71", 0 },
{ 21, "WUESTE", 0, 0 },
{ 22, "8.2", "82", 0 },
- { 22, "DPG", "DSPEACH", 0 },
+ { 22, "DPG", "DS PEACH", 0 },
+ { 22, "DS PEACH GARDENS", "DS PEACHS", 0 },
+ { 22, "DS PEACHS SCHLOSSGARTEN", "DSPEACH", 0 },
{ 22, "DSPEACHGARDENS", "DSPEACHS", 0 },
{ 22, "DSPEACHSSCHLOSSGARTEN", "GARDENS", 0 },
- { 22, "OLDGARDENDS.SZS", "PEACHGARDENS", 0 },
- { 22, "PEACHS", "PEACHSSCHLOSSGARTEN", 0 },
- { 22, "RDSGARDEN32F.BRSTM", "RDSGARDEN32N.BRSTM", 0 },
- { 22, "RPG", "SCHLOSSGARTEN", 0 },
- { 22, "T8.2", "T82", 0 },
+ { 22, "OLDGARDENDS", "OLDGARDENDS.SZS", 0 },
+ { 22, "OLD_GARDEN_DS", "OLD_GARDEN_DS.SZS", 0 },
+ { 22, "PEACH GARDENS", "PEACHGARDENS", 0 },
+ { 22, "PEACHS", "PEACHS SCHLOSSGARTEN", 0 },
+ { 22, "PEACHSSCHLOSSGARTEN", "RDSGARDEN32F.BRSTM", 0 },
+ { 22, "RDSGARDEN32N.BRSTM", "RPG", 0 },
+ { 22, "R_DS_GARDEN32_F.BRSTM", "R_DS_GARDEN32_N.BRSTM", 0 },
+ { 22, "SCHLOSSGARTEN", "T8.2", 0 },
+ { 22, "T82", 0, 0 },
{ 23, "6.3", "63", 0 },
{ 23, "DDS", "DELFINO", 0 },
- { 23, "DELFINOSQUARE", "DSDELFINO", 0 },
- { 23, "DSDELFINOSQUARE", "DSPIAZZALE", 0 },
- { 23, "DSPIAZZALEDELFINO", "OLDTOWNDS.SZS", 0 },
+ { 23, "DELFINO SQUARE", "DELFINOSQUARE", 0 },
+ { 23, "DS DELFINO", "DS DELFINO SQUARE", 0 },
+ { 23, "DS PIAZZALE", "DS PIAZZALE DELFINO", 0 },
+ { 23, "DSDELFINO", "DSDELFINOSQUARE", 0 },
+ { 23, "DSPIAZZALE", "DSPIAZZALEDELFINO", 0 },
+ { 23, "OLDTOWNDS", "OLDTOWNDS.SZS", 0 },
+ { 23, "OLD_TOWN_DS", "OLD_TOWN_DS.SZS", 0 },
{ 23, "PIAZ", "PIAZ.DELFINO", 0 },
- { 23, "PIAZZALE", "PIAZZALEDELFINO", 0 },
- { 23, "RDS", "RDSTOWN32F.BRSTM", 0 },
- { 23, "RDSTOWN32N.BRSTM", "SQUARE", 0 },
- { 23, "T6.3", "T63", 0 },
+ { 23, "PIAZZALE", "PIAZZALE DELFINO", 0 },
+ { 23, "PIAZZALEDELFINO", "RDS", 0 },
+ { 23, "RDSTOWN32F.BRSTM", "RDSTOWN32N.BRSTM", 0 },
+ { 23, "R_DS_TOWN32_F.BRSTM", "R_DS_TOWN32_N.BRSTM", 0 },
+ { 23, "SQUARE", "T6.3", 0 },
+ { 23, "T63", 0, 0 },
{ 24, "8.1", "81", 0 },
- { 24, "CIRCUIT3", "MARIOCIRCUIT3", 0 },
- { 24, "MARIOSPISTE3", "OLDMARIOSFC.SZS", 0 },
- { 24, "PISTE3", "RMC3", 0 },
- { 24, "RSFCCIRCUIT32F.BRSTM", "RSFCCIRCUIT32N.BRSTM", 0 },
- { 24, "SMC3", "SNESMARIO", 0 },
- { 24, "SNESMARIOCIRCUIT", "SNESMARIOCIRCUIT3", 0 },
- { 24, "SNESMARIOS", "SNESMARIOSPISTE", 0 },
- { 24, "SNESMARIOSPISTE3", "T8.1", 0 },
- { 24, "T81", 0, 0 },
+ { 24, "CIRCUIT 3", "CIRCUIT3", 0 },
+ { 24, "MARIO CIRCUIT 3", "MARIOCIRCUIT3", 0 },
+ { 24, "MARIOS PISTE 3", "MARIOSPISTE3", 0 },
+ { 24, "OLDMARIOSFC", "OLDMARIOSFC.SZS", 0 },
+ { 24, "OLD_MARIO_SFC", "OLD_MARIO_SFC.SZS", 0 },
+ { 24, "PISTE 3", "PISTE3", 0 },
+ { 24, "RMC3", "RSFCCIRCUIT32F.BRSTM", 0 },
+ { 24, "RSFCCIRCUIT32N.BRSTM", "R_SFC_CIRCUIT32_F.BRSTM", 0 },
+ { 24, "R_SFC_CIRCUIT32_N.BRSTM", "SMC3", 0 },
+ { 24, "SNES MARIO", "SNES MARIO CIRCUIT", 0 },
+ { 24, "SNES MARIO CIRCUIT 3", "SNES MARIOS", 0 },
+ { 24, "SNES MARIOS PISTE", "SNES MARIOS PISTE 3", 0 },
+ { 24, "SNESMARIO", "SNESMARIOCIRCUIT", 0 },
+ { 24, "SNESMARIOCIRCUIT3", "SNESMARIOS", 0 },
+ { 24, "SNESMARIOSPISTE", "SNESMARIOSPISTE3", 0 },
+ { 24, "T8.1", "T81", 0 },
{ 25, "5.3", "53", 0 },
- { 25, "GEISTERTAL", "GEISTERTAL2", 0 },
- { 25, "GHOST", "GHOSTVALLEY", 0 },
- { 25, "GHOSTVALLEY2", "OLDOBAKESFC.SZS", 0 },
+ { 25, "GEISTERTAL", "GEISTERTAL 2", 0 },
+ { 25, "GEISTERTAL2", "GHOST", 0 },
+ { 25, "GHOST VALLEY", "GHOST VALLEY 2", 0 },
+ { 25, "GHOSTVALLEY", "GHOSTVALLEY2", 0 },
+ { 25, "OLDOBAKESFC", "OLDOBAKESFC.SZS", 0 },
+ { 25, "OLD_OBAKE_SFC", "OLD_OBAKE_SFC.SZS", 0 },
{ 25, "RGV2", "RSFCOBAKE32F.BRSTM", 0 },
- { 25, "RSFCOBAKE32N.BRSTM", "SGV2", 0 },
- { 25, "SNESGEISTERTAL", "SNESGEISTERTAL2", 0 },
- { 25, "SNESGHOST", "SNESGHOSTVALLEY", 0 },
- { 25, "SNESGHOSTVALLEY2", "T5.3", 0 },
- { 25, "T53", "VALLEY", 0 },
+ { 25, "RSFCOBAKE32N.BRSTM", "R_SFC_OBAKE32_F.BRSTM", 0 },
+ { 25, "R_SFC_OBAKE32_N.BRSTM", "SGV2", 0 },
+ { 25, "SNES GEISTERTAL", "SNES GEISTERTAL 2", 0 },
+ { 25, "SNES GHOST", "SNES GHOST VALLEY", 0 },
+ { 25, "SNES GHOST VALLEY 2", "SNESGEISTERTAL", 0 },
+ { 25, "SNESGEISTERTAL2", "SNESGHOST", 0 },
+ { 25, "SNESGHOSTVALLEY", "SNESGHOSTVALLEY2", 0 },
+ { 25, "T5.3", "T53", 0 },
+ { 25, "VALLEY", "VALLEY 2", 0 },
{ 25, "VALLEY2", 0, 0 },
{ 26, "5.4", "54", 0 },
{ 26, "MAR", "MAR.RENNPISTE", 0 },
- { 26, "MARIORACEWAY", "MARIOSRENNPISTE", 0 },
+ { 26, "MARIO RACEWAY", "MARIORACEWAY", 0 },
+ { 26, "MARIOS RENNPISTE", "MARIOSRENNPISTE", 0 },
+ { 26, "N64 MARIO", "N64 MARIO RACEWAY", 0 },
+ { 26, "N64 MARIOS", "N64 MARIOS RENNPISTE", 0 },
{ 26, "N64MARIO", "N64MARIORACEWAY", 0 },
{ 26, "N64MARIOS", "N64MARIOSRENNPISTE", 0 },
- { 26, "NMR", "OLDMARIO64.SZS", 0 },
- { 26, "R64CIRCUIT32F.BRSTM", "R64CIRCUIT32N.BRSTM", 0 },
- { 26, "RACEWAY", "RENNPISTE", 0 },
- { 26, "RMR", "T5.4", 0 },
- { 26, "T54", 0, 0 },
+ { 26, "NMR", "OLDMARIO64", 0 },
+ { 26, "OLDMARIO64.SZS", "OLD_MARIO_64", 0 },
+ { 26, "OLD_MARIO_64.SZS", "R64CIRCUIT32F.BRSTM", 0 },
+ { 26, "R64CIRCUIT32N.BRSTM", "RACEWAY", 0 },
+ { 26, "RENNPISTE", "RMR", 0 },
+ { 26, "R_64_CIRCUIT32_F.BRSTM", "R_64_CIRCUIT32_N.BRSTM", 0 },
+ { 26, "T5.4", "T54", 0 },
{ 27, "6.1", "61", 0 },
- { 27, "LAND", "N64SHERBET", 0 },
- { 27, "N64SHERBETLAND", "N64SORBETLAND", 0 },
- { 27, "NSL", "OLDSHERBET64.SZS", 0 },
+ { 27, "LAND", "N64 SHERBET", 0 },
+ { 27, "N64 SHERBET LAND", "N64 SORBET-LAND", 0 },
+ { 27, "N64SHERBET", "N64SHERBETLAND", 0 },
+ { 27, "N64SORBETLAND", "NSL", 0 },
+ { 27, "OLDSHERBET64", "OLDSHERBET64.SZS", 0 },
+ { 27, "OLD_SHERBET_64", "OLD_SHERBET_64.SZS", 0 },
{ 27, "R64SHERBET32F.BRSTM", "R64SHERBET32N.BRSTM", 0 },
- { 27, "RSL", "SHERBET", 0 },
- { 27, "SHERBETLAND", "SORBET", 0 },
- { 27, "SORBETLAND", "T6.1", 0 },
- { 27, "T61", 0, 0 },
+ { 27, "RSL", "R_64_SHERBET32_F.BRSTM", 0 },
+ { 27, "R_64_SHERBET32_N.BRSTM", "SHERBET", 0 },
+ { 27, "SHERBET LAND", "SHERBETLAND", 0 },
+ { 27, "SORBET", "SORBET LAND", 0 },
+ { 27, "SORBET-LAND", "SORBETLAND", 0 },
+ { 27, "T6.1", "T61", 0 },
{ 28, "8.4", "84", 0 },
- { 28, "BOW.FESTUNG", "N64BOW.FESTUNG", 0 },
- { 28, "N64BOWSERS", "N64BOWSERSCASTLE", 0 },
- { 28, "N64BOWSERSFESTUNG", "NBC", 0 },
- { 28, "OLDKOOPA64.SZS", "R64KUPPA32F.BRSTM", 0 },
+ { 28, "BOW.FESTUNG", "N64 BOW.FESTUNG", 0 },
+ { 28, "N64 BOWSER-S", "N64 BOWSER-S CASTLE", 0 },
+ { 28, "N64 BOWSERS", "N64 BOWSERS FESTUNG", 0 },
+ { 28, "N64BOW.FESTUNG", "N64BOWSERS", 0 },
+ { 28, "N64BOWSERSCASTLE", "N64BOWSERSFESTUNG", 0 },
+ { 28, "NBC", "OLDKOOPA64", 0 },
+ { 28, "OLDKOOPA64.SZS", "OLD_KOOPA_64", 0 },
+ { 28, "OLD_KOOPA_64.SZS", "R64KUPPA32F.BRSTM", 0 },
{ 28, "R64KUPPA32N.BRSTM", "RBC", 0 },
+ { 28, "R_64_KUPPA32_F.BRSTM", "R_64_KUPPA32_N.BRSTM", 0 },
{ 28, "T8.4", "T84", 0 },
{ 29, "7.3", "73", 0 },
- { 29, "DKS", "DKSDSCHUNGELPARK", 0 },
+ { 29, "DK-S", "DK-S JUNGLE", 0 },
+ { 29, "DK-S JUNGLE PARKWAY", "DKS", 0 },
+ { 29, "DKS DSCHUNGELPARK", "DKSDSCHUNGELPARK", 0 },
{ 29, "DKSJUNGLE", "DKSJUNGLEPARKWAY", 0 },
{ 29, "DSCHUNGELPARK", "JUNGLE", 0 },
- { 29, "JUNGLEPARKWAY", "N64DKS", 0 },
+ { 29, "JUNGLE PARKWAY", "JUNGLEPARKWAY", 0 },
+ { 29, "N64 DK-S", "N64 DK-S JUNGLE", 0 },
+ { 29, "N64 DK-S JUNGLE PARKWAY", "N64 DKS", 0 },
+ { 29, "N64 DKS DSCHUNGELPARK", "N64DKS", 0 },
{ 29, "N64DKSDSCHUNGELPARK", "N64DKSJUNGLE", 0 },
{ 29, "N64DKSJUNGLEPARKWAY", "NDKJP", 0 },
- { 29, "OLDDONKEY64.SZS", "PARKWAY", 0 },
- { 29, "R64JUNGLE32F.BRSTM", "R64JUNGLE32N.BRSTM", 0 },
- { 29, "RDJP", "RDKJP", 0 },
- { 29, "T7.3", "T73", 0 },
+ { 29, "OLDDONKEY64", "OLDDONKEY64.SZS", 0 },
+ { 29, "OLD_DONKEY_64", "OLD_DONKEY_64.SZS", 0 },
+ { 29, "PARKWAY", "R64JUNGLE32F.BRSTM", 0 },
+ { 29, "R64JUNGLE32N.BRSTM", "RDJP", 0 },
+ { 29, "RDKJP", "R_64_JUNGLE32_F.BRSTM", 0 },
+ { 29, "R_64_JUNGLE32_N.BRSTM", "T7.3", 0 },
+ { 29, "T73", 0, 0 },
{ 30, "7.2", "72", 0 },
- { 30, "BOW.FESTUNG3", "BOWSER", 0 },
- { 30, "BOWSERCASTLE", "BOWSERCASTLE3", 0 },
- { 30, "BOWSERSFESTUNG3", "CASTLE3", 0 },
- { 30, "FESTUNG3", "GBABOWSER", 0 },
+ { 30, "BOW.FESTUNG 3", "BOW.FESTUNG3", 0 },
+ { 30, "BOWSER", "BOWSER CASTLE", 0 },
+ { 30, "BOWSER CASTLE 3", "BOWSERCASTLE", 0 },
+ { 30, "BOWSERCASTLE3", "BOWSERS FESTUNG 3", 0 },
+ { 30, "BOWSERSFESTUNG3", "CASTLE 3", 0 },
+ { 30, "CASTLE3", "FESTUNG 3", 0 },
+ { 30, "FESTUNG3", "GBA BOWSER", 0 },
+ { 30, "GBA BOWSER CASTLE", "GBA BOWSER CASTLE 3", 0 },
+ { 30, "GBA BOWSERS", "GBA BOWSERS FESTUNG", 0 },
+ { 30, "GBA BOWSERS FESTUNG 3", "GBABOWSER", 0 },
{ 30, "GBABOWSERCASTLE", "GBABOWSERCASTLE3", 0 },
{ 30, "GBABOWSERS", "GBABOWSERSFESTUNG", 0 },
{ 30, "GBABOWSERSFESTUNG3", "GBC3", 0 },
- { 30, "OLDKOOPAGBA.SZS", "RAGBKUPPA32F.BRSTM", 0 },
- { 30, "RAGBKUPPA32N.BRSTM", "RBC3", 0 },
- { 30, "T7.2", "T72", 0 },
+ { 30, "OLDKOOPAGBA", "OLDKOOPAGBA.SZS", 0 },
+ { 30, "OLD_KOOPA_GBA", "OLD_KOOPA_GBA.SZS", 0 },
+ { 30, "RAGBKUPPA32F.BRSTM", "RAGBKUPPA32N.BRSTM", 0 },
+ { 30, "RBC3", "R_AGB_KUPPA32_F.BRSTM", 0 },
+ { 30, "R_AGB_KUPPA32_N.BRSTM", "T7.2", 0 },
+ { 30, "T72", 0, 0 },
{ 31, "6.2", "62", 0 },
+ { 31, "GBA SHY", "GBA SHY GUY", 0 },
+ { 31, "GBA SHY GUY BEACH", "GBA SHY GUY-STRAND", 0 },
{ 31, "GBASHY", "GBASHYGUY", 0 },
{ 31, "GBASHYGUYBEACH", "GBASHYGUYSTRAND", 0 },
{ 31, "GSGB", "GUY", 0 },
- { 31, "GUYBEACH", "GUYSTRAND", 0 },
- { 31, "OLDHEYHOGBA.SZS", "RAGBBEACH32F.BRSTM", 0 },
+ { 31, "GUY BEACH", "GUY STRAND", 0 },
+ { 31, "GUY-STRAND", "GUYBEACH", 0 },
+ { 31, "GUYSTRAND", "OLDHEYHOGBA", 0 },
+ { 31, "OLDHEYHOGBA.SZS", "OLD_HEYHO_GBA", 0 },
+ { 31, "OLD_HEYHO_GBA.SZS", "RAGBBEACH32F.BRSTM", 0 },
{ 31, "RAGBBEACH32N.BRSTM", "RSGB", 0 },
- { 31, "SHY", "SHYGUY", 0 },
+ { 31, "R_AGB_BEACH32_F.BRSTM", "R_AGB_BEACH32_N.BRSTM", 0 },
+ { 31, "SHY", "SHY GUY", 0 },
+ { 31, "SHY GUY BEACH", "SHY GUY STRAND", 0 },
+ { 31, "SHY GUY-STRAND", "SHYGUY", 0 },
{ 31, "SHYGUYBEACH", "SHYGUYSTRAND", 0 },
{ 31, "STRAND", "T6.2", 0 },
{ 31, "T62", 0, 0 },
@@ -944,76 +1101,80 @@ const KeywordTab_t arena_name_tab[] =
{ 0, "ADP", "DELFINOPIER", 0 },
{ 0, "NVENICEF.BRSTM", "NVENICEN.BRSTM", 0 },
{ 0, "U1.2", "U12", 0 },
- { 0, "VENICEBATTLE.SZS", 0, 0 },
+ { 0, "VENICEBATTLE", "VENICEBATTLE.SZS", 0 },
{ 1, "1.1", "11", 0 },
{ 1, "A1.1", "A11", 0 },
- { 1, "ABP", "BLOCKBATTLE.SZS", 0 },
- { 1, "BLOCKPLAZA", "NBLOCKF.BRSTM", 0 },
- { 1, "NBLOCKN.BRSTM", "U1.1", 0 },
- { 1, "U11", 0, 0 },
+ { 1, "ABP", "BLOCKBATTLE", 0 },
+ { 1, "BLOCKBATTLE.SZS", "BLOCKPLAZA", 0 },
+ { 1, "NBLOCKF.BRSTM", "NBLOCKN.BRSTM", 0 },
+ { 1, "U1.1", "U11", 0 },
{ 2, "1.4", "14", 0 },
{ 2, "A1.4", "A14", 0 },
- { 2, "ACCW", "CASINOBATTLE.SZS", 0 },
- { 2, "CHAINCHOMPWHEEL", "KETTENHUNDRLT", 0 },
- { 2, "KETTENHUNDROULETTE", "NCASINOF.BRSTM", 0 },
- { 2, "NCASINON.BRSTM", "U1.4", 0 },
- { 2, "U14", 0, 0 },
+ { 2, "ACCW", "CASINOBATTLE", 0 },
+ { 2, "CASINOBATTLE.SZS", "CHAINCHOMPWHEEL", 0 },
+ { 2, "KETTENHUNDRLT", "KETTENHUNDROULETTE", 0 },
+ { 2, "NCASINOF.BRSTM", "NCASINON.BRSTM", 0 },
+ { 2, "U1.4", "U14", 0 },
{ 3, "1.3", "13", 0 },
{ 3, "A1.3", "A13", 0 },
{ 3, "AFS", "FUNKYSTADION", 0 },
{ 3, "FUNKYSTADIUM", "NSKATEF.BRSTM", 0 },
- { 3, "NSKATEN.BRSTM", "SKATEBATTLE.SZS", 0 },
- { 3, "U1.3", "U13", 0 },
+ { 3, "NSKATEN.BRSTM", "SKATEBATTLE", 0 },
+ { 3, "SKATEBATTLE.SZS", "U1.3", 0 },
+ { 3, "U13", 0, 0 },
{ 4, "1.5", "15", 0 },
{ 4, "A1.5", "A15", 0 },
{ 4, "ATD", "NRYUUSAF.BRSTM", 0 },
- { 4, "NRYUUSAN.BRSTM", "SANDBATTLE.SZS", 0 },
- { 4, "STEINWUESTE", "THWOMPDESERT", 0 },
- { 4, "U1.5", "U15", 0 },
+ { 4, "NRYUUSAN.BRSTM", "SANDBATTLE", 0 },
+ { 4, "SANDBATTLE.SZS", "STEINWUESTE", 0 },
+ { 4, "THWOMPDESERT", "U1.5", 0 },
+ { 4, "U15", 0, 0 },
{ 5, "2.4", "24", 0 },
{ 5, "A2.4", "A24", 0 },
{ 5, "AGCL", "ARCL", 0 },
{ 5, "GCNCOOKIELAND", "GCNKEKSLAND", 0 },
- { 5, "OLDCOOKIELANDGC.SZS", "RGCBATTLE32F.BRSTM", 0 },
- { 5, "RGCBATTLE32N.BRSTM", "U2.4", 0 },
- { 5, "U24", 0, 0 },
+ { 5, "OLDCOOKIELANDGC", "OLDCOOKIELANDGC.SZS", 0 },
+ { 5, "RGCBATTLE32F.BRSTM", "RGCBATTLE32N.BRSTM", 0 },
+ { 5, "U2.4", "U24", 0 },
{ 6, "2.5", "25", 0 },
{ 6, "A2.5", "A25", 0 },
{ 6, "ADTH", "ARTH", 0 },
{ 6, "DSFINSTERVILLA", "DSTWILIGHTHOUSE", 0 },
- { 6, "OLDHOUSEDS.SZS", "RDSBATTLEF.BRSTM", 0 },
- { 6, "RDSBATTLEN.BRSTM", "U2.5", 0 },
- { 6, "U25", 0, 0 },
+ { 6, "OLDHOUSEDS", "OLDHOUSEDS.SZS", 0 },
+ { 6, "RDSBATTLEF.BRSTM", "RDSBATTLEN.BRSTM", 0 },
+ { 6, "U2.5", "U25", 0 },
{ 7, "2.1", "21", 0 },
{ 7, "A2.1", "A21", 0 },
{ 7, "ARBC4", "ASBC4", 0 },
- { 7, "OLDBATTLE4SFC.SZS", "RSFCBATTLEF.BRSTM", 0 },
- { 7, "RSFCBATTLEN.BRSTM", "SNESBATTLECOURSE4", 0 },
- { 7, "SNESKAMPFK.4", "SNESKAMPFKURS4", 0 },
- { 7, "U2.1", "U21", 0 },
+ { 7, "OLDBATTLE4SFC", "OLDBATTLE4SFC.SZS", 0 },
+ { 7, "RSFCBATTLEF.BRSTM", "RSFCBATTLEN.BRSTM", 0 },
+ { 7, "SNESBATTLECOURSE4", "SNESKAMPFK.4", 0 },
+ { 7, "SNESKAMPFKURS4", "U2.1", 0 },
+ { 7, "U21", 0, 0 },
{ 8, "2.2", "22", 0 },
{ 8, "A2.2", "A22", 0 },
{ 8, "AGBC3", "ARBC3", 0 },
{ 8, "GBABATTLECOURSE3", "GBAKAMPFKURS3", 0 },
- { 8, "OLDBATTLE3GBA.SZS", "RAGBBATTLEF.BRSTM", 0 },
- { 8, "RAGBBATTLEN.BRSTM", "U2.2", 0 },
- { 8, "U22", 0, 0 },
+ { 8, "OLDBATTLE3GBA", "OLDBATTLE3GBA.SZS", 0 },
+ { 8, "RAGBBATTLEF.BRSTM", "RAGBBATTLEN.BRSTM", 0 },
+ { 8, "U2.2", "U22", 0 },
{ 9, "2.3", "23", 0 },
{ 9, "A2.3", "A23", 0 },
{ 9, "ANSS", "ARSS", 0 },
{ 9, "N64SKYSCRAPER", "N64WOLKENKRATZER", 0 },
- { 9, "OLDMATENRO64.SZS", "R64BATTLEF.BRSTM", 0 },
- { 9, "R64BATTLEN.BRSTM", "U2.3", 0 },
- { 9, "U23", "WOLKENKRATZER", 0 },
+ { 9, "OLDMATENRO64", "OLDMATENRO64.SZS", 0 },
+ { 9, "R64BATTLEF.BRSTM", "R64BATTLEN.BRSTM", 0 },
+ { 9, "U2.3", "U23", 0 },
+ { 9, "WOLKENKRATZER", 0, 0 },
{0,0,0,0}
};
diff --git a/project/src/db-mkw.h b/project/src/db-mkw.h
index 7762963..d0f7215 100644
--- a/project/src/db-mkw.h
+++ b/project/src/db-mkw.h
@@ -35,7 +35,7 @@ typedef struct TrackInfo_t
ccp sound_n_fname; // file name of normal sound
ccp sound_f_fname; // file name of fast sound
- u8 sha1[4][24]; // SHA1+size, compatible to sha1_size_hash_t
+ u8 sha1[4][24]; // SHA1+size, compatible to sha1_size_t
// ... ORIG, ORIG_D, NORM, NORM_D
} TrackInfo_t;
diff --git a/project/src/lib-checksum.c b/project/src/lib-checksum.c
index ad29b19..acfc12e 100644
--- a/project/src/lib-checksum.c
+++ b/project/src/lib-checksum.c
@@ -195,9 +195,11 @@ void CreateSSXChecksumDBByData ( char *buf, uint bufsize, cvp data, uint size, f
ccp append = 0;
switch((int)ff)
{
- case FF_YAZ0: append = ".y"; break;
- case FF_BZIP2: append = ".b"; break;
- case FF_LZMA: append = ".l"; break;
+ case FF_YAZ0: append = ".y"; break;
+ case FF_BZ: append = ".B"; break;
+ case FF_BZIP2: append = ".b"; break;
+ case FF_LZ: append = ".L"; break;
+ case FF_LZMA: append = ".l"; break;
}
if (append)
memcpy(buf+CHECKSUM_DB_SIZE,append,3);
diff --git a/project/src/lib-file.c b/project/src/lib-file.c
index 340950b..108b91e 100644
--- a/project/src/lib-file.c
+++ b/project/src/lib-file.c
@@ -2420,7 +2420,7 @@ s64 FindAutoAdd ( ccp fname, ccp ext, char *buf, uint buf_size )
/////////////// CompressManager_t ///////////////
///////////////////////////////////////////////////////////////////////////////
-enumError DecodeCompressManager
+enumError DecompressManager
(
CompressManager_t *mgr // manager data
)
@@ -4246,7 +4246,7 @@ const mkw_prefix_t * GetPrefixTable(void)
{
if (!current_prefix_tab)
{
- DecodeBZIP2Manager(&prefix_inc_mgr);
+ DecompressManager(&prefix_inc_mgr);
DefinePrefixTable(prefix_inc_mgr.data,prefix_inc_mgr.size);
}
diff --git a/project/src/lib-image.h b/project/src/lib-image.h
index 46e8b98..a34fc1b 100644
--- a/project/src/lib-image.h
+++ b/project/src/lib-image.h
@@ -386,8 +386,8 @@ typedef struct tpl_raw_t
{
bool valid; // 'data' is valid
mem_t data; // raw data, alloced
- int n_image; // number of images including mainn image
- struct mipmap_info_t *mmi; // 'n_images' info recored, alloced
+ int n_image; // number of images including main image
+ struct mipmap_info_t *mmi; // 'n_images' info records, alloced
const endian_func_t *endian; // endian functions
}
tpl_raw_t;
@@ -407,7 +407,7 @@ enumError SaveTPL
Image_t *src_img, // pointer to valid source img
FILE *f, // output file, if NULL then use fname+overwrite
ccp fname, // filename of source
- bool overwrite // true: force overwriting
+ bool overwrite // true: allow overwriting
);
///////////////////////////////////////////////////////////////////////////////
@@ -612,7 +612,7 @@ typedef struct GenericImgParam_t
//--- analysis, setup by CreateGenericIMG()
const KeywordTab_t *cmd; // selected command
- bool force_width_64; // finally reduce image size to width of 64 pixles
+ int force_width; // !=128: finally resize image size to width given
int width; // width of image
int height; // height of image
Color_t color; // default color
diff --git a/project/src/lib-image2.c b/project/src/lib-image2.c
index c453181..c18d249 100644
--- a/project/src/lib-image2.c
+++ b/project/src/lib-image2.c
@@ -568,13 +568,41 @@ static enumError CreateGenericCupImagesIMG
DASSERT(par);
DASSERT(img);
- enum { I_ARROWS, I_ORIG, I_SWAPPED, I_WIIMM };
+ enum
+ { I_ARROWS,
+ I_ORIG,
+ I_SWAPPED,
+ I_WIIMM,
+
+ I_PIXEL = 0x10, // N(pixel) = ( ( VAL & I_M_PIXEL ) >> I_S_PIXEL ) * 8 + 8
+ I_M_PIXEL = 0xf0,
+ I_S_PIXEL = 4,
+ };
+
static const KeywordTab_t keytab[] =
{
{ I_ARROWS, "ARROWS", 0, 0 },
{ I_ORIG, "ORIGINAL", 0, 0 },
{ I_SWAPPED, "SWAPPED", 0, 0 },
{ I_WIIMM, "WIIMM", 0, 0 },
+
+ { 0*I_PIXEL, "8PIXELS", 0, I_M_PIXEL },
+ { 1*I_PIXEL, "16PIXELS", 0, I_M_PIXEL },
+ { 2*I_PIXEL, "24PIXELS", 0, I_M_PIXEL },
+ { 3*I_PIXEL, "32PIXELS", 0, I_M_PIXEL },
+ { 4*I_PIXEL, "40PIXELS", 0, I_M_PIXEL },
+ { 5*I_PIXEL, "48PIXELS", 0, I_M_PIXEL },
+ { 6*I_PIXEL, "56PIXELS", 0, I_M_PIXEL },
+ { 7*I_PIXEL, "64PIXELS", 0, I_M_PIXEL },
+ { 8*I_PIXEL, "72PIXELS", 0, I_M_PIXEL },
+ { 9*I_PIXEL, "80PIXELS", 0, I_M_PIXEL },
+ { 10*I_PIXEL, "88PIXELS", 0, I_M_PIXEL },
+ { 11*I_PIXEL, "96PIXELS", 0, I_M_PIXEL },
+ { 12*I_PIXEL, "104PIXELS", 0, I_M_PIXEL },
+ { 13*I_PIXEL, "112PIXELS", 0, I_M_PIXEL },
+ { 14*I_PIXEL, "120PIXELS", 0, I_M_PIXEL },
+ { 15*I_PIXEL, "128PIXELS", 0, I_M_PIXEL },
+
{0,0,0,0},
};
@@ -652,11 +680,10 @@ static enumError CreateGenericCupIconIMG
parlist = BehindMem(parlist,pipe?pipe+1:0);
PRINT0("%d+%d : %.*s\n",text.len,parlist.len,text.len,text.ptr);
- if ( text.len == 3 && !memcmp(text.ptr,":64",3) )
+ if ( text.len > 2 && *text.ptr == ':' && !memcmp(text.ptr+text.len-2,"px",2) )
{
- PRINT0(">>>>> width 64\n");
- par->force_width_64 = true;
- continue;
+ par->force_width = str2ul(text.ptr+1,0,10);
+ PRINT0(">>>>> width %u\n",par->force_width);
}
Image_t cupicon;
@@ -851,8 +878,8 @@ enumError CreateGenericIMG
return ERR_NOT_EXISTS;
}
- if ( !err && par->force_width_64 )
- ResizeIMG(img,false,img,64,0);
+ if ( !err && par->force_width != 128 )
+ ResizeIMG(img,false,img,par->force_width,0);
return err;
}
@@ -1363,7 +1390,7 @@ enumError SaveTPL
Image_t *src_img, // pointer to valid source img
FILE *f, // output file, if NULL then use fname+overwrite
ccp fname, // filename of source
- bool overwrite // true: force overwriting
+ bool overwrite // true: allow overwriting
)
{
DASSERT(src_img);
diff --git a/project/src/lib-lecode.c b/project/src/lib-lecode.c
index 45582b0..dc1645b 100644
--- a/project/src/lib-lecode.c
+++ b/project/src/lib-lecode.c
@@ -846,7 +846,7 @@ const mem_t GetLecodeLEREG ( le_region_t reg )
if ( idx > LEREG__END )
return NullMem;
- DecodeCompressManager(&lecode4_bin_mgr);
+ DecompressManager(&lecode4_bin_mgr);
const u32 *poslist = (u32*)lecode4_bin_mgr.data;
const u32 pos = ntohl(poslist[idx]);
mem_t res;
@@ -1302,6 +1302,7 @@ void InitializeLPAR ( le_lpar_t *lpar, bool load_lpar )
lpar->default_online_sec = LE_DEF_ONLINE_SEC;
lpar->min_online_sec = LE_DEF_ONLINE_SEC;
lpar->max_online_sec = LE_MAX_WD_ONLINE_SEC;
+ lpar->cup_icon_size = 128;
// [[new-lpar]]
@@ -1371,6 +1372,10 @@ static void NormalizeLPAR ( le_lpar_t * lp, int build )
lp->max_online_sec = MINMAX( lp->max_online_sec, lp->min_online_sec, LE_MAX_ONLINE_SEC );
}
+ lp->cup_icon_size &= 0xf8;
+ if (!lp->cup_icon_size)
+ lp->cup_icon_size = 128;
+
// [[new-lpar]]
#if 0
@@ -1378,7 +1383,6 @@ static void NormalizeLPAR ( le_lpar_t * lp, int build )
for ( int l = 0; l < LEDEB__N_LINE; l++ )
lp->debug[c][l] &= LEDEB__ALL;
#endif
-
}
///////////////////////////////////////////////////////////////////////////////
@@ -1478,6 +1482,9 @@ static void CopyLPAR2Data ( le_analyze_t * ana )
h->dev_mode3 = lp->dev_mode3;
}
+ if ( offsetof(le_binpar_v1_t,cup_icon_size) < ana->param_size )
+ h->cup_icon_size = lp->cup_icon_size;
+
// [[new-lpar]]
}
@@ -1640,10 +1647,11 @@ enumError WriteSectionLPAR
,lpar->default_online_sec ,PrintHMS(0,0,lpar->default_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
,lpar->min_online_sec ,PrintHMS(0,0,lpar->min_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
,lpar->max_online_sec ,PrintHMS(0,0,lpar->max_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
- ,lpar->developer_modes
- ,lpar->dev_mode1
- ,lpar->dev_mode2
- ,lpar->dev_mode3
+ ,lpar->cup_icon_size
+ ,lpar->developer_modes
+ ,lpar->dev_mode1
+ ,lpar->dev_mode2
+ ,lpar->dev_mode3
);
}
else
@@ -1673,6 +1681,7 @@ enumError WriteSectionLPAR
"DEF-ONLINE-SEC = %3u%s\r\n"
"MIN-ONLINE-SEC = %3u%s\r\n"
"MAX-ONLINE-SEC = %3u%s\r\n"
+ "CUP-ICON-SIZE = %u\r\n"
"\r\n"
"DEVELOPER-MODES = %u\r\n" // always last 4 settings
"DEV-MODE1 = %u\r\n"
@@ -1700,10 +1709,11 @@ enumError WriteSectionLPAR
,lpar->default_online_sec ,PrintHMS(0,0,lpar->default_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
,lpar->min_online_sec ,PrintHMS(0,0,lpar->min_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
,lpar->max_online_sec ,PrintHMS(0,0,lpar->max_online_sec,LE_VIEW_ONLINE_HMS," # ",0)
- ,lpar->developer_modes
- ,lpar->dev_mode1
- ,lpar->dev_mode2
- ,lpar->dev_mode3
+ ,lpar->cup_icon_size
+ ,lpar->developer_modes
+ ,lpar->dev_mode1
+ ,lpar->dev_mode2
+ ,lpar->dev_mode3
);
}
@@ -2192,6 +2202,12 @@ enumError AnalyzeLEBinary
ana->lpar.dev_mode3 = p->dev_mode3;
}
+ if ( param_size >= sizeof(le_binpar_v1_276_t) )
+ {
+ le_binpar_v1_276_t *p = (le_binpar_v1_276_t*)(data+off_param);
+ ana->lpar.cup_icon_size = p->cup_icon_size;
+ }
+
// [[new-lpar]]
break;
@@ -3394,6 +3410,10 @@ void DumpLEAnalyse ( FILE *f, uint indent, const le_analyze_t *ana )
);
}
+ if ( ana->param_size >= sizeof(le_binpar_v1_276_t) )
+ fprintf(f,"%*s" "Cup image size: %u x %u pixels\n"
+ ,indent,"", h->cup_icon_size, h->cup_icon_size );
+
// [[new-lpar]]
#if 0 // for later use
@@ -4140,12 +4160,10 @@ static enumError ScanTextLPAR_PARAM
{ "DEF-ONLINE-SEC", SPM_U16, &lpar->default_online_sec },
{ "MIN-ONLINE-SEC", SPM_U16, &lpar->min_online_sec },
{ "MAX-ONLINE-SEC", SPM_U16, &lpar->max_online_sec },
- #if 1
- { "USE-AVAIL-TXT", SPM_DOUBLE_X, &use_avail_txt }, // [[obsolete]] 2023-09
- #else
- { "USE-AVAIL-TXT", SPM_U8, &lpar->use_avail_txt },
- #endif
+ { "CUP-ICON-SIZE", SPM_U8, &lpar->cup_icon_size },
// [[new-lpar]]
+
+ { "USE-AVAIL-TXT", SPM_DOUBLE_X, &use_avail_txt }, // [[obsolete]] 2023-09
{0}
};
diff --git a/project/src/lib-lecode.h b/project/src/lib-lecode.h
index 8e690d2..711c1ca 100644
--- a/project/src/lib-lecode.h
+++ b/project/src/lib-lecode.h
@@ -344,7 +344,8 @@ typedef struct le_lpar_t
u8 vs_textures; // &1: enable texture hacks for versus, &2:alternable
u8 block_textures; // >0: enable blocking of recent texture hacks
u8 staticr_points; // >0: use points definied by StaticR.rel
- u8 use_avail_txt; // [[obsolete]] >0: use file "avail.txt" to detect dir "Race/Common/###/"
+ u8 use_avail_txt; // unused: // >0: use file "avail.txt" to detect dir "Race/Common/###/"
+ u8 cup_icon_size; // size of single cup icon, usually 128 (128x128)
u8 debug_mode; // debug mode
u8 debug_predef[LEDEB__N_CONFIG];
@@ -1132,9 +1133,9 @@ __attribute__ ((packed)) le_binpar_v1_274_t;
_Static_assert(sizeof(le_binpar_v1_274_t)==0x274,"le_binpar_v1_274_t");
//-----------------------------------------------------------------------------
-// [[le_binpar_v1_275_t]]
+// [[le_binpar_v1_276_t]]
-typedef struct le_binpar_v1_275_t
+typedef struct le_binpar_v1_276_t
{
//--- le_binary_param_t
@@ -1218,21 +1219,25 @@ typedef struct le_binpar_v1_275_t
/*273*/ u8 dev_mode3; // Third developer mode
//--- le_binpar_v1_275_t
-
+ // not longer used
/*274*/ u8 use_avail_txt; // >0: use file "avail.txt" to detect dir "Race/Common/###/"
+ //--- le_binpar_v1_276_t
+
+ /*275*/ u8 cup_icon_size; // Size of single cup icon, usually 128 (128x128)
+
//--- END
- /*275*/
+ /*276*/
}
-__attribute__ ((packed)) le_binpar_v1_275_t;
+__attribute__ ((packed)) le_binpar_v1_276_t;
-_Static_assert(sizeof(le_binpar_v1_275_t)==0x275,"le_binpar_v1_275_t");
+_Static_assert(sizeof(le_binpar_v1_276_t)==0x276,"le_binpar_v1_276_t");
//-----------------------------------------------------------------------------
// [[le_binpar_v1_t]] [[new-lpar]]
-typedef struct le_binpar_v1_275_t le_binpar_v1_t;
+typedef struct le_binpar_v1_276_t le_binpar_v1_t;
//
///////////////////////////////////////////////////////////////////////////////
diff --git a/project/src/lib-ledis.c b/project/src/lib-ledis.c
index e960561..20cedf6 100644
--- a/project/src/lib-ledis.c
+++ b/project/src/lib-ledis.c
@@ -175,11 +175,11 @@ static KeywordTab_t keywords_leo[] =
{ LTT_SHA1_D, "D-SHA1", "DSHA1", LEO_LTT_SELECTOR },
{ LTT_IDENT, "IDENT", 0, LEO_LTT_SELECTOR },
{ LTT_IDENT_D, "D-IDENT", "DIDENT", LEO_LTT_SELECTOR },
- { LTT_FILE, "FILES", 0, LEO_LTT_SELECTOR },
- { LTT_PATH, "PATHS", 0, LEO_LTT_SELECTOR },
- { LTT_NAME, "NAMES", 0, LEO_LTT_SELECTOR },
- { LTT_XNAME, "XNAMES", 0, LEO_LTT_SELECTOR },
- { LTT_XNAME2, "X2NAMES", 0, LEO_LTT_SELECTOR },
+ { LTT_FILE, "FILES", "FILE", LEO_LTT_SELECTOR },
+ { LTT_PATH, "PATHS", "PATH", LEO_LTT_SELECTOR },
+ { LTT_NAME, "NAMES", "NAME", LEO_LTT_SELECTOR },
+ { LTT_XNAME, "XNAMES", "XNAME", LEO_LTT_SELECTOR },
+ { LTT_XNAME2, "X2NAMES", "X2NAME", LEO_LTT_SELECTOR },
#if LE_STRING_LIST_ENABLED
{ LTT_TEMP1, "TEMP1", 0, LEO_LTT_SELECTOR },
{ LTT_TEMP2, "TEMP2", 0, LEO_LTT_SELECTOR },
@@ -220,6 +220,9 @@ static KeywordTab_t keywords_leo[] =
{ LEO_IN_LECODE, "IN-LECODE", "INLECODE", 0 },
{ LEO_IN_LECODE, "ILECODE", 0, 0 },
{ LEO_NO_SLOT, "NO-SLOT", "NOSLOT", 0 },
+ { LEO_HEX2SLOT, "HEX2SLOT", 0, 0 },
+ { LEO_NAME2SLOT, "NAME2SLOT", 0, 0 },
+ { LEO_CT_SLOTS, "CT-SLOTS", "CTSLOTS", 0 },
{ LEO_BRIEF, "BRIEF", 0, 0 },
{ LEO_AUTO_PATH, "AUTO-PATH", "AUTOPATH", 0 },
@@ -4126,6 +4129,7 @@ le_track_arch_t * GetNextArchLD ( le_distrib_t *ld )
ta->lt.track_slot = ld->arch_used++; // index of 'arch'
ta->lt.track_status = LTS_EXPORT;
+ ta->force_slot = -1;
ta->attr_order = 1000;
ta->plus_order = 10000000;
ta->game_order = 10000000;
@@ -4140,9 +4144,48 @@ enumError AddToArchLD ( le_distrib_t *ld, raw_data_t *raw )
if ( !ld || !raw )
return ERR_MISSING_PARAM;
- char buf[LE_TRACK_STRING_MAX+1];
+ char buf[LE_TRACK_STRING_MAX+1], fname_buf[LE_TRACK_STRING_MAX+1];
exmem_dest_t exdest = { .buf = buf, .buf_size = sizeof(buf), .try_circ = true };
+// [[split-le-flags]]
+ split_filename_t spf;
+ AnalyseSPF(&spf,true,raw->fname,0,CPM_LINK,opt_plus);
+
+ int force_slot = -1;
+ if ( ld->spar.opt & (LEO_HEX2SLOT|LEO_NAME2SLOT) )
+ {
+ if (!spf.f_d.len)
+ {
+ if ( ld->spar.opt & LEO_HEX2SLOT && spf.f_name.len == 3 )
+ {
+ const uint slot = str2ul(spf.f_name.ptr,0,16);
+ snprintf(fname_buf,sizeof(fname_buf),"%03x",slot);
+ if (!strncasecmp(spf.f_name.ptr,fname_buf,3))
+ {
+ PRINT0("HEX: %.3s\n",spf.f_name.ptr);
+ force_slot = slot;
+ }
+ }
+
+ if ( ld->spar.opt & LEO_NAME2SLOT )
+ {
+ StringCopySM(fname_buf,sizeof(fname_buf),spf.f_name.ptr,spf.f_name.len);
+ const int slot = FindTrackSlot(fname_buf,true);
+ if ( slot >= 0 )
+ {
+ PRINT0("NAME: 0x%02x = %s\n",slot,fname_buf);
+ force_slot = slot;
+ }
+ }
+ }
+
+ if ( !IsUsableXcodeSlot(force_slot,ld->spar.opt&LEO_CT_SLOTS) )
+ {
+ ResetSPF(&spf);
+ return ERR_JOB_IGNORED;
+ }
+ }
+
szs_file_t szs;
AssignSZS(&szs,true,raw->data,raw->data_size,false,raw->fform,raw->fname);
@@ -4152,10 +4195,6 @@ enumError AddToArchLD ( le_distrib_t *ld, raw_data_t *raw )
as.sha1_szs,
as.slotinfo.race_slot, as.slotinfo.arena_slot, as.slotinfo.music_index );
-// [[split-le-flags]]
- split_filename_t spf;
- AnalyseSPF(&spf,true,raw->fname,0,CPM_LINK,opt_plus);
-
enumError err = ERR_WARNING;
if ( as.valid_track && !spf.f_d.len )
{
@@ -4169,6 +4208,7 @@ enumError AddToArchLD ( le_distrib_t *ld, raw_data_t *raw )
le_track_arch_t *ta = GetNextArchLD(ld);
ta->lt.lap_count = as.lap_count;
ta->lt.speed_factor = as.speed_factor;
+ ta->force_slot = force_slot;
if (szs.is_arena)
{
@@ -4262,6 +4302,7 @@ enumError AddToArchLD ( le_distrib_t *ld, raw_data_t *raw )
}
// setfilelt ->file
+// lti
///////////////////////////////////////////////////////////////////////////////
@@ -4300,6 +4341,7 @@ bool CloseArchLD ( le_distrib_t *ld )
if ( !ld || !ld->arch )
return false;
+
//-- manage groups
exmem_key_t *ek = ld->group.list;
@@ -4368,10 +4410,16 @@ bool CloseArchLD ( le_distrib_t *ld )
for ( ptr = order; *ptr; ptr++ )
{
le_track_arch_t *ta = *ptr;
- le_track_t *lt = IsRandomLEFL(ta->lt.flags)
+ le_track_t *lt = ta->force_slot >= 0
+ ? DefineTrackLD(ld,ta->force_slot,false)
+ : IsRandomLEFL(ta->lt.flags)
? DefineGroupTrackLD(ld,ta->lt.track_type,true)
: DefineFreeTrackLD(ld,ta->lt.track_type,true);
+ if (!lt)
+ continue;
+
ta->lt.track_slot = lt->track_slot;
+ ResetLT(lt);
*lt = ta->lt;
if (ta->group)
@@ -4416,6 +4464,28 @@ bool CloseArchLD ( le_distrib_t *ld )
return true;
}
+//-----------------------------------------------------------------------------
+
+bool CloseArchLogLD ( le_distrib_t *ld )
+{
+ if (IsActiveArchLD(ld))
+ {
+ const u_nsec_t start_nsec = GetTimerNSec();
+
+ if ( verbose >= 1 )
+ PrintDistribHead("Close Track Archive");
+
+ if ( CloseArchLD(ld) && verbose >= 2 )
+ {
+ const u_nsec_t dur = GetTimerNSec() - start_nsec;
+ fprintf(stdlog,"%s >> Track archive closed in %s%s\n",
+ collog->status, PrintTimerNSec6(0,0,dur,0), collog->reset );
+ }
+ return true;
+ }
+ return false;
+}
+
//
///////////////////////////////////////////////////////////////////////////////
/////////////// le_distrib_t: import ///////////////
@@ -4760,6 +4830,9 @@ enumError ImportRawDataLD
if (!ld->is_initialized)
InitializeLD(ld);
+ if ( raw->fform != FF_U8 )
+ CloseArchLogLD(ld);
+
if ( logging >= 2 && raw->fname )
fprintf(stdlog,"Import data to LD: %s\n",raw->fname);
@@ -5848,7 +5921,6 @@ static void print_ledef_track
}
}
#endif
-
}
//-----------------------------------------------------------------------------
@@ -6278,12 +6350,15 @@ enumError CreateCupIconsLD ( ld_out_param_t *lop, mem_t mem_opt, bool print_info
O_XGAME = 0x0100,
O_SPACE = 0x0200,
- O_64 = 0x0400,
-
O_CHARS = 0x1000,
O_M_CHARS = 0xf000,
O_S_CHARS = 12,
+ O_PIXEL = 0x010000, // N(pixel) = ( (val&O_M_PIXEL) >> O_S_PIXEL ) * O_PIXEL_FACTOR
+ O_M_PIXEL = 0x1f0000,
+ O_S_PIXEL = 16,
+ O_PIXEL_FACTOR = 8,
+
O__DEFAULT = 5*O_CHARS,
};
@@ -6301,9 +6376,6 @@ enumError CreateCupIconsLD ( ld_out_param_t *lop, mem_t mem_opt, bool print_info
{ O_XGAME, "XGAME", 0, 0 },
{ O_SPACE, "SPACE", 0, 0 },
- { O_64, "64", 0, O_64 },
- { 0, "128", 0, O_64 },
-
{ 0*O_CHARS, "0", 0, O_M_CHARS },
{ 1*O_CHARS, "1", 0, O_M_CHARS },
{ 2*O_CHARS, "2", 0, O_M_CHARS },
@@ -6320,6 +6392,39 @@ enumError CreateCupIconsLD ( ld_out_param_t *lop, mem_t mem_opt, bool print_info
{ 13*O_CHARS, "13", 0, O_M_CHARS },
{ 14*O_CHARS, "14", 0, O_M_CHARS },
{ 15*O_CHARS, "15", 0, O_M_CHARS },
+
+ { 1*O_PIXEL, "8PX", 0, O_M_PIXEL },
+ { 2*O_PIXEL, "16PX", 0, O_M_PIXEL },
+ { 3*O_PIXEL, "24PX", 0, O_M_PIXEL },
+ { 4*O_PIXEL, "32PX", 0, O_M_PIXEL },
+ { 5*O_PIXEL, "40PX", 0, O_M_PIXEL },
+ { 6*O_PIXEL, "48PX", 0, O_M_PIXEL },
+ { 7*O_PIXEL, "56PX", 0, O_M_PIXEL },
+ { 8*O_PIXEL, "64PX", 0, O_M_PIXEL },
+ { 9*O_PIXEL, "72PX", 0, O_M_PIXEL },
+ { 10*O_PIXEL, "80PX", 0, O_M_PIXEL },
+ { 11*O_PIXEL, "88PX", 0, O_M_PIXEL },
+ { 12*O_PIXEL, "96PX", 0, O_M_PIXEL },
+ { 13*O_PIXEL, "104PX", 0, O_M_PIXEL },
+ { 14*O_PIXEL, "112PX", 0, O_M_PIXEL },
+ { 15*O_PIXEL, "120PX", 0, O_M_PIXEL },
+ { 16*O_PIXEL, "128PX", 0, O_M_PIXEL },
+ { 17*O_PIXEL, "136PX", 0, O_M_PIXEL },
+ { 18*O_PIXEL, "144PX", 0, O_M_PIXEL },
+ { 19*O_PIXEL, "152PX", 0, O_M_PIXEL },
+ { 20*O_PIXEL, "160PX", 0, O_M_PIXEL },
+ { 21*O_PIXEL, "168PX", 0, O_M_PIXEL },
+ { 22*O_PIXEL, "176PX", 0, O_M_PIXEL },
+ { 23*O_PIXEL, "184PX", 0, O_M_PIXEL },
+ { 24*O_PIXEL, "192PX", 0, O_M_PIXEL },
+ { 25*O_PIXEL, "200PX", 0, O_M_PIXEL },
+ { 26*O_PIXEL, "208PX", 0, O_M_PIXEL },
+ { 27*O_PIXEL, "216PX", 0, O_M_PIXEL },
+ { 28*O_PIXEL, "224PX", 0, O_M_PIXEL },
+ { 29*O_PIXEL, "232PX", 0, O_M_PIXEL },
+ { 30*O_PIXEL, "240PX", 0, O_M_PIXEL },
+ { 31*O_PIXEL, "248PX", 0, O_M_PIXEL },
+
{0,0,0,0}
};
@@ -6341,8 +6446,9 @@ enumError CreateCupIconsLD ( ld_out_param_t *lop, mem_t mem_opt, bool print_info
if (!opt)
opt = O__DEFAULT;
- if ( opt & O_64 )
- dest = StringCopyE(dest,bufend,":64\n");
+ const uint pix = (( opt & O_M_PIXEL ) >> O_S_PIXEL ) * O_PIXEL_FACTOR;
+ if ( pix && pix != 128 )
+ dest = snprintfE(dest,bufend,":%upx\n",pix);
dest = StringCopyE(dest,bufend,":arrows\n");
enumError err = ERR_OK;
@@ -8802,6 +8908,24 @@ void ScanOptLeDefine ( ccp arg )
///////////////////////////////////////////////////////////////////////////////
+void PrintDistribHead ( ccp format, ... )
+{
+ if (stdlog)
+ {
+ char buf[500];
+ va_list arg;
+ va_start(arg,format);
+ vsnprintf(buf,sizeof(buf),format,arg);
+ va_end(arg);
+
+ ASSERT(collog);
+ fprintf(stdlog,"%s▼ %s%s\n",collog->caption,buf,collog->reset);
+ fflush(stdlog);
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
ccp GetNameLTS ( le_track_status_t lts )
{
switch(lts)
diff --git a/project/src/lib-ledis.h b/project/src/lib-ledis.h
index ed4cc01..6596a68 100644
--- a/project/src/lib-ledis.h
+++ b/project/src/lib-ledis.h
@@ -321,23 +321,26 @@ typedef enum le_options_t
LEO_IN_LECODE = 0x00100000, // import lecode binary
LEO_NO_SLOT = 0x00200000, // suppress 'SLOT <num>' if creating a LE-DEF file.
- LEO_BRIEF = 0x00400000, // suppress descriptions
- LEO_AUTO_PATH = 0x00800000, // enable auto paths
+ LEO_HEX2SLOT = 0x00400000, // if reading an szs of format '%03x.*', use it to force slot
+ LEO_NAME2SLOT = 0x00800000, // if reading an szs, use its filename to force number
+ LEO_CT_SLOTS = 0x01000000, // LEO_HEX2SLOT,LEO_NAME2SLOT: check for ct-code slots
+ LEO_BRIEF = 0x02000000, // suppress descriptions
+ LEO_AUTO_PATH = 0x04000000, // enable auto paths
//-- special signals
- LEO_CUT_ALL = 0x01000000, // cut all
- LEO_CUT_STD = 0x02000000, // cut for standard distribution.
- LEO_CUT_CTCODE = 0x04000000, // cut for CT-CODE distribution.
+ LEO_CUT_ALL = 0x08000000, // cut all
+ LEO_CUT_STD = 0x10000000, // cut for standard distribution.
+ LEO_CUT_CTCODE = 0x20000000, // cut for CT-CODE distribution.
LEO_M_CUT = LEO_CUT_ALL | LEO_CUT_STD | LEO_CUT_CTCODE,
- LEO_HELP = 0x08000000, // print help and exit
+ LEO_HELP = 0x40000000, // print help and exit
//-- misc
- LEO__ALL = 0x07ffffff,
+ LEO__ALL = 0x1fffffff,
LEO__DEFAULT = LTT__DEFAULT | LEO_OVERWRITE | LEO_OUT_DUMMY | LEO_AUTO_PATH,
LEO__SRC = LEO_LTT_SELECTOR | LEO_IN_ALL,
LEO__DEST = LEO_LTT_SELECTOR | LEO_OUT_ALL | LEO_M_OUTPUT | LEO_M_HOW,
@@ -667,13 +670,14 @@ typedef struct le_track_arch_t
le_group_t group; // group id
// [[mtcat]]
- // all string alloced
+ // all strings are alloced
ccp name_order; // relevant name for order
ccp version; // version
// order := attr_order plus_order name_order game_order
+ int force_slot; // ≥0: force slot
int attr_order; // order by attribute, default=1000
int plus_order; // order by plus prefix
int game_order; // order by game prefix
@@ -872,6 +876,10 @@ void ResetArchLD ( le_distrib_t *ld );
le_track_arch_t * GetNextArchLD ( le_distrib_t *ld );
enumError AddToArchLD ( le_distrib_t *ld, raw_data_t *raw );
bool CloseArchLD ( le_distrib_t *ld ); // return true on activity
+bool CloseArchLogLD ( le_distrib_t *ld ); // return true on activity
+
+static inline bool IsActiveArchLD ( le_distrib_t *ld )
+ { return ld && ld->arch; }
//-----------------------------------------------------------------------------
@@ -1178,6 +1186,9 @@ void ScanSlotTranslation
void ScanOptLeDefine ( ccp arg );
+void PrintDistribHead ( ccp format, ... )
+ __attribute__ ((__format__(__printf__,1,2)));
+
//
///////////////////////////////////////////////////////////////////////////////
/////////////// END ///////////////
diff --git a/project/src/lib-lex.c b/project/src/lib-lex.c
index ed49f9b..5374d80 100644
--- a/project/src/lib-lex.c
+++ b/project/src/lib-lex.c
@@ -161,6 +161,7 @@ static const feature_var_t lex_section_list[] =
DEF_VAR( 0,HAVELEXS_DEV1, lex_sect_dev1, "LEX section DEV1" ),
DEF_VAR( 0,HAVELEXS_SET1, lex_sect_set1, "LEX section SET1" ),
DEF_VAR( 0,HAVELEXS_CANN, lex_sect_cann, "LEX section CANN" ),
+ DEF_VAR( 0,HAVELEXS_CTDN, lex_sect_ctdn, "LEX section CTDN" ),
DEF_VAR( 0,HAVELEXS_HIPT, lex_sect_hipt, "LEX section HIPT" ),
DEF_VAR( 0,HAVELEXS_RITP, lex_sect_ritp, "LEX section RITP" ),
@@ -573,6 +574,7 @@ const features_szs_t * GetFeaturesModes()
m.lex_sect_dev1 = FZM_SECTION;
m.lex_sect_set1 = FZM_GAMEPLAY | FZM_M_TYPE | FZM_ONLINE | FZM_SECTION;
m.lex_sect_cann = FZM_GAMEPLAY | FZM_M_TYPE | FZM_M_WHERE | FZM_SECTION;
+ m.lex_sect_ctdn = FZM_SECTION;
m.lex_sect_hipt = FZM_VISUAL | FZM_M_TYPE | no_timetrial | FZM_SECTION;
m.lex_sect_ritp = FZM_GAMEPLAY | FZM_M_TYPE | no_timetrial | FZM_SECTION;
@@ -916,6 +918,65 @@ static bool IsActiveLEXElement_SET1 ( const lex_set1_t *set1 )
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
+static void FixLEXElement_CTDN ( lex_ctdn_t *ctdn )
+{
+ DASSERT(ctdn);
+
+ u16 tlimit[LEC__N];
+ be16n(tlimit,ctdn->time_limit_sec,LEC__N);
+
+ if (!tlimit[LEC_150CC])
+ tlimit[LEC_150CC] = 150;
+ for ( int i = LEC_150CC - 1; i >= 0; i-- )
+ if (!tlimit[i])
+ tlimit[i] = tlimit[i+1];
+ for ( int i = LEC_150CC+1; i < LEC__N; i++ )
+ if (!tlimit[i])
+ tlimit[i] = tlimit[i-1];
+
+ write_be16n(ctdn->time_limit_sec,tlimit,LEC__N);
+ // [[new-lex-ctdn]]
+}
+
+//-----------------------------------------------------------------------------
+
+static void FixLEXItem_CTDN
+(
+ lex_t * lex, // LEX data structure
+ lex_item_t * item // item to fix
+)
+{
+ DASSERT(lex);
+ DASSERT(item);
+ DASSERT( ntohl(item->elem.size) >= sizeof(lex_ctdn_t) );
+
+ lex_ctdn_t *ctdn = (lex_ctdn_t*)item->elem.data;
+ FixLEXElement_CTDN(ctdn);
+}
+
+//-----------------------------------------------------------------------------
+
+static void ClearLEXElement_CTDN ( lex_ctdn_t *ctdn )
+{
+ DASSERT(ctdn);
+ memset(ctdn,0,sizeof(*ctdn));
+ FixLEXElement_CTDN(ctdn);
+}
+
+//-----------------------------------------------------------------------------
+
+static bool IsActiveLEXElement_CTDN ( const lex_ctdn_t *ctdn )
+{
+ DASSERT(ctdn);
+ lex_ctdn_t empty, test = *ctdn;
+ ClearLEXElement_CTDN(&empty);
+ FixLEXElement_CTDN(&test);
+ return memcmp(&empty,&test,sizeof(empty)) != 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
// [[new-lex-sect]] upto 4 functions, see SET1 above
///////////////////////////////////////////////////////////////////////////////
@@ -1121,6 +1182,12 @@ static lex_item_t * AppendElementLEX
size4 = ALIGN32(sizeof(lex_set1_t),4);
break;
+ case LEXS_CTDN:
+ fix_func = FixLEXItem_CTDN;
+ if ( size4 < sizeof(lex_ctdn_t) )
+ size4 = ALIGN32(sizeof(lex_ctdn_t),4);
+ break;
+
// [[new-lex-sect]]
case LEXS_TEST:
@@ -1311,6 +1378,7 @@ uint GetLexFeatures ( const lex_element_t *elem, lex_t *lex )
//case LEXS_DEV1: return GetLexFeaturesDEV1(elem,lex); // will never have features
case LEXS_SET1: return GetLexFeaturesSET1(elem,lex);
case LEXS_CANN: return GetLexFeaturesCANN(elem);
+//X case LEXS_CTDN: return GetLexFeaturesCTDN(elem);
case LEXS_HIPT: return GetLexFeaturesHIPT(elem);
case LEXS_RITP: return GetLexFeaturesRITP(elem);
case LEXS_TEST: return GetLexFeaturesTEST(elem);
@@ -1371,6 +1439,7 @@ const have_lex_info_t have_lex_sect_info[HAVELEXS__N] =
{ LEXS_FEAT, "features", 2 }, // HAVELEXS_FEAT
{ LEXS_RITP, "rnditph", sizeof(lex_ritp_rule_t) }, // HAVELEXS_RITP
{ LEXS_DEV1, "dev1", 1 }, // HAVELEXS_DEV1
+ { LEXS_CTDN, "countdown", 0 }, // HAVELEXS_CTDN
//--- add new sections here (order is important)
// [[new-lex-sect]]
};
@@ -1453,6 +1522,9 @@ void UpdateLEX ( lex_t * lex, bool add_missing, bool add_test )
//--- CANN
AppendCannLEX(lex,false);
+ //--- CTDN
+ AppendCtdnLEX(lex,false);
+
//--- HIPT
AppendHiptLEX(lex,false);
@@ -1487,8 +1559,7 @@ lex_item_t * AppendFeatLEX
lex_item_t * AppendDev1LEX ( lex_t * lex, bool overwrite )
{
- lex_dev1_t dev1;
- memset(&dev1,0,sizeof(dev1));
+ lex_dev1_t dev1 = {0};
// AppendElementLEX() does call FixLEXItem_DEV1()
return AppendElementLEX(lex,LEXS_DEV1,&dev1,sizeof(dev1),overwrite);
}
@@ -1497,8 +1568,7 @@ lex_item_t * AppendDev1LEX ( lex_t * lex, bool overwrite )
lex_item_t * AppendSet1LEX ( lex_t * lex, bool overwrite )
{
- lex_set1_t set1;
- memset(&set1,0,sizeof(set1));
+ lex_set1_t set1 = {0};
// AppendElementLEX() does call FixLEXItem_SET1()
return AppendElementLEX(lex,LEXS_SET1,&set1,sizeof(set1),overwrite);
}
@@ -1513,6 +1583,15 @@ lex_item_t * AppendCannLEX ( lex_t * lex, bool overwrite )
//-----------------------------------------------------------------------------
+lex_item_t * AppendCtdnLEX ( lex_t * lex, bool overwrite )
+{
+ lex_ctdn_t ctdn = {0};
+ // AppendElementLEX() does call FixLEXItem_CTDN()
+ return AppendElementLEX(lex,LEXS_CTDN,&ctdn,sizeof(ctdn),overwrite);
+}
+
+//-----------------------------------------------------------------------------
+
lex_item_t * AppendHiptLEX ( lex_t * lex, bool overwrite )
{
return AppendElementLEX( lex, LEXS_HIPT, 0, 0, overwrite );
@@ -1734,6 +1813,7 @@ typedef enum lex_section_id
LID_DEVELOP1,
LID_SETTINGS1,
LID_CANNON,
+ LID_COUNTDOWN,
LID_HIDE_PT,
LID_RND_ITPH,
LID_TEST,
@@ -1757,6 +1837,7 @@ static const KeywordTab_t lex_section_name[] =
{ LID_DEVELOP1, "DEV1", "Developer settings", 0 },
{ LID_SETTINGS1, "SET1", "Primary settings", 0 },
{ LID_CANNON, "CANN", "Cannon settings", 0 },
+ { LID_COUNTDOWN, "CTDN", "Countdown settings", 0 },
{ LID_HIDE_PT, "HIPT", "Hide position tracker", 0 },
{ LID_RND_ITPH, "RITP", "Random next-links @KMP:ITPH", 0 },
{ LID_TEST, "TEST", "Test case", 0 },
@@ -2038,6 +2119,63 @@ static enumError ScanLEXElement_CANN
///////////////////////////////////////////////////////////////////////////////
+static enumError ScanLEXElement_CTDN
+(
+ lex_t * lex, // KMP data structure
+ ScanInfo_t * si // valid data
+)
+{
+ DASSERT(lex);
+ DASSERT(si);
+ TRACE("ScanLEXElement_CTDN()\n");
+
+
+ //--- setup data
+
+ lex_ctdn_t ctdn = {0};
+
+ ScanParam_t ptab[] =
+ {
+ { "TIME-LIMIT-BATTLE", SPM_U16_BE, ctdn.time_limit_sec + LEC_BATTLE },
+ { "TIME-LIMIT-50CC", SPM_U16_BE, ctdn.time_limit_sec + LEC_50CC },
+ { "TIME-LIMIT-100CC", SPM_U16_BE, ctdn.time_limit_sec + LEC_100CC },
+ { "TIME-LIMIT-150CC", SPM_U16_BE, ctdn.time_limit_sec + LEC_150CC },
+ { "TIME-LIMIT-200CC", SPM_U16_BE, ctdn.time_limit_sec + LEC_200CC },
+ { "TIME-LIMIT-300CC", SPM_U16_BE, ctdn.time_limit_sec + LEC_300CC },
+ {0}
+ };
+
+ char fb_buf[1000];
+ FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf));
+ AppendFastBuf(fb,&ctdn,sizeof(ctdn));
+
+
+ //--- main loop
+
+ for(;;)
+ {
+ char ch = NextCharSI(si,true);
+ if ( !ch || ch == '[' )
+ break;
+
+ if ( ch == '@' )
+ ScanParamSI(si,ptab);
+ else
+ ScanHexlineSI(si,fb,true);
+ }
+ CheckLevelSI(si);
+
+ FixLEXElement_CTDN(&ctdn);
+ memcpy(fb->buf,&ctdn,sizeof(ctdn));
+ //HexDump16(stderr,0,0,fb->buf,fb->ptr-fb->buf);
+ AppendElementLEX(lex,LEXS_CTDN,fb->buf,fb->ptr-fb->buf,true);
+
+ ResetFastBuf(fb);
+ return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
static enumError ScanLEXElement_HIPT
(
lex_t * lex, // KMP data structure
@@ -2284,6 +2422,10 @@ enumError ScanTextLEX
err = ScanLEXElement_CANN(lex,&si);
break;
+ case LID_COUNTDOWN:
+ err = ScanLEXElement_CTDN(lex,&si);
+ break;
+
case LID_HIDE_PT:
err = ScanLEXElement_HIPT(lex,&si);
break;
@@ -2693,6 +2835,73 @@ static enumError SaveTextLEX_SET1
///////////////////////////////////////////////////////////////////////////////
+static enumError SaveTextLEX_CTDN
+(
+ FILE * f, // file to write
+ const lex_t * lex, // pointer to valid LEX
+ lex_item_t * item // item to save
+)
+{
+ DASSERT(f);
+ DASSERT(lex);
+ DASSERT(item);
+
+ const uint size = ntohl(item->elem.size);
+ noPRINT("SaveTextLEX_CTDN(), size=%u\n",size);
+ DASSERT( size >= sizeof(lex_ctdn_t) );
+ if ( size < sizeof(lex_ctdn_t))
+ return ERR_OK;
+
+ const u8 *data = item->elem.data;
+ const lex_ctdn_t *ctdn = (lex_ctdn_t*)data;
+
+ const uint cc050 = be16( ctdn->time_limit_sec + LEC_50CC );
+ const uint cc100 = be16( ctdn->time_limit_sec + LEC_100CC );
+ const uint cc150 = be16( ctdn->time_limit_sec + LEC_150CC );
+ const uint cc200 = be16( ctdn->time_limit_sec + LEC_200CC );
+ const uint cc300 = be16( ctdn->time_limit_sec + LEC_300CC );
+
+ if ( brief_count || export_count )
+ fprintf(f,
+ "%s[CTDN]\r\n\r\n"
+ "@TIME-LIMIT-50CC = %3u\r\n"
+ "@TIME-LIMIT-100CC = %3u\r\n"
+ "@TIME-LIMIT-150CC = %3u\r\n"
+ "@TIME-LIMIT-200CC = %3u\r\n"
+ "@TIME-LIMIT-300CC = %3u\r\n"
+ "\r\n"
+ ,section_sep
+ ,cc050
+ ,cc100
+ ,cc150
+ ,cc200
+ ,cc300
+ // [[new-lex-ctdn]]
+ );
+ else
+ fprintf(f,text_lex_elem_ctdn_cr
+ ,item->sort_order
+ ,cc050, PrintHMS(0,0,cc050,1," # ","")
+ ,cc100, PrintHMS(0,0,cc100,1," # ","")
+ ,cc150, PrintHMS(0,0,cc150,1," # ","")
+ ,cc200, PrintHMS(0,0,cc200,1," # ","")
+ ,cc300, PrintHMS(0,0,cc300,1," # ","")
+ // [[new-lex-ctdn]]
+ );
+
+ if ( size > sizeof(lex_ctdn_t) )
+ {
+ fputs("\r\n# Hex dump for unknown settings:\r\n",f);
+ HexDump(f,0,sizeof(lex_ctdn_t),5,16,
+ item->elem.data + sizeof(lex_ctdn_t),
+ size - sizeof(lex_ctdn_t) );
+ }
+
+ return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
static enumError SaveTextLEX_CANN
(
FILE * f, // file to write
@@ -2994,6 +3203,7 @@ enumError SaveTextLEX
case LEXS_DEV1: err = SaveTextLEX_DEV1(F.f,lex,s); break;
case LEXS_SET1: err = SaveTextLEX_SET1(F.f,lex,s); break;
case LEXS_CANN: err = SaveTextLEX_CANN(F.f,lex,s); break;
+ case LEXS_CTDN: err = SaveTextLEX_CTDN(F.f,lex,s); break;
case LEXS_HIPT: err = SaveTextLEX_HIPT(F.f,lex,s); break;
case LEXS_RITP: err = SaveTextLEX_RITP(F.f,lex,s); break;
case LEXS_TEST: err = SaveTextLEX_TEST(F.f,lex,s); break;
@@ -3454,16 +3664,24 @@ bool PurgeLEX ( lex_t * lex )
break;
case LEXS_DEV1:
- remove = !IsActiveLEXElement_DEV1((lex_dev1_t*)data);
+ remove = size == sizeof(lex_dev1_t)
+ && !IsActiveLEXElement_DEV1((lex_dev1_t*)data);
break;
case LEXS_SET1:
- remove = !IsActiveLEXElement_SET1((lex_set1_t*)data);
+ remove = size == sizeof(lex_set1_t)
+ && !IsActiveLEXElement_SET1((lex_set1_t*)data);
break;
case LEXS_CANN:
- remove = size <= sizeof(CannonDataLEX)
- && !memcmp(data,&CannonDataLEX,size);
+ remove = size < sizeof(CannonDataLEX)
+ || size == sizeof(CannonDataLEX)
+ && !memcmp(data,&CannonDataLEX,sizeof(CannonDataLEX));
+ break;
+
+ case LEXS_CTDN:
+ remove = size == sizeof(lex_ctdn_t)
+ && !IsActiveLEXElement_CTDN((lex_ctdn_t*)data);
break;
case LEXS_HIPT:
@@ -3477,7 +3695,8 @@ bool PurgeLEX ( lex_t * lex )
// [[new-lex-sect]]
case LEXS_TEST:
- remove = !IsActiveLEXElement_TEST((lex_test_t*)data);
+ remove = size == sizeof(lex_test_t)
+ && !IsActiveLEXElement_TEST((lex_test_t*)data);
break;
default:
diff --git a/project/src/lib-lex.h b/project/src/lib-lex.h
index a099263..53f165b 100644
--- a/project/src/lib-lex.h
+++ b/project/src/lib-lex.h
@@ -51,6 +51,25 @@ struct szs_have_t;
//
///////////////////////////////////////////////////////////////////////////////
+/////////////// lex_engine_class_t ///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[lex_engine_class_t]]
+
+typedef enum lex_engine_class_t
+{
+ LEC_BATTLE,
+ LEC_50CC,
+ LEC_100CC,
+ LEC_150CC,
+ LEC_200CC,
+ LEC_300CC, // >200cc
+
+ LEC__N
+}
+lex_engine_class_t;
+
+//
+///////////////////////////////////////////////////////////////////////////////
/////////////// features_szs_t ///////////////
///////////////////////////////////////////////////////////////////////////////
// [[features_szs_t]]
@@ -109,16 +128,19 @@ typedef struct features_szs_t
u8 lex_hide_pos; // HAVELEXF_HIDE_POS
u8 lex_start_item; // HAVELEXF_START_ITEM
- //--- since v2.35a
+ //--- since v2.35a
u8 lex_apply_otl; // HAVELEXF_APPLY_OTL
u8 lex_sect_ritp; // HAVELEXS_RIPT
u8 lex_rnd_itph; // HAVELEXF_RND_ITPH
- // [[new-lex-sect+]]
- //--- new files and features will be appended here
-
+ //--- since v2.36a
u8 lex_sect_dev1; // HAVELEXS_DEV1
+
+ //--- since v2.39a
+ u8 lex_sect_ctdn; // HAVELEXS_CTDN
+
+ //--- [[new-lex-sect]] new files and features will be appended here
}
__attribute__ ((packed)) features_szs_t;
@@ -252,6 +274,7 @@ typedef enum have_lex_sect_t
HAVELEXS_FEAT,
HAVELEXS_RITP,
HAVELEXS_DEV1,
+ HAVELEXS_CTDN,
// [[new-lex-sect]]
//--- add new elements here (order is important)
HAVELEXS__N
@@ -289,6 +312,7 @@ typedef enum lex_stream_id
LEXS_DEV1 = 0x44455631, // "DEV1" primary developer settings
LEXS_SET1 = 0x53455431, // "SET1" primary settings
LEXS_CANN = 0x43414e4e, // "CANN" cannon settings
+ LEXS_CTDN = 0x4354444e, // "CTDN" countdown settings
LEXS_HIPT = 0x48495054, // "HIPT" hide position tracker
LEXS_RITP = 0x52495450, // "RITP" random next links @KMP:ITPH
LEXS_TEST = 0x54455354, // "TEST" settings for tests
@@ -362,6 +386,17 @@ typedef struct lex_set1_t
__attribute__ ((packed,aligned(4))) lex_set1_t;
//-----------------------------------------------------------------------------
+// [[lex_ctdn_t]]
+
+typedef struct lex_ctdn_t
+{
+ /*00*/ u16 time_limit_sec[LEC__N]; // time limits in sec (6 values)
+ /*0c*/
+ // [[new-lex-ctdn]]
+}
+__attribute__ ((packed,aligned(4))) lex_ctdn_t;
+
+//-----------------------------------------------------------------------------
// [[lex_hipt_rule_t]]
typedef struct lex_hipt_rule_t
@@ -494,6 +529,7 @@ lex_item_t * AppendFeatLEX ( lex_t * lex, bool overwrite, const features_szs_t *
lex_item_t * AppendDev1LEX ( lex_t * lex, bool overwrite );
lex_item_t * AppendSet1LEX ( lex_t * lex, bool overwrite );
lex_item_t * AppendCannLEX ( lex_t * lex, bool overwrite );
+lex_item_t * AppendCtdnLEX ( lex_t * lex, bool overwrite );
lex_item_t * AppendHiptLEX ( lex_t * lex, bool overwrite );
lex_item_t * AppendRitpLEX ( lex_t * lex, bool overwrite );
lex_item_t * AppendTestLEX ( lex_t * lex, bool overwrite );
@@ -612,7 +648,7 @@ typedef struct lex_info_t
lex_set1_t test; // data of section TEST
- // data
+ //-- data
float3 item_factor; // 1.0 or copy of set1.item_factor
// [[new-lex-sect]] [[new-lex-set1]]
diff --git a/project/src/lib-std.c b/project/src/lib-std.c
index 5855450..03d9061 100644
--- a/project/src/lib-std.c
+++ b/project/src/lib-std.c
@@ -5514,6 +5514,56 @@ uint GetMkwMusicSlot ( uint tid )
}
}
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int FindTrackSlot ( ccp name, bool allow_arenas )
+{
+ int idx = ScanTrack(name);
+ if ( idx >= 0 )
+ return idx;
+
+ if (allow_arenas)
+ {
+ idx = ScanArena(name);
+ if ( idx >= 0 )
+ return idx + MKW_ARENA_BEG;
+ }
+
+ return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindArenaSlot ( ccp name, bool allow_tracks )
+{
+ int idx = ScanArena(name);
+ if ( idx >= 0 )
+ return idx + MKW_ARENA_BEG;
+
+ if (allow_tracks)
+ {
+ idx = ScanTrack(name);
+ if ( idx >= 0 )
+ return idx;
+ }
+
+ return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const TrackInfo_t * FindTrackInfo ( ccp name, bool allow_arenas )
+{
+ return GetTrackInfo(FindTrackSlot(name,allow_arenas));
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const TrackInfo_t * FindArenaInfo ( ccp name, bool allow_tracks )
+{
+ return GetTrackInfo(FindArenaSlot(name,allow_tracks));
+}
//
///////////////////////////////////////////////////////////////////////////////
/////////////// apple only ///////////////
diff --git a/project/src/lib-std.h b/project/src/lib-std.h
index a4fe66d..2029a95 100644
--- a/project/src/lib-std.h
+++ b/project/src/lib-std.h
@@ -969,7 +969,7 @@ CompressManager_t;
//-----------------------------------------------------------------------------
-enumError DecodeCompressManager
+enumError DecompressManager
(
CompressManager_t *mgr // manager data
);
@@ -2710,6 +2710,14 @@ static inline ccp PrintU16M1 ( u16 num )
return num == M1(num) ? "-1" : PrintCircBuf("%u",num);
}
+///////////////////////////////////////////////////////////////////////////////
+
+int FindTrackSlot ( ccp name, bool allow_arenas );
+int FindArenaSlot ( ccp name, bool allow_tracks );
+
+const TrackInfo_t * FindTrackInfo ( ccp name, bool allow_arenas );
+const TrackInfo_t * FindArenaInfo ( ccp name, bool allow_tracks );
+
//
///////////////////////////////////////////////////////////////////////////////
/////////////// apple only ///////////////
diff --git a/project/src/lib-szs-create.c b/project/src/lib-szs-create.c
index 7cb9482..e046a5f 100644
--- a/project/src/lib-szs-create.c
+++ b/project/src/lib-szs-create.c
@@ -1666,8 +1666,7 @@ bool NormalizeExSZS
.print_err = true };
am.log_indent = verbose >= 1 || logging >= 2 ? 2 : -1;
AddMissingFile("button/timg/ct_icons.tpl",FF_TPL,&am);
-//ALWAYS if (opt_links)
- am.link = am.last_subfile;
+ am.link = am.last_subfile; // link always to save space
AddMissingFile("control/timg/ct_icons.tpl",FF_TPL,&am);
}
}
@@ -2812,7 +2811,7 @@ static void patch_9laps ( struct szs_iterator_t *it )
if (cm)
{
PRINT0("9laps/add %s\n",ptr->fname);
- DecodeCompressManager(cm);
+ DecompressManager(cm);
add_missing_t am = { .szs = it->szs, .norm = &it->norm_create,
.data = (u8*)cm->data, .size = cm->size, .print_err = true };
am.log_indent = verbose >= 1 || logging >= 2 ? 2 : -1;
@@ -2841,7 +2840,7 @@ static void patch_9laps ( struct szs_iterator_t *it )
if ( patch && cm )
{
- DecodeCompressManager(cm);
+ DecompressManager(cm);
patch_file(it,cm->data,cm->size,false,true);
break;
}
diff --git a/project/src/lib-szs.c b/project/src/lib-szs.c
index 639bcc5..06eda8c 100644
--- a/project/src/lib-szs.c
+++ b/project/src/lib-szs.c
@@ -2208,6 +2208,12 @@ enumError CompressBZ ( szs_file_t * szs, int compr, bool remove_uncompressed )
if ( !szs->size || !szs->data || szs->cdata )
return ERR_OK;
+ if ( compr < 1 || compr == BZIP2_DEFAULT_COMPR )
+ {
+ if (CheckSZSCacheSZS(szs,FF_BZ,".bz",remove_uncompressed))
+ return ERR_OK;
+ }
+
c_bzip2_t c = get_compressed_bzip2(szs,sizeof(wbz_header_t),compr);
if (c.err)
return c.err;
@@ -2341,7 +2347,13 @@ enumError CompressLZ ( szs_file_t * szs, int compr, bool remove_uncompressed )
else if (!compr)
compr = opt_compr_mode > 0 ? opt_compr : LZMA_DEFAULT_COMPR;
compr = CalcCompressionLevelLZMA(compr);
- PRINT0(" => USE LZMA COMPRESSION %u\n",compr);
+ PRINT0(" => USE LZ COMPRESSION %u\n",compr);
+
+ if ( compr == LZMA_DEFAULT_COMPR
+ && CheckSZSCacheSZS(szs,FF_LZ,".lz",remove_uncompressed))
+ {
+ return ERR_OK;
+ }
u8 *cdata;
uint csize;
@@ -2410,7 +2422,6 @@ enumError CompressLZMA ( szs_file_t * szs, int compr, bool remove_uncompressed )
else if (!compr)
compr = opt_compr_mode > 0 ? opt_compr : LZMA_DEFAULT_COMPR;
compr = CalcCompressionLevelLZMA(compr);
-
PRINT0(" => USE LZMA COMPRESSION %u\n",compr);
if ( compr == LZMA_DEFAULT_COMPR
diff --git a/project/src/prefix.inc b/project/src/prefix.inc
index 9c7fddb..af76761 100644
--- a/project/src/prefix.inc
+++ b/project/src/prefix.inc
@@ -1,109 +1,110 @@
-static const u8 prefix_inc_bz2[] =
+static const u8 prefix_inc_lzma[] =
{
- // decompressed size: 0xe61 = 3681 bytes
- 0x00,0x00,0x0e,0x61,
+ // decompressed size: 0xecd = 3789 bytes
+ 0x00,0x00,0x0e,0xcd,
- // bzipped data
- 0x42,0x5a,0x68,0x39, 0x31,0x41,0x59,0x26, 0x53,0x59,0x8b,0xb2, 0xac,0x87,0x00,0x02,
- 0x00,0xdf,0x80,0x00, 0x12,0x61,0xef,0x7f, 0xf2,0x7f,0xef,0xdf, 0xf0,0xbf,0xff,0xff,
- 0xf4,0x50,0x05,0xfa, 0xc9,0xee,0x02,0xec, 0x6e,0xcd,0xbb,0xb1, 0x22,0xd0,0x61,0x86,
- 0x88,0x4d,0x34,0xd4, 0xc0,0x26,0x86,0x9a, 0x68,0xc4,0xd0,0x0a, 0x7a,0x34,0x19,0x34,
- 0x26,0x9a,0x3d,0x43, 0x4d,0x19,0x06,0x84, 0xa7,0x93,0x4f,0x42, 0x4d,0x4f,0x4d,0x4f,
- 0x4d,0x4d,0x0d,0xa2, 0x00,0x06,0x80,0x00, 0x00,0x68,0x01,0x22, 0x22,0x68,0x13,0x41,
- 0x34,0x68,0x46,0x49, 0xe2,0x9e,0xa7,0xa8, 0x31,0x01,0xa3,0x4d, 0x1a,0x33,0x43,0x51,
- 0xa6,0x43,0x8c,0x99, 0x34,0xd3,0x09,0x91, 0x90,0x30,0x23,0x13, 0x46,0x08,0xc2,0x0d,
- 0x1a,0x60,0x00,0x41, 0x28,0xa9,0xfa,0x10, 0xf5,0x51,0x8c,0xa0, 0xf2,0x8d,0x1a,0x06,
- 0x80,0x00,0x03,0x40, 0xf5,0x03,0x40,0x06, 0x84,0x85,0xf3,0x37, 0xb1,0x08,0x5e,0x1f,
- 0xaf,0x7d,0x3f,0x8f, 0x51,0xce,0xbe,0x1e, 0xeb,0xfd,0x51,0x1d, 0xff,0x29,0x78,0xd3,
- 0x08,0x99,0x6c,0x4c, 0xc3,0x24,0x31,0x43, 0xf8,0xd5,0x0b,0x42, 0x07,0x41,0x4f,0x41,
- 0x78,0x36,0x96,0xb8, 0xeb,0x83,0xd9,0x4d, 0xb7,0x93,0xf1,0x31, 0x13,0x03,0x48,0x7c,
- 0x7e,0xe6,0x8e,0x4f, 0x7f,0xd3,0xa2,0x91, 0x06,0xd1,0x64,0x22, 0xd8,0xba,0x2f,0x22,
- 0x08,0x64,0x22,0x62, 0x93,0x0b,0x13,0x08, 0x22,0xb3,0x29,0x00, 0x86,0x2a,0x31,0x04,
- 0x85,0x6d,0x7b,0xe3, 0x5b,0x01,0x24,0xa5, 0xd9,0x4d,0xfb,0xf3, 0xd1,0x9c,0x5b,0x7d,
- 0x43,0xa3,0x6c,0x59, 0x50,0xbb,0x42,0xc4, 0x64,0x8c,0xad,0x63, 0x85,0x43,0xe0,0x9b,
- 0x09,0xde,0x93,0x88, 0x94,0x3d,0xa2,0x27, 0x53,0x37,0x72,0x17, 0x34,0x81,0xd2,0xbc,
- 0x28,0xbe,0x9b,0xc9, 0x50,0xbe,0xba,0x62, 0x0e,0xc5,0x6b,0xf3, 0x5a,0x5e,0x62,0x63,
- 0x9e,0xfc,0x2e,0x00, 0x3e,0x3d,0x6f,0x10, 0x3f,0xc1,0x36,0x4e, 0xb8,0xc4,0xd9,0x79,
- 0xbe,0x07,0x88,0x0c, 0x49,0x97,0x0e,0xce, 0x3b,0x40,0x47,0x70, 0x20,0x08,0x22,0x72,
- 0xf5,0xb2,0x58,0xb5, 0x78,0xd8,0x4e,0x20, 0x2d,0xb9,0x48,0x33, 0xa2,0x0e,0x0e,0xfe,
- 0x14,0x50,0x13,0x27, 0x47,0x38,0xe8,0x16, 0x0a,0x42,0x79,0x63, 0x19,0x55,0x51,0x34,
- 0x81,0x1d,0x92,0x67, 0xab,0x48,0x73,0x2c, 0xe2,0xb8,0xba,0x7d, 0x2e,0x94,0xa4,0xa5,
- 0x71,0x4a,0x22,0x29, 0x49,0x49,0x08,0xa7, 0x97,0xf7,0x91,0xb0, 0x6d,0x82,0x11,0x5a,
- 0xf0,0x3e,0xcd,0x3b, 0xa4,0xe1,0xe4,0x89, 0x85,0x1b,0x7d,0xbb, 0xc8,0xe4,0xd9,0x13,
- 0xbb,0x30,0xd6,0xcb, 0xaa,0x50,0xaf,0x0e, 0x8f,0xb6,0xbb,0x7d, 0x77,0x12,0x5b,0xd9,
- 0x06,0x21,0x93,0x1d, 0xba,0xa4,0x6a,0x61, 0x2a,0x66,0x59,0xdf, 0x34,0x85,0x9f,0xaf,
- 0xaf,0x2f,0x6d,0xa6, 0xe5,0x63,0x16,0xd8, 0xdb,0x07,0xe1,0xd5, 0xfd,0xd8,0xe6,0xb1,
- 0xa3,0xea,0xeb,0xce, 0x27,0x74,0xe5,0xd2, 0xca,0xfa,0x2e,0x9f, 0x63,0x16,0xb4,0xd1,
- 0xcb,0xc0,0xc2,0x5c, 0x71,0x1c,0xfd,0x96, 0x30,0x7c,0xa4,0x3a, 0x7b,0xe4,0xa6,0x08,
- 0x9d,0xb4,0x32,0xe0, 0x54,0x96,0x2d,0xf7, 0x5d,0x12,0x99,0x27, 0xba,0x47,0x85,0x38,
- 0x3b,0x95,0x89,0xe7, 0x93,0xa2,0xf0,0x5c, 0xcd,0x09,0xbd,0x43, 0x0d,0x35,0xf0,0x8e,
- 0xae,0xec,0xcb,0x32, 0x2c,0x4a,0x9f,0x4d, 0xe2,0x5a,0x25,0xbd, 0x94,0x5a,0x99,0x0d,
- 0x03,0xe8,0xcf,0x86, 0x99,0x64,0xc4,0xc4, 0x0c,0x62,0x6d,0xab, 0x9c,0x28,0x2b,0xa5,
- 0x57,0xc6,0x11,0xe5, 0x63,0x20,0x0b,0x5d, 0x3a,0x8e,0x44,0x8e, 0x75,0xd3,0x23,0x0d,
- 0x44,0x81,0xea,0xae, 0x25,0xc4,0x22,0x1c, 0x9a,0xc5,0x9b,0x21, 0x18,0x2e,0x73,0x27,
- 0xae,0x28,0x66,0xa5, 0x61,0x9c,0xf3,0x83, 0x0a,0x00,0x07,0x22, 0x42,0x33,0x5b,0xae,
- 0xc3,0x11,0x8e,0xd3, 0x6e,0xa8,0xd7,0x7e, 0x9e,0x18,0xc5,0xe6, 0xa4,0xdc,0x6c,0x1c,
- 0x36,0x95,0xcf,0x83, 0x00,0xe9,0xe4,0x23, 0x86,0x99,0xca,0x91, 0x9b,0xb7,0x26,0xcf,
- 0x44,0x40,0x31,0x31, 0x89,0xa6,0x4c,0x2f, 0x1b,0x96,0xdb,0x1b, 0x10,0xd9,0xe0,0xbe,
- 0xa3,0x56,0xcf,0xa5, 0x9b,0x1a,0xf2,0x67, 0xab,0x75,0x0e,0x53, 0x4e,0x66,0x73,0x64,
- 0x6b,0xd6,0xc6,0x9a, 0x6e,0x8c,0x39,0x7a, 0xf1,0xec,0xfd,0x96, 0x7b,0x2d,0xcf,0x84,
- 0x18,0xbe,0x16,0xed, 0xe1,0x46,0x19,0xba, 0x53,0x98,0x55,0x19, 0x4e,0x05,0x90,0xe1,
- 0xa2,0x8c,0x32,0x23, 0x66,0x5e,0xb0,0xa4, 0xa1,0x4d,0xaa,0x63, 0x3d,0x45,0x00,0xec,
- 0xb7,0xc3,0x43,0x98, 0xce,0x7d,0x47,0xe4, 0x41,0xfb,0xe0,0x89, 0x36,0x78,0x04,0xd4,
- 0xa1,0xe1,0x3c,0xe3, 0x1e,0xa0,0xf7,0x61, 0xbd,0xe8,0x8f,0xf6, 0xe1,0x9d,0xd1,0x8b,
- 0xd2,0x1a,0x8e,0x2a, 0x5b,0x25,0x6d,0xc4, 0x18,0xf5,0xf7,0xae, 0x3b,0x92,0x03,0xc9,
- 0xc5,0xc8,0x24,0x5a, 0xf1,0x42,0xd6,0x6b, 0x57,0x5d,0xb7,0xa3, 0x6a,0xae,0xc1,0x99,
- 0xbc,0xe8,0x61,0xf2, 0x95,0x8d,0x32,0xe6, 0x36,0x2c,0x2f,0xd8, 0x61,0x8f,0x28,0x1d,
- 0x70,0x76,0x72,0x52, 0x87,0x8d,0xf1,0x21, 0xa4,0x65,0x84,0x57, 0xaa,0xd8,0x51,0xdf,
- 0xad,0xa5,0x44,0x94, 0x0d,0x98,0x11,0x58, 0x41,0x71,0x15,0xcd, 0x55,0xeb,0x46,0x2d,
- 0x20,0x28,0xea,0x0c, 0x63,0xd7,0x0b,0x98, 0x92,0x29,0xaa,0x4c, 0xf9,0x31,0xb7,0x23,
- 0xcc,0x9b,0x6c,0x9c, 0x48,0xb2,0xf7,0xb4, 0x3a,0x22,0xd0,0xf1, 0x88,0x61,0x19,0x1c,
- 0x41,0x02,0x8c,0xc9, 0x3d,0x33,0x26,0x7d, 0x51,0x0e,0xf3,0x16, 0x86,0xb5,0xe0,0x70,
- 0xb5,0xb8,0x23,0x97, 0x1b,0xb7,0x9f,0x38, 0x14,0x4c,0xf9,0xcd, 0x2f,0x37,0x52,0xb5,
- 0x53,0xd2,0xa2,0x43, 0x13,0x72,0xec,0x89, 0xa4,0x0c,0xb2,0x98, 0x46,0xa1,0x1b,0xbe,
- 0x3b,0x28,0x15,0x21, 0x95,0x11,0xb4,0x5b, 0x51,0xca,0x7d,0x0d, 0x87,0x75,0x2d,0x89,
- 0x36,0x30,0xed,0xdf, 0x0a,0xac,0x37,0x54, 0x54,0x98,0xaf,0x36, 0x3d,0x35,0xbb,0x5e,
- 0x24,0x0c,0x54,0x5b, 0x2b,0x76,0x80,0x4b, 0x58,0x97,0x2b,0x30, 0x4d,0x00,0x76,0xa3,
- 0x0f,0x0e,0x3a,0x19, 0x9b,0x20,0x03,0x21, 0x96,0x30,0xeb,0x08, 0x56,0x60,0x88,0xaa,
- 0xd5,0x8b,0x2d,0xd3, 0x5f,0x21,0x9e,0x88, 0x28,0xdb,0x53,0x59, 0xe5,0x0d,0xa0,0x58,
- 0xf0,0x48,0x46,0x70, 0x64,0x95,0x20,0xc6, 0x15,0x56,0x87,0x77, 0x5c,0x4e,0x04,0x3d,
- 0xa0,0x89,0x38,0xf5, 0x99,0x25,0x2d,0xc0, 0xfa,0x70,0x99,0x39, 0x05,0x69,0xe0,0x90,
- 0x12,0xa2,0x66,0xe8, 0xca,0x86,0x0c,0x31, 0x30,0x3b,0x85,0x48, 0x66,0xbc,0x6d,0x4c,
- 0xfc,0xbe,0x89,0xc5, 0xac,0x11,0x80,0xc6, 0xe0,0x86,0x5f,0xa1, 0x12,0xc2,0x89,0xb5,
- 0x48,0x05,0x09,0x48, 0xc1,0xe9,0x9d,0x69, 0x95,0x4b,0xa2,0x64, 0x28,0x4c,0xb6,0xa8,
- 0x8b,0xd8,0x90,0xd3, 0x4b,0x91,0x90,0x79, 0xff,0xe8,0x26,0xc5, 0xb0,0xa5,0x56,0xf0,
- 0xd4,0x63,0xeb,0x01, 0x78,0x83,0x80,0x41, 0x06,0x40,0x8a,0x4a, 0x62,0x2c,0x7d,0x43,
- 0x7d,0xc9,0x79,0x1f, 0x41,0xf2,0xf8,0x0e, 0xd8,0x26,0xdb,0x5e, 0xc1,0x08,0xd0,0x77,
- 0xb0,0x00,0xed,0xf1, 0xba,0x4e,0xa9,0x4f, 0xbc,0xca,0x2d,0x2f, 0x46,0x76,0x60,0xb0,
- 0x10,0x18,0x82,0x08, 0x0e,0x88,0x40,0x24, 0xaa,0x80,0x68,0x32, 0x22,0xa7,0x3a,0x08,
- 0x24,0xd4,0x8a,0x13, 0x04,0x62,0x0c,0xf2, 0x16,0x4a,0x84,0xf0, 0x6a,0x07,0x0c,0x30,
- 0xa0,0xa8,0xaf,0x8a, 0xa3,0x11,0x09,0x21, 0x66,0xc3,0x24,0x03, 0x78,0x97,0x37,0x5f,
- 0xad,0x10,0xdc,0x68, 0x10,0xaa,0xc6,0x84, 0x36,0x54,0x1a,0x07, 0x84,0x8c,0x7f,0x1b,
- 0x26,0xb5,0x81,0x88, 0xc6,0x03,0x0e,0x00, 0xc6,0x89,0x93,0xb6, 0x6e,0x50,0x4d,0x15,
- 0x2b,0xa4,0x6d,0x75, 0x89,0x1d,0xd6,0x84, 0xc8,0x99,0xa5,0x87, 0x18,0x70,0x8d,0x8e,
- 0xee,0xa8,0x02,0xb8, 0xc2,0xe9,0xdb,0x44, 0x33,0x72,0xa5,0xb1, 0x45,0x94,0xe7,0x7d,
- 0xf7,0xd0,0x78,0x35, 0x74,0x8c,0xa6,0x24, 0x14,0x30,0xa8,0xaa, 0xdd,0xf0,0xe8,0xc8,
- 0xc0,0xa4,0x5b,0xe6, 0x9e,0x38,0xdb,0xcd, 0x4f,0x3f,0x47,0x1f, 0x6d,0xf5,0xfc,0x2d,
- 0x22,0x09,0xa3,0xe3, 0xd0,0x85,0x8a,0xd3, 0x6e,0xf2,0x8d,0xcf, 0x66,0x08,0xad,0xa9,
- 0xe2,0x52,0xb7,0xcc, 0x3f,0xce,0xa8,0xf3, 0x54,0x8c,0xb2,0x97, 0xcf,0x7c,0xf7,0x56,
- 0x4e,0x84,0xee,0x76, 0xa6,0x16,0xa1,0x1e, 0xdf,0xe9,0xa4,0xbb, 0xe2,0x03,0xf9,0xef,
- 0x84,0xbb,0xc6,0x51, 0x88,0xf8,0xc4,0x0d, 0xa1,0x0d,0x83,0x68, 0x27,0xdf,0x59,0xa3,
- 0x6c,0x6e,0x8d,0x38, 0x51,0x11,0xef,0x8f, 0x85,0xaf,0x45,0x92, 0x29,0xe2,0xc0,0x89,
- 0x6c,0x40,0x86,0x89, 0x41,0x82,0xe2,0x44, 0x01,0x04,0x5e,0x1e, 0x60,0xc6,0xbe,0xc7,
- 0x8b,0xb7,0x85,0x4a, 0x50,0x11,0xf0,0xe7, 0x62,0x87,0x23,0x5c, 0x08,0x6b,0x1e,0x95,
- 0xf1,0xf2,0xf2,0x91, 0xdc,0x84,0x5d,0xbe, 0xef,0xad,0xfe,0x54, 0xe3,0xa6,0x1a,0x5f,
- 0x0b,0x3c,0xd7,0xab, 0xd0,0x89,0x8f,0xe4, 0xee,0x49,0xfb,0xb2, 0x40,0xb0,0x53,0x7c,
- 0x36,0x86,0x4f,0x56, 0xfe,0x75,0xac,0x3d, 0x65,0xb7,0x3a,0x84, 0x68,0x60,0xca,0xa1,
- 0x97,0x3c,0xd3,0xad, 0x96,0xab,0xec,0x6b, 0x0a,0x62,0xee,0x5d, 0x31,0xa4,0xe6,0xeb,
- 0x85,0x37,0x82,0xae, 0x0a,0xc9,0xa7,0x66, 0x60,0x33,0x64,0x1c, 0xce,0xae,0x08,0x31,
- 0x84,0xc3,0x0d,0x8b, 0x62,0xec,0x71,0xe5, 0xf2,0x5a,0xdc,0xd7, 0xaf,0x5e,0xbd,0x77,
- 0xf5,0x3d,0xae,0x29, 0x40,0xab,0x2d,0xbb, 0xd5,0xdb,0x21,0xe9, 0x6b,0xcd,0xf8,0x05,
- 0xac,0xa1,0x5a,0xb1, 0x43,0x48,0x3c,0x56, 0xe6,0x21,0xde,0x30, 0xf7,0x33,0xfc,0x5d,
- 0xc9,0x14,0xe1,0x42, 0x42,0x2e,0xca,0xb2, 0x1c,
- // 0x5f9 = 1529 data bytes (42%)
+ // LZMA.6 compressed data
+ 0x5d,0x00,0x00,0x80, 0x00,0xff,0xff,0xff, 0xff,0xff,0xff,0xff, 0xff,0x00,0x20,0x15,
+ 0x06,0x01,0x7b,0xa2, 0xa1,0xd0,0xb6,0xe6, 0x42,0x19,0xec,0xf7, 0x37,0x70,0x15,0x8e,
+ 0x25,0x3c,0x80,0xfc, 0x38,0xd8,0x99,0x2a, 0xaa,0xdf,0xc9,0x44, 0x9a,0x44,0x8b,0x29,
+ 0x12,0x98,0x47,0xc4, 0x6f,0x2e,0xa6,0xc1, 0x27,0xd7,0xae,0x49, 0x17,0x6b,0xd8,0xb2,
+ 0x08,0x96,0x54,0x14, 0x50,0xe7,0x19,0xb5, 0x94,0x80,0x20,0x4b, 0x4f,0x81,0x04,0x71,
+ 0x57,0xbb,0x37,0xb6, 0xa0,0x0f,0x0d,0x4b, 0x93,0x38,0x90,0x6d, 0x04,0x64,0x57,0x30,
+ 0x2a,0xda,0x99,0x30, 0x43,0xf0,0xca,0x57, 0x98,0x6e,0x23,0xa5, 0xa1,0xd5,0x44,0x33,
+ 0x9f,0xf6,0x62,0x18, 0x08,0x1d,0xfc,0x63, 0x80,0xfd,0xbe,0xde, 0xfd,0x5a,0xac,0xcf,
+ 0xb6,0xf0,0xba,0xe0, 0xac,0x1a,0xea,0x42, 0xe1,0x4a,0x46,0xf0, 0xb7,0xf8,0xb6,0x30,
+ 0x4f,0x0e,0x7b,0x32, 0xb8,0x63,0xab,0x98, 0x03,0x53,0xf9,0x71, 0x3c,0x60,0x91,0x5b,
+ 0x0b,0xed,0x03,0xc6, 0x3c,0x51,0x07,0x57, 0xe8,0xf0,0x38,0x3a, 0x8b,0x11,0x9a,0x55,
+ 0xc8,0x0f,0x1d,0x5a, 0xb0,0x41,0xeb,0x68, 0x73,0xb7,0x29,0xf4, 0xd2,0x50,0x0d,0x5f,
+ 0x23,0x9e,0x6c,0x40, 0xbf,0xd7,0xcb,0xdc, 0x2a,0x6b,0xb3,0x0d, 0x24,0x9d,0x32,0x2a,
+ 0x31,0xdb,0xa8,0x73, 0xfa,0x99,0x3c,0x8d, 0x3c,0x43,0x1d,0xcc, 0xe5,0x84,0x74,0x4a,
+ 0xfc,0x17,0x71,0xee, 0x17,0xd1,0x9d,0x2e, 0xfa,0x27,0xcf,0xa4, 0xb1,0xbc,0x4c,0x94,
+ 0x3d,0x22,0xa6,0xc4, 0xc5,0xf1,0x23,0x3b, 0x08,0x07,0xfb,0x3c, 0x92,0x77,0x08,0x99,
+ 0x11,0x90,0xf5,0x21, 0xe6,0x03,0xe6,0xa0, 0xc6,0xce,0xdd,0xd6, 0x3d,0x0c,0x25,0x3d,
+ 0x02,0xc6,0x8d,0xef, 0x57,0x4a,0xbf,0xd3, 0x85,0xd8,0x70,0xda, 0xd0,0x27,0xc9,0xd2,
+ 0x83,0xe6,0x52,0x25, 0x00,0x88,0x23,0x3e, 0x9c,0x88,0x76,0x84, 0x12,0xd6,0xaa,0x36,
+ 0xab,0x79,0x2f,0x6b, 0xf3,0x96,0xe5,0x58, 0x9d,0xcb,0x3a,0xce, 0xae,0x2f,0xec,0x4b,
+ 0x18,0xa3,0xfd,0x1a, 0x5b,0x4c,0x40,0x8a, 0x63,0x87,0x5f,0xfe, 0x84,0x3f,0xe0,0xc8,
+ 0x17,0x15,0xae,0xbf, 0xda,0x70,0x55,0x19, 0x51,0xd4,0x22,0x74, 0x10,0x5d,0xea,0x45,
+ 0x3a,0x68,0x44,0x76, 0x4d,0x14,0xa8,0xf1, 0x71,0xba,0xd9,0x3d, 0xef,0x35,0x0d,0xf3,
+ 0xa3,0xb7,0xc9,0x7e, 0xd3,0x86,0x13,0x35, 0x25,0xa3,0xea,0x01, 0xc8,0x01,0x89,0x1b,
+ 0xd7,0x47,0x52,0x48, 0xcc,0x43,0xe3,0x76, 0xd3,0x21,0x83,0x8f, 0xec,0xa7,0xca,0x17,
+ 0x53,0xc3,0x9b,0x28, 0xa7,0xa0,0xd8,0x12, 0xcf,0x42,0xbf,0x22, 0xe5,0x51,0xa6,0xe8,
+ 0xd2,0x40,0x49,0x29, 0xc3,0xcf,0x3d,0x2f, 0x79,0x4b,0xe6,0xe5, 0xe9,0x03,0xe5,0xe2,
+ 0xa8,0x82,0xa0,0x07, 0xc1,0x5e,0xf0,0x78, 0x42,0x31,0x95,0x4d, 0x48,0xbe,0x32,0xbc,
+ 0x63,0x29,0xbf,0x10, 0xd3,0xd3,0xd1,0x97, 0x05,0x45,0xa4,0x29, 0xfc,0x22,0xbc,0x94,
+ 0x19,0x58,0x76,0x1c, 0x38,0x4a,0x75,0xf2, 0x49,0x81,0x4b,0x7b, 0x1f,0xf9,0x79,0xda,
+ 0x2e,0x1a,0xe8,0x8b, 0xdf,0xf5,0xcb,0x07, 0x29,0xa0,0x08,0x33, 0x8a,0x63,0x84,0xb0,
+ 0x6e,0x7f,0xed,0x80, 0xb4,0x1e,0xac,0xe4, 0xec,0x0b,0xae,0xcb, 0xb7,0x66,0xb5,0x86,
+ 0x32,0x38,0xee,0x30, 0xcb,0x24,0xf8,0xf6, 0xbd,0x8a,0x9a,0x68, 0x13,0x49,0x79,0xc8,
+ 0x73,0x45,0xbe,0xbe, 0x6b,0x15,0xab,0x3d, 0x12,0x03,0x61,0x4c, 0x0d,0xe7,0x01,0xb3,
+ 0xbb,0x3e,0x9b,0x87, 0x95,0xee,0xe3,0x51, 0x55,0x4f,0xe6,0x9a, 0x1f,0xe6,0x70,0xfa,
+ 0xdf,0x21,0x9a,0x3c, 0xab,0xd7,0x55,0x9b, 0xd0,0x48,0x2a,0x39, 0xb1,0x2b,0xa0,0x2f,
+ 0xb8,0x7c,0xc3,0x71, 0x95,0x10,0xfe,0xc1, 0xf0,0x49,0x1c,0xba, 0xea,0x0a,0x59,0xad,
+ 0x33,0xb8,0x7f,0xbf, 0x32,0x4b,0x41,0x6b, 0x93,0x07,0x32,0xd5, 0x9f,0x14,0x38,0xfa,
+ 0xfd,0xd6,0xb5,0x1b, 0xac,0x81,0xc4,0x28, 0xe3,0x21,0x1d,0xff, 0x54,0x06,0x3b,0xf2,
+ 0xbe,0xd9,0x7b,0xa5, 0x0a,0xa9,0xa9,0xf3, 0x4d,0x8b,0x17,0x5a, 0x72,0x9a,0x88,0xd6,
+ 0x06,0xeb,0xc4,0x40, 0xe9,0x63,0x70,0xdd, 0x78,0x59,0x79,0xbf, 0x71,0x92,0x80,0x46,
+ 0xfc,0x7c,0xa5,0x53, 0x5a,0xa3,0x5f,0x43, 0xf5,0x5f,0xba,0x74, 0x8d,0xc2,0x14,0x5a,
+ 0xcd,0x3a,0x7e,0x63, 0x14,0xc5,0xf6,0x74, 0xd3,0x6f,0xd2,0x8c, 0x5c,0xb8,0x2a,0x8f,
+ 0x36,0xb1,0x0c,0x2a, 0x46,0x04,0xec,0x33, 0x66,0xd3,0xe7,0xfc, 0x95,0x7e,0xcd,0x23,
+ 0x17,0x08,0xc6,0x9d, 0xc3,0x9e,0xd7,0x7f, 0x21,0x2a,0x40,0x5e, 0x35,0x4f,0x85,0x14,
+ 0xc5,0x47,0x83,0x16, 0x81,0xfc,0x29,0x1b, 0xd4,0x69,0x65,0xfc, 0x68,0xea,0x55,0x9e,
+ 0x01,0xa8,0x0c,0x85, 0x7b,0xbc,0x2e,0x79, 0xb2,0x15,0xc7,0x98, 0xd7,0x3e,0xd5,0xdb,
+ 0x7a,0x0d,0xb5,0xf7, 0x73,0xe3,0x14,0xce, 0x34,0x0f,0x68,0xe5, 0x3e,0xc6,0x78,0xd5,
+ 0x9e,0x06,0xa1,0x9c, 0x46,0xd7,0xd5,0xa0, 0xf5,0xdd,0x27,0xb3, 0xdf,0x92,0x38,0x87,
+ 0xf5,0xb5,0x77,0x35, 0x74,0xf6,0x3a,0x06, 0x26,0xd0,0x5e,0x07, 0xca,0xd7,0x41,0x87,
+ 0x5a,0xd9,0x0e,0x44, 0x6b,0x99,0x1e,0x2e, 0x00,0x2b,0x34,0x94, 0xde,0xea,0x4f,0x7c,
+ 0xfe,0x51,0x97,0xf3, 0x46,0x52,0x8d,0x96, 0x33,0xf1,0xbc,0x23, 0x6a,0x68,0x26,0x05,
+ 0x32,0xb7,0x08,0x33, 0x18,0x24,0xb9,0xdc, 0x91,0xf8,0x95,0x63, 0x33,0x8c,0x93,0x69,
+ 0x28,0xfb,0x4f,0x1c, 0xe6,0xbd,0x4e,0x22, 0x10,0x6f,0x64,0x73, 0xde,0x58,0x3e,0xc0,
+ 0x84,0x97,0x8b,0x6b, 0x15,0x59,0x17,0x7b, 0x86,0x57,0xd6,0x2f, 0xef,0xa2,0x53,0x34,
+ 0xcb,0xf9,0xec,0xbf, 0xac,0xdd,0x2f,0xce, 0xa3,0x9f,0x77,0x3c, 0xad,0xc3,0x34,0x4f,
+ 0x1b,0x52,0x22,0x95, 0xab,0x08,0xe7,0xca, 0x8d,0x64,0x89,0x78, 0xd9,0x99,0x1b,0xa5,
+ 0xdb,0xab,0xe4,0x50, 0xcb,0x56,0x15,0xe0, 0x3d,0xa5,0x3d,0xb2, 0xa6,0x4b,0x87,0xab,
+ 0x1c,0xfe,0xd0,0xf4, 0xae,0xe3,0xc3,0x2a, 0x8e,0x36,0x71,0xe2, 0x7c,0x05,0x0d,0x3a,
+ 0xf3,0xaa,0x56,0x40, 0x82,0xed,0xf2,0x9c, 0xa0,0x7e,0x7a,0x4c, 0x8f,0x42,0x55,0x91,
+ 0x98,0xf4,0x25,0x72, 0x36,0xad,0xbb,0x76, 0x68,0xe2,0x06,0x19, 0xc1,0x6f,0x45,0x8c,
+ 0xf9,0x53,0x5f,0xb5, 0xf6,0x60,0xe9,0x56, 0x26,0x40,0x9a,0xc2, 0x45,0x92,0x35,0xd8,
+ 0xc9,0x8a,0xb3,0x63, 0x82,0x5d,0x6a,0xd7, 0xca,0xd6,0xb8,0xe2, 0xd2,0x01,0x89,0xe4,
+ 0x89,0xd7,0xc2,0xf9, 0x44,0xc2,0x66,0xa0, 0xfb,0x96,0xfb,0xce, 0x1f,0xfb,0xaf,0xa9,
+ 0x0e,0x6b,0x1f,0x52, 0x11,0xc3,0x9c,0xac, 0xa4,0x5f,0xb6,0x7f, 0x87,0x58,0x9e,0x15,
+ 0xd2,0x5f,0x39,0xee, 0x9f,0xde,0x5b,0x38, 0xb4,0xef,0xb9,0x32, 0x06,0xbb,0x62,0xc3,
+ 0x9d,0xaf,0x21,0x69, 0xe6,0x6d,0x9b,0xc7, 0x79,0xef,0x9b,0x52, 0x8b,0xda,0x21,0xca,
+ 0x24,0xff,0x95,0x7f, 0x0a,0x19,0xbb,0x49, 0xd4,0x81,0xdc,0x04, 0xd8,0xb7,0xbf,0xda,
+ 0x47,0xd2,0x00,0x1d, 0x98,0x7d,0xde,0x1f, 0xb4,0x30,0xd9,0x25, 0x80,0x0b,0x97,0x0e,
+ 0x56,0x6c,0xf9,0xa7, 0x78,0xe8,0x01,0x64, 0xf3,0x8e,0x82,0x32, 0xfc,0x95,0xcc,0xa8,
+ 0xaa,0x71,0x6e,0xb4, 0xa3,0x54,0x6d,0xca, 0x8e,0x9a,0xac,0x0e, 0xca,0xef,0x1c,0x43,
+ 0x52,0xca,0x27,0x80, 0xe6,0xa7,0x26,0x52, 0xc6,0xe1,0x6e,0x7d, 0x38,0xad,0x17,0xd6,
+ 0x2b,0x77,0x65,0x3c, 0x01,0x16,0x95,0x3c, 0x0a,0xf4,0xa2,0x03, 0xd1,0xd5,0x5f,0x4d,
+ 0xb1,0x55,0xdc,0x6e, 0xb6,0x61,0xcb,0x52, 0xaa,0x44,0xd3,0xd1, 0x35,0x76,0x91,0x1a,
+ 0x2b,0x29,0x49,0x06, 0xeb,0x86,0x47,0x54, 0x63,0xf0,0xda,0x1d, 0x1f,0x7b,0x7b,0x1f,
+ 0xc1,0x38,0x99,0x6b, 0x07,0x2e,0xae,0x91, 0x9d,0x92,0x92,0x37, 0x27,0x4e,0xe1,0x20,
+ 0xb0,0x11,0xc9,0x32, 0x2f,0x1d,0xf6,0x02, 0xbf,0xbd,0x70,0xbd, 0x5c,0xc9,0x67,0xfd,
+ 0xdc,0x34,0x06,0xf1, 0xff,0x8a,0xda,0xc8, 0xcd,0xae,0x71,0x3f, 0x56,0x50,0x2d,0x1a,
+ 0x8a,0x35,0xdd,0x39, 0x45,0x92,0xf2,0x40, 0x93,0x39,0xe4,0x45, 0x9f,0xb8,0x37,0xb5,
+ 0x98,0xaf,0x81,0xc7, 0x14,0x1b,0x4a,0x45, 0xa3,0x16,0xac,0x37, 0xc8,0x2e,0xcf,0x81,
+ 0x09,0x38,0xd2,0x62, 0x14,0xb4,0xfc,0x34, 0x00,0x75,0x81,0xfe, 0x86,0x51,0xa6,0xf3,
+ 0x5e,0x45,0xda,0x2d, 0xb2,0x50,0xa0,0x0a, 0x8f,0x43,0xe6,0x0c, 0xa1,0x49,0xc1,0x8d,
+ 0x4d,0xe3,0xf5,0xcb, 0x38,0x9a,0xc7,0x6c, 0xab,0xb1,0x9e,0xab, 0x70,0x94,0x0d,0xc0,
+ 0x3b,0xf1,0x85,0x15, 0xbe,0x23,0x57,0xd2, 0x60,0x47,0x92,0xf4, 0x18,0x2a,0xe6,0xef,
+ 0x53,0x2b,0xa1,0xee, 0xab,0x23,0x52,0x33, 0x18,0xc6,0x7b,0x56, 0x51,0x5c,0xbc,0x65,
+ 0xc7,0xef,0x02,0xbf, 0x74,0xf0,0x1f,0x97, 0x4d,0x13,0x5c,0x69, 0xec,0x46,0x4f,0xd3,
+ 0xeb,0x51,0x9d,0xf3, 0x10,0x45,0xc9,0xd9, 0x72,0x64,0x02,0x85, 0xf7,0xdd,0xf0,0xaa,
+ 0x29,0x8c,0xb0,0x6a, 0x89,0x94,0xcc,0x2f, 0x24,0xc6,0x8b,0x8e, 0x29,0xdb,0x6c,0x33,
+ 0x20,0x04,0x6c,0xd8, 0x77,0x09,0x0f,0x17, 0x0a,0x9d,0xb0,0xeb, 0xc8,0xae,0x76,0xcb,
+ 0x56,0x8e,0x28,0x28, 0xf4,0x23,0x1e,0xb4, 0xe5,0x7b,0x42,0x58, 0x80,0xa0,0x24,0x35,
+ 0xe3,0xda,0x8f,0x0b, 0x94,0x39,0x24,0x43, 0xfc,0x40,0x6c,0xc8, 0xa5,0x36,0x5a,0x90,
+ 0x7e,0xbb,0xde,0x0c, 0x42,0xc0,0x64,0xc3, 0xda,0x30,0x39,0x4a, 0x46,0x53,0x45,0xc9,
+ 0x28,0xb2,0xa5,0xb2, 0xa4,0xc6,0xa5,0x07, 0x27,0x05,0x86,0x35, 0x4d,0x8d,0xca,0x17,
+ 0x6f,0x5f,0xb9,0x2f, 0xcb,0x21,0x9d,0x1a, 0xc9,0x09,0xd0,0xba, 0xa1,0xaa,0x31,0x2a,
+ 0xea,0xd1,0xbd,0x9d, 0x93,0xf3,0x0b,0xd4, 0x65,0x74,0xe9,0xb3, 0xec,0x68,0x6d,0xcc,
+ 0x8f,0xd1,0x49,0x0a, 0xe0,0xa4,0x02,0x0f, 0xe1,0x77,0x6c,0xec, 0xc4,0x49,0xe6,0x73,
+ 0xff,0xe0,0x47,0x7a, 0x88,
+ // 0x605 = 1541 data bytes (41%)
};
-static BZ2Manager_t prefix_inc_mgr
- = { prefix_inc_bz2, sizeof(prefix_inc_bz2), 0, 0 };
+static CompressManager_t prefix_inc_mgr
+ = { FF_LZMA, prefix_inc_lzma, sizeof(prefix_inc_lzma), 0, 0 };
diff --git a/project/src/ui/tab-wlect.inc b/project/src/ui/tab-wlect.inc
index 208cf30..51702ba 100644
--- a/project/src/ui/tab-wlect.inc
+++ b/project/src/ui/tab-wlect.inc
@@ -405,8 +405,8 @@
" The cache is used to generate LTA files when new compression is forced."
" Option {--remove-dest} is set automatically to protect cache integrity."
"\n "
- " Background: Loading a compressed SZS and content verification"
- " is much faster than compressing a file." },
+ " The idea behind the cache: Loading an SZS file and comparing the"
+ " decompressed content is clearly faster than compressing the file." },
{ T_OPT_GP, "LOG_CACHE", "log-cache|logcache",
0, 0 /* copy of wszst */ },
diff --git a/project/src/ui/tab-wszst.inc b/project/src/ui/tab-wszst.inc
index a78dca4..2b67963 100644
--- a/project/src/ui/tab-wszst.inc
+++ b/project/src/ui/tab-wszst.inc
@@ -1557,7 +1557,7 @@
{ T_OPT_G, "LT_CLEAR", "lt-clear|ltclear",
0,
- "Clear LEX sections TEST and DEV1 and remove the section and course.lex if empty."
+ "Clear LEX sections TEST and DEV1 and remove them and course.lex if empty."
" This option is executed before all other --lt-* options." },
{ T_OPT_GP, "LT_ONLINE", "lt-online|ltonline",
@@ -1705,7 +1705,9 @@
"Load given image, convert it to TPL.CMPR and add the result as sub-files"
" 'button/timg/ct_icons.tpl' and as 'control/timg/ct_icons.tpl'"
" to files 'Channel.szs', 'MenuMulti.szs' and 'MenuSingle.szs'."
- " Both sub-files are always linked, so that storage space is saved." },
+ " Both sub-files are always linked, so that storage space is saved."
+ " The usual size for each single icon is 128x128."
+ " This can be changed by LPAR setting CUP-ICON-SIZE." },
{ T_OPT_C, "NO_COPY", "no-copy|nocopy",
0,
@@ -1714,19 +1716,19 @@
{ T_OPT_GP, "CACHE", "cache",
"dir",
"Define a directory for an SZS cache."
- " If creating a YAZ0, BZIP2 or LZMA compressed file"
- " with standard compression (levels 9,9,6),"
+ " If creating a YAZ0, BZ, BZIP2, LZ or LZMA compressed file"
+ " with standard compression (levels 9,9,9,6,6),"
" the cache is searched for the compressed version."
" File cache-content.txt is used as file list with hash values."
" If the cache file is not found or the content differ,"
" the file is (re-)created and exit status 2=differ is returned."
" Option {--remove-dest} is set automatically to protect cache integrity."
"\n "
- " Background: Loading a compressed SZS and content verification"
- " is much faster than compressing a file."
+ " The idea behind the cache: Loading an SZS file and comparing the"
+ " decompressed content is clearly faster than compressing the file."
"\n "
" For legay reasons:"
- " If parameter DIR is a file, it is split into directory and base name."
+ " If parameter DIR is a file, the filename is split into directory and base name."
" The directory is used for the cache directory and the base name"
" for option {--cname}, but only if {--cname} is not used." },
diff --git a/project/src/ui/ui-wlect.c b/project/src/ui/ui-wlect.c
index 976b614..33cdf78 100644
--- a/project/src/ui/ui-wlect.c
+++ b/project/src/ui/ui-wlect.c
@@ -596,8 +596,8 @@ static const InfoOption_t OptionInfo[OPT__N_TOTAL+1] =
"Define a directory for an SZS cache. The cache is used to generate"
" LTA files when new compression is forced. Option --remove-dest is"
" set automatically to protect cache integrity.\n"
- " Background: Loading a compressed SZS and content verification is"
- " much faster than compressing a file."
+ " The idea behind the cache: Loading an SZS file and comparing the"
+ " decompressed content is clearly faster than compressing the file."
},
{ OPT_LOG_CACHE, false, false, false, false, false, 0, "log-cache",
diff --git a/project/src/ui/ui-wszst.c b/project/src/ui/ui-wszst.c
index 0880c59..c5af720 100644
--- a/project/src/ui/ui-wszst.c
+++ b/project/src/ui/ui-wszst.c
@@ -506,7 +506,8 @@ static const InfoOption_t OptionInfo[OPT__N_TOTAL+1] =
" sub-files 'button/timg/ct_icons.tpl' and as"
" 'control/timg/ct_icons.tpl' to files 'Channel.szs', 'MenuMulti.szs'"
" and 'MenuSingle.szs'. Both sub-files are always linked, so that"
- " storage space is saved."
+ " storage space is saved. The usual size for each single icon is"
+ " 128x128. This can be changed by LPAR setting CUP-ICON-SIZE."
},
{ OPT_NO_COPY, false, false, false, false, false, 0, "no-copy",
@@ -1621,9 +1622,8 @@ static const InfoOption_t OptionInfo[OPT__N_TOTAL+1] =
{ OPT_LT_CLEAR, false, false, false, false, false, 0, "lt-clear",
0,
- "Clear LEX sections TEST and DEV1 and remove the section and"
- " course.lex if empty. This option is executed before all other --lt-*"
- " options."
+ "Clear LEX sections TEST and DEV1 and remove them and course.lex if"
+ " empty. This option is executed before all other --lt-* options."
},
{ OPT_LT_ONLINE, false, false, false, false, false, 0, "lt-online",
@@ -1700,19 +1700,19 @@ static const InfoOption_t OptionInfo[OPT__N_TOTAL+1] =
{ OPT_CACHE, false, false, false, false, false, 0, "cache",
"dir",
- "Define a directory for an SZS cache. If creating a YAZ0, BZIP2 or"
- " LZMA compressed file with standard compression (levels 9,9,6), the"
- " cache is searched for the compressed version. File cache-content.txt"
- " is used as file list with hash values. If the cache file is not"
- " found or the content differ, the file is (re-)created and exit"
- " status 2=differ is returned. Option --remove-dest is set"
- " automatically to protect cache integrity.\n"
- " Background: Loading a compressed SZS and content verification is"
- " much faster than compressing a file.\n"
- " For legay reasons: If parameter DIR is a file, it is split into"
- " directory and base name. The directory is used for the cache"
- " directory and the base name for option --cname, but only if --cname"
- " is not used."
+ "Define a directory for an SZS cache. If creating a YAZ0, BZ, BZIP2,"
+ " LZ or LZMA compressed file with standard compression (levels"
+ " 9,9,9,6,6), the cache is searched for the compressed version. File"
+ " cache-content.txt is used as file list with hash values. If the"
+ " cache file is not found or the content differ, the file is"
+ " (re-)created and exit status 2=differ is returned. Option"
+ " --remove-dest is set automatically to protect cache integrity.\n"
+ " The idea behind the cache: Loading an SZS file and comparing the"
+ " decompressed content is clearly faster than compressing the file.\n"
+ " For legay reasons: If parameter DIR is a file, the filename is"
+ " split into directory and base name. The directory is used for the"
+ " cache directory and the base name for option --cname, but only if"
+ " --cname is not used."
},
{ OPT_CNAME, false, false, false, false, false, 0, "cname",
diff --git a/project/src/ui/ui.def b/project/src/ui/ui.def
index 1cd3169..16e9553 100644
--- a/project/src/ui/ui.def
+++ b/project/src/ui/ui.def
@@ -1234,9 +1234,8 @@
#:def_opt( "LT_CLEAR", "lt-clear|ltclear", "G", \
"", \
- "Clear LEX sections TEST and DEV1 and remove the section and" \
- " course.lex if empty. This option is executed before all other --lt-*" \
- " options." )
+ "Clear LEX sections TEST and DEV1 and remove them and course.lex if" \
+ " empty. This option is executed before all other --lt-* options." )
#:def_opt( "LT_ONLINE", "lt-online|ltonline", "GP", \
"mode", \
@@ -1381,7 +1380,8 @@
" sub-files 'button/timg/ct_icons.tpl' and as" \
" 'control/timg/ct_icons.tpl' to files 'Channel.szs', 'MenuMulti.szs'" \
" and 'MenuSingle.szs'. Both sub-files are always linked, so that" \
- " storage space is saved." )
+ " storage space is saved. The usual size for each single icon is" \
+ " 128x128. This can be changed by LPAR setting CUP-ICON-SIZE." )
#:def_opt( "NO_COPY", "no-copy|nocopy", "C", \
"", \
@@ -1389,18 +1389,18 @@
#:def_opt( "CACHE", "cache", "GP", \
"dir", \
- "Define a directory for an SZS cache. If creating a YAZ0, BZIP2 or" \
- " LZMA compressed file with standard compression (levels 9,9,6), the" \
- " cache is searched for the compressed version. File cache-content.txt" \
- " is used as file list with hash values. If the cache file is not" \
- " found or the content differ, the file is (re-)created and exit" \
- " status 2=differ is returned. Option {--remove-dest} is set" \
- " automatically to protect cache integrity.\n" \
- " Background: Loading a compressed SZS and content verification is" \
- " much faster than compressing a file.\n" \
- " For legay reasons: If parameter DIR is a file, it is split into" \
- " directory and base name. The directory is used for the cache" \
- " directory and the base name for option {--cname}, but only if" \
+ "Define a directory for an SZS cache. If creating a YAZ0, BZ, BZIP2," \
+ " LZ or LZMA compressed file with standard compression (levels" \
+ " 9,9,9,6,6), the cache is searched for the compressed version. File" \
+ " cache-content.txt is used as file list with hash values. If the" \
+ " cache file is not found or the content differ, the file is" \
+ " (re-)created and exit status 2=differ is returned. Option" \
+ " {--remove-dest} is set automatically to protect cache integrity.\n" \
+ " The idea behind the cache: Loading an SZS file and comparing the" \
+ " decompressed content is clearly faster than compressing the file.\n" \
+ " For legay reasons: If parameter DIR is a file, the filename is" \
+ " split into directory and base name. The directory is used for the" \
+ " cache directory and the base name for option {--cname}, but only if" \
" {--cname} is not used." )
#:def_opt( "CNAME", "cname", "GP", \
@@ -22470,8 +22470,8 @@
"Define a directory for an SZS cache. The cache is used to generate" \
" LTA files when new compression is forced. Option {--remove-dest} is" \
" set automatically to protect cache integrity.\n" \
- " Background: Loading a compressed SZS and content verification is" \
- " much faster than compressing a file." )
+ " The idea behind the cache: Loading an SZS file and comparing the" \
+ " decompressed content is clearly faster than compressing the file." )
#:def_opt( "LOG_CACHE", "log-cache|logcache", "GP", \
"file", \
diff --git a/project/src/wlect.c b/project/src/wlect.c
index bd21e81..e7fa231 100644
--- a/project/src/wlect.c
+++ b/project/src/wlect.c
@@ -978,6 +978,8 @@ static void help_create ( enumError exit_code )
"Create a LEX text file with section »SET1« only.\n"
"\t{name|CANNONS}:\t|"
"Create a LEX text file with section »CANN« only.\n"
+ "\t{name|CTDN} || {name|COUNTDOWN}:\n\t\t|"
+ "Create a LEX text file with section »CTDN« only.\n"
"\t{name|HIPT}:\t|"
"Create a LEX text file with section »HIPT« only.\n"
"\t{name|TEST}:\t|"
@@ -1037,12 +1039,12 @@ static enumError cmd_create()
//--- data
enum { C_HELP,
- C_LEX, C_FEATURES, C_DEV1, C_SET1, C_CANNON, C_HIDE_PT, C_RND_ITPH, C_TEST,
+ C_LEX, C_FEATURES, C_DEV1, C_SET1, C_CANNON, C_COUNTDOWN, C_HIDE_PT, C_RND_ITPH, C_TEST,
C_LPAR, C_LEDEF, C_PREFIX, C_CATEGORY,
C_LEINFO,
};
- // [[lex-new-sect]]
+ // [[new-lex-sect]]
static const KeywordTab_t tab[] =
{
@@ -1055,6 +1057,7 @@ static enumError cmd_create()
{ C_DEV1, "DEV1", 0, 0 },
{ C_SET1, "SET1", 0, 0 },
{ C_CANNON, "CANNONS", 0, 0 },
+ { C_COUNTDOWN, "CTDN", "COUNTDOWN", 0 },
{ C_HIDE_PT, "HIPT", 0, 0 },
{ C_RND_ITPH, "RITP ", 0, 0 },
{ C_TEST, "TEST", 0, 0 },
@@ -1108,6 +1111,7 @@ static enumError cmd_create()
case C_DEV1:
case C_SET1:
case C_CANNON:
+ case C_COUNTDOWN:
case C_HIDE_PT:
case C_RND_ITPH:
{
@@ -1119,6 +1123,7 @@ static enumError cmd_create()
case C_DEV1: AppendDev1LEX(&lex,false); break;
case C_SET1: AppendSet1LEX(&lex,false); break;
case C_CANNON: AppendCannLEX(&lex,false); break;
+ case C_COUNTDOWN: AppendCtdnLEX(&lex,false); break;
case C_HIDE_PT: AppendHiptLEX(&lex,false); break;
case C_RND_ITPH: AppendRitpLEX(&lex,false); break;
}
@@ -1127,7 +1132,7 @@ static enumError cmd_create()
}
break;
- // [[lex-new-sect]]
+ // [[new-lex-sect]]
case C_TEST:
{
@@ -1679,7 +1684,8 @@ static void help_distrib ( enumError exit_code )
" The following options are available:"
"|[14,22]\n"
- "\t{par|remove}:\t|Remove all used SZS source files at the very end.\n"
+ "\t{par|remove}:\t|Remove all used SZS source files at the very end."
+ " »{par|rm}« is s short cut.\n"
"\t{par|yaz0}:\t|Force YAZ0 compression for each track file.\n"
"\t{par|bz}:\t|Force BZ compression for each track file.\n"
"\t{par|bzip2}:\t|Force BZIP2 compression for each track file.\n"
@@ -1926,6 +1932,30 @@ static void help_distrib ( enumError exit_code )
"\t{name|/NO-SLOT}:\t|"
"Switch option {name|NO-SLOT} off.\n"
"\n"
+ "\t{name|HEX2SLOT}:\t|"
+ "If a filename of a track is a hex number with exact 3 digits,"
+ " then use it as slot number and force the slot for the track."
+ " If the slot is not defined or not available, or it is a _d track,"
+ " then the track is ignored.\n"
+ "\t{name|/HEX2SLOT}:\t|"
+ "Switch option {name|HEX2SLOT} off.\n"
+ "\n"
+ "\t{name|NAME2SLOT}:\t|"
+ "If a filename of a track is a known name like »{name|farm_course}«,"
+ " then use the related slot number and force the slot for the track."
+ " If the slot is not defined or not available, or it is a _d track,"
+ " then the track is ignored.\n"
+ "\t{name|/NAME2SLOT}:\t|"
+ "Switch option {name|NAME2SLOT} off.\n"
+ "\n"
+ "\t{name|CT-SLOTS}:\t|"
+ "Options {name|HEX2SLOT} and {name|NAME2SLOT}:"
+ " The availability of a slot for LE-CODE is usually examined."
+ " If this option is set, the availability for CT-CODE is examined."
+ " {name|CTSLOTS} is a short cut for this keyword.\n"
+ "\t{name|/CT-SLOTS}:\t|"
+ "Switch option {name|CT-SLOT} off.\n"
+ "\n"
"\t{name|BRIEF}:\t|"
"When creating text files, detailed descriptions are suppressed."
" The default is based on the global options {opt|--no-header} and {opt|--brief}.\n"
@@ -1979,29 +2009,9 @@ static void help_distrib ( enumError exit_code )
///////////////////////////////////////////////////////////////////////////////
-static void PrintHead ( ccp format, ... )
- __attribute__ ((__format__(__printf__,1,2)));
-
-static void PrintHead ( ccp format, ... )
-{
- if (stdlog)
- {
- char buf[500];
- va_list arg;
- va_start(arg,format);
- vsnprintf(buf,sizeof(buf),format,arg);
- va_end(arg);
-
- ASSERT(collog);
- fprintf(stdlog,"%s▼ %s%s\n",collog->caption,buf,collog->reset);
- fflush(stdlog);
- }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
static enumError cmd_distrib_instruction ( le_distrib_t *ld, ccp mode, char * arg )
{
+ CloseArchLogLD(ld);
u_nsec_t start_nsec = GetTimerNSec();
enum { C_NAMES, C_INFO, C_RATING, C_LEINFO, C_SHA1, C_DISTRIB,
@@ -2121,7 +2131,7 @@ static enumError cmd_distrib_instruction ( le_distrib_t *ld, ccp mode, char * ar
const KeywordTab_t *cmd = ScanKeyword(&cmd_stat,mode,tab);
if (!cmd)
{
- PrintHead("Instruction: %s = %s",mode,arg);
+ PrintDistribHead("Instruction: %s = %s",mode,arg);
PrintKeywordError(tab,mode,cmd_stat,0,"instruction");
hint_exit(ERR_SYNTAX);
}
@@ -2130,7 +2140,7 @@ static enumError cmd_distrib_instruction ( le_distrib_t *ld, ccp mode, char * ar
//--- start
if ( verbose >= 1 )
- PrintHead("Instruction %s: %s",cmd->name1,arg);
+ PrintDistribHead("Instruction %s: %s",cmd->name1,arg);
u_nsec_t temp_nsec = GetTimerNSec();
if ( CloseArchLD(ld) && verbose >= 2 )
@@ -2262,7 +2272,7 @@ static enumError cmd_distrib_instruction ( le_distrib_t *ld, ccp mode, char * ar
cmd = ScanKeyword(&cmd_stat,arg,tracks_tab);
if (!cmd)
{
- PrintHead("Instruction: %s = %s",mode,arg);
+ PrintDistribHead("Instruction: %s = %s",mode,arg);
PrintKeywordError(tab,arg,cmd_stat,0,"TRACKS keyword");
hint_exit(ERR_SYNTAX);
}
@@ -2426,7 +2436,7 @@ static enumError cmd_distrib()
if ( *arg == '+' )
{
if ( verbose >= 1 )
- PrintHead("Scan options: %s",arg);
+ PrintDistribHead("Scan options: %s",arg);
ScanOptionsLSP(&ld.spar,arg+1,"Filter option");
if ( ld.spar.opt & LEO_HELP )
help_distrib(ERR_OK);
@@ -2464,7 +2474,7 @@ static enumError cmd_distrib()
}
if ( verbose >= 1 )
- PrintHead("Read file(s): %s",arg);
+ PrintDistribHead("Read file(s): %s",arg);
const u_nsec_t start_nsec = GetTimerNSec();
ImportFileLD(&ld,arg,true,false);
if ( verbose >= 2 )
diff --git a/project/src/wszst.c b/project/src/wszst.c
index 59192d2..ed55f39 100644
--- a/project/src/wszst.c
+++ b/project/src/wszst.c
@@ -510,6 +510,7 @@ static const sizeof_info_t sizeof_info_szs_list[] =
SIZEOF_INFO_ENTRY(lex_element_t)
SIZEOF_INFO_ENTRY(lex_dev1_t)
SIZEOF_INFO_ENTRY(lex_set1_t)
+ SIZEOF_INFO_ENTRY(lex_ctdn_t)
SIZEOF_INFO_ENTRY(lex_hipt_rule_t)
SIZEOF_INFO_ENTRY(lex_ritp_rule_t)
// [[new-lex-sect]]
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-29 12:17:39 +0000