SZS v2.18a

1 files changed, 4248 insertions, 0 deletions

diff --git a/project/src/lib-ctcode.c b/project/src/lib-ctcode.c
new file mode 100644
index 0000000..11b60e4
--- /dev/null
+++ b/project/src/lib-ctcode.c
@@ -0,0 +1,4248 @@
+
+/***************************************************************************
+ *                         _______ _______ _______                         *
+ *                        |  ___  |____   |  ___  |                        *
+ *                        | |   |_|    / /| |   |_|                        *
+ *                        | |_____    / / | |_____                         *
+ *                        |_____  |  / /  |_____  |                        *
+ *                         _    | | / /    _    | |                        *
+ *                        | |___| |/ /____| |___| |                        *
+ *                        |_______|_______|_______|                        *
+ *                                                                         *
+ *                            Wiimms SZS Tools                             *
+ *                          https://szs.wiimm.de/                          *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This file is part of the SZS project.                                 *
+ *   Visit https://szs.wiimm.de/ for project details and sources.          *
+ *                                                                         *
+ *   Copyright (c) 2011-2020 by Dirk Clemens <wiimm@wiimm.de>              *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   See file gpl-2.0.txt or http://www.gnu.org/licenses/gpl-2.0.txt       *
+ *                                                                         *
+ ***************************************************************************/
+
+#include "lib-ctcode.h"
+#include "lib-lecode.h"
+#include "lib-szs.h"
+#include "lib-xbmg.h"
+#include "lib-bzip2.h"
+#include "lib-image.h"
+#include "dclib-utf8.h"
+
+#include "db-ctcode.h"
+#include "lib-ctdata.c"
+#include "ctcode.inc"
+#include <locale.h>
+
+#define TNAME_BUF_SIZE	1000
+#define HIDDEN_CUP	0x7f
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			helpers				///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int MusicID2TrackId ( uint music_id, int no_track, int not_found )
+{
+    if ( music_id >= MKW_MUSIC_MIN_ID && music_id <= MKW_MUSIC_MAX_ID )
+    {
+	music_id = ( music_id - MKW_MUSIC_MIN_ID ) / 2;
+	DASSERT( music_id < MKW_N_MUSIC );
+	const int tid = music_info[music_id].track;
+	return tid < 0 ? no_track : tid;
+    }
+    return not_found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SetName16 ( u16 *dest, ccp src )
+{
+    DASSERT(dest);
+    DASSERT(src);
+
+    memset(dest,0,CT_NAME_SIZE*sizeof(*dest));
+    ScanString16BMG(dest,CT_NAME_SIZE-1,src,-1,0);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void SetTrackBMG
+(
+    ctcode_t	*ctcode,	// valid CTCODE
+    bmg_t	*bmg,		// destination BMG
+    uint	tidx,		// index of the track
+    ccp		text		// any text
+)
+{
+    DASSERT(ctcode);
+    DASSERT(bmg);
+
+    u16 *dest = ctcode->crs->data[tidx].tname;
+    memset(dest,0,CT_NAME_SIZE*sizeof(*dest));
+
+    if ( text && *text )
+    {
+	bmg_item_t *bi = InsertItemBMG(bmg,ctcode->ctb.track_name1.beg+tidx,0,0,0);
+	DASSERT(bi);
+	AssignItemScanTextBMG(bi,text,-1);
+
+	const uint max_len = bi->len < CT_NAME_SIZE-1 ? bi->len : CT_NAME_SIZE-1;
+	memcpy(dest,bi->text,max_len*sizeof(*dest));
+    }
+    else
+    {
+	bmg_item_t *bi = FindItemBMG(bmg,ctcode->ctb.track_name1.beg+tidx);
+	if (bi)
+	    FreeItemBMG(bi);
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+static inline void SetTrackFile
+(
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    ccp		text		// any text
+)
+{
+    SetTrackBMG(ctcode,&ctcode->track_file,tidx,text);
+}
+
+//-----------------------------------------------------------------------------
+
+static inline void SetTrackString
+(
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    ccp		text		// any text
+)
+{
+    SetTrackBMG(ctcode,&ctcode->track_string,tidx,text);
+}
+
+//-----------------------------------------------------------------------------
+
+static inline void SetTrackIdentifier
+(
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    ccp		text		// any text
+)
+{
+    if ( !text || !*text || !strcmp(text,"-") )
+	text = 0;
+    SetTrackBMG(ctcode,&ctcode->track_ident,tidx,text);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// [[file-name]]
+static void SetTrackInfo16
+(
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const u16	*text,		// any text
+    int		len		// length of 'text', or -1
+)
+{
+    DASSERT(ctcode);
+    DASSERT(text);
+
+    if ( len < 0 )
+	len = GetLength16BMG(text,1000);
+
+    u16 *dest = ctcode->crs->data[tidx].tname;
+    memset(dest,0,CT_NAME_SIZE*sizeof(*dest));
+
+    if ( text && len )
+    {
+	bmg_item_t *bi = InsertItemBMG( &ctcode->track_string,
+					ctcode->ctb.track_name1.beg+tidx,0,0,0);
+	DASSERT(bi);
+	AssignItemText16BMG(bi,text,len);
+
+	const uint max_len = bi->len < CT_NAME_SIZE-1 ? bi->len : CT_NAME_SIZE-1;
+	memcpy(dest,bi->text,max_len*sizeof(*dest));
+    }
+    else
+    {
+	bmg_item_t *bi = FindItemBMG(&ctcode->track_string,
+					ctcode->ctb.track_name1.beg+tidx);
+	if (bi)
+	    FreeItemBMG(bi);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp GetRawTrackInfo
+(
+    char	*buf,		// dest buffer
+    uint	size,		// size of 'buf'
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const bmg_item_t *bi	// NULL or bmg text
+)
+{
+    DASSERT(buf);
+    DASSERT(size);
+    DASSERT(ctcode);
+
+// [[file-name]]
+    if ( !bi || !bi->len )
+	bi = FindItemBMG(&ctcode->track_string,tidx+ctcode->ctb.track_name1.beg);
+
+    const u16 *src;
+    uint len;
+    if ( bi && bi->len )
+    {
+	src = bi->text;
+	len = bi->len;
+    }
+    else
+    {
+	src = ctcode->crs->data[tidx].tname;
+	len = GetLength16BMG(src,CT_NAME_SIZE);
+    }
+
+    const u16 *end = src + len;
+    char *dest = buf;
+    char *dest_end = buf + size - 4;
+    while ( dest < dest_end && src < end )
+	dest = PrintUTF8Char(dest,ntohs(*src++));
+    *dest = 0;
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp GetTrackFile
+(
+    char	*buf,		// dest buffer
+    uint	size,		// size of 'buf'
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const bmg_item_t *bi	// NULL or bmg text
+)
+{
+    DASSERT(buf);
+    DASSERT(size);
+    DASSERT(ctcode);
+
+    if ( !bi || !bi->len )
+	bi = FindItemBMG(&ctcode->track_file,tidx+ctcode->ctb.track_name1.beg);
+
+    if ( bi && bi->len )
+	PrintString16BMG(buf,size,bi->text,bi->len,BMG_UTF8_MAX,0,opt_bmg_colors);
+    else
+    {
+	const u16 *src = ctcode->crs->data[tidx].tname;
+	const uint len = GetLength16BMG(src,CT_NAME_SIZE);
+	PrintString16BMG(buf,size,src,len,BMG_UTF8_MAX,0,opt_bmg_colors);
+    }
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+static ccp GetTrackString
+(
+    char	*buf,		// dest buffer
+    uint	size,		// size of 'buf'
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const bmg_item_t *bi	// NULL or bmg text
+)
+{
+    DASSERT(buf);
+    DASSERT(size);
+    DASSERT(ctcode);
+
+    if ( !bi || !bi->len )
+	bi = FindItemBMG(&ctcode->track_string,tidx+ctcode->ctb.track_name1.beg);
+
+    if ( bi && bi->len )
+	PrintString16BMG(buf,size,bi->text,bi->len,BMG_UTF8_MAX,0,opt_bmg_colors);
+    else
+	*buf = 0;
+    return buf;
+}
+
+//-----------------------------------------------------------------------------
+
+static ccp GetTrackIdentifier
+(
+    char	*buf,		// dest buffer
+    uint	size,		// size of 'buf'
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const bmg_item_t *bi	// NULL or bmg text
+)
+{
+    DASSERT(buf);
+    DASSERT(size);
+    DASSERT(ctcode);
+
+    if ( !bi || !bi->len )
+	bi = FindItemBMG(&ctcode->track_ident,tidx+ctcode->ctb.track_name1.beg);
+
+    if ( bi && bi->len )
+	PrintString16BMG(buf,size,bi->text,bi->len,BMG_UTF8_MAX,0,opt_bmg_colors);
+    else
+	*buf = 0;
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const u16 * GetTrackName16
+(
+    uint	*tlen,		// not nULL: store length of result here
+    ctcode_t	*ctcode,	// valid CTCODE
+    uint	tidx,		// index of the track
+    const bmg_item_t *bi	// NULL or bmg text
+)
+{
+    DASSERT(ctcode);
+
+// [[file-name]]
+    if ( !bi || !bi->len )
+	bi = FindItemBMG(&ctcode->track_string,tidx+ctcode->ctb.track_name1.beg);
+
+    if ( bi && bi->len )
+    {
+	if (tlen)
+	    *tlen = bi->len;
+	return bi->text;
+    }
+
+    const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+    if (tlen)
+	*tlen = GetLength16BMG(td->tname,sizeof(td->tname)/sizeof(*td->tname));
+    return td->tname;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintMusicID ( uint mid, bool force_hex )
+{
+    if ( !force_hex && mid >= MKW_MUSIC_MIN_ID && mid <= MKW_MUSIC_MAX_ID )
+    {
+	const uint mid0 = mid - MKW_MUSIC_MIN_ID;
+	if (!(mid0&1))
+	    return music_info[mid0/2].name;
+    }
+
+    if (!mid)
+	return "0";
+
+    const int bufsize = 8;
+    char *buf = GetCircBuf(bufsize);
+    snprintf(buf,bufsize,"0x%02x",mid);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintPropertyID ( uint tid, bool force_hex )
+{
+    if ( tid < MKW_N_TRACKS && !force_hex )
+	return track_info[tid].abbrev;
+
+    const int bufsize = 8;
+    char *buf = GetCircBuf(bufsize);
+    snprintf(buf,bufsize,"0x%02x",tid);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ctcode_cup1_data_t * GetCupData ( const ctcode_t * ctcode, uint cup_idx )
+{
+    DASSERT(ctcode);
+    if ( cup_idx < ctcode->n_racing_cups )
+	return ctcode->cup_racing + cup_idx;
+
+    cup_idx -= ctcode->n_racing_cups;
+    return cup_idx < ctcode->n_battle_cups ? ctcode->cup_battle + cup_idx : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool CheckLEFlagsUsage ( ctcode_t * ctcode )
+{
+    PRINT("USE_LE_FLAGS=%d\n",ctcode->use_le_flags);
+    if (!ctcode->use_le_flags)
+    {
+	uint tid;
+	for ( tid = 0; tid < CODE_MAX_TRACKS; tid++ )
+	    if (ctcode->le_flags[tid])
+	    {
+		ctcode->use_le_flags = true;
+		break;
+	    }
+	PRINT("USE_LE_FLAGS=%d\n",ctcode->use_le_flags);
+    }
+
+    return ctcode->use_le_flags;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			CTCODE base interface		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InitializeCTCODE ( ctcode_t * ctcode, ct_mode_t ct_mode )
+{
+    DASSERT(ctcode);
+    memset(ctcode,0,sizeof(*ctcode));
+    SetupCtBMG( &ctcode->ctb, ct_mode, opt_ct_mode );
+    PRINT("CTCODE: %s\n",GetCtBMGIdentification(&ctcode->ctb,true));
+
+    ctcode->use_lecode = lecode_enabled;
+    ctcode->fname = EmptyString;
+    InitializeBMG(&ctcode->track_file);
+    InitializeBMG(&ctcode->track_string);
+    InitializeBMG(&ctcode->track_ident);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetCTCODE ( ctcode_t * ctcode )
+{
+    DASSERT(ctcode);
+    ResetBMG(&ctcode->track_file);
+    ResetBMG(&ctcode->track_string);
+    ResetBMG(&ctcode->track_ident);
+    ResetDataCTCODE(ctcode,false);
+    FreeString(ctcode->fname);
+    FreeString(ctcode->next_cup_name);
+    InitializeCTCODE(ctcode,ctcode->ctb.ct_mode);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void SetupUsedSlotList ( u8 *slot_list, uint n_slots, uint le_phase )
+{
+    DASSERT(slot_list);
+    DASSERT(n_slots>=0x100);
+
+    memset(slot_list, 0, n_slots );
+    if (le_phase)
+    {
+	memset( slot_list + MKW_ARENA_BEG,
+		2,
+		LE_FIRST_LOWER_CT_SLOT - MKW_ARENA_BEG );
+	if ( le_phase == 1 )
+	{
+	    const uint max = n_slots < LE_FIRST_UPPER_CT_SLOT
+			   ? n_slots : LE_FIRST_UPPER_CT_SLOT;
+	    if ( max > 0xff )
+		memset(slot_list+0xff,2,max-0xff); // 0xff == random
+	}
+    }
+    else
+    {
+	memset( slot_list + MKW_ARENA_BEG, 2, MKW_N_ARENAS );
+	memset( slot_list + 0xff, 2, n_slots - 0xff );
+
+	slot_list[0x36] = 2;  // ring_mission = Galaxy Colosseum (music_id=0xc9)
+	slot_list[0x37] = 2;  // winningrun_demo
+	slot_list[0x38] = 2;  // loser_demo
+	slot_list[0x39] = 2;  // draw_demo
+	slot_list[0x3a] = 2;  // ending_demo
+
+	slot_list[0x42] = 2;  // invalid -> can be used? (99%)
+	slot_list[0x43] = 2;  // no track selected
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+// 0:free, 1:used, 2:reserved
+u8 ctcode_used_slot[USED_SLOT_MAX] = {0x7f};
+
+static void SetupUsedSlots()
+{
+    if ( ctcode_used_slot[0] == 0x7f  )
+	SetupUsedSlotList(ctcode_used_slot,sizeof(ctcode_used_slot),0);
+}
+
+//-----------------------------------------------------------------------------
+
+void SetupUsedSlotsCTCODE ( ctcode_t * ctcode )
+{
+    SetupUsedSlots();
+    if ( ctcode->ctb.le_phase )
+    {
+	SetupUsedSlotList( ctcode->used_slot,
+				sizeof(ctcode->used_slot), ctcode->ctb.le_phase );
+	ctcode->n_tracks = LE_FIRST_LOWER_CT_SLOT;
+    }
+    else
+    {
+	SetupUsedSlotList(ctcode->used_slot,sizeof(ctcode->used_slot),0);
+	memcpy(ctcode->used_slot,ctcode_used_slot,sizeof(ctcode_used_slot));
+	ctcode->n_tracks = 0x3b;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetDataCTCODE ( ctcode_t * ctcode, bool create_empty )
+{
+    DASSERT(ctcode);
+
+    //--- cups (CUP1)
+
+    if (ctcode->cup_alloced)
+    {
+	ctcode->cup_alloced = false;
+	FREE(ctcode->cup);
+    }
+    ctcode->cup			= 0;
+    ctcode->cup_size		= 0;
+
+    ctcode->cup_racing		= 0;
+    ctcode->n_racing_cups	= 0;
+    ctcode->max_racing_cups	= 0;
+
+    ctcode->cup_battle		= 0;
+    ctcode->n_battle_cups	= 0;
+    ctcode->max_battle_cups	= 0;
+
+    ctcode->n_unused_cups	= 0;
+
+
+    //--- tracks (CRS1)
+
+    if (ctcode->crs_alloced)
+    {
+	ctcode->crs_alloced = false;
+	FREE(ctcode->crs);
+    }
+    ctcode->crs			= 0;
+    ctcode->crs_size		= 0;
+
+    ctcode->n_tracks		= 0;
+    ctcode->max_tracks		= 0;
+
+
+    //--- misc
+
+    SetupUsedSlotsCTCODE(ctcode);
+    CalcCupRefCTCODE(ctcode,true);
+ #if USE_NEW_CONTAINER_CTC
+    ResetContainer(&ctcode->container);
+ #else
+    FreeContainer(ctcode->old_container);
+    ctcode->old_container = 0;
+ #endif
+
+
+
+    //--- create empty image?
+
+    if (!create_empty)
+	return;
+
+    char namebuf[100]; // no more chars needed
+
+
+    //--- create empty cups
+
+    const uint max_battle_cups	= 2;
+    const uint max_racing_cups	= ( ctcode->ctb.le_phase
+					? LE_CODE_MAX_CUPS : CT_CODE_DEFAULT_CUPS )
+				- max_battle_cups ;
+
+    ctcode->cup_size	= sizeof(ctcode_cup1_head_t)
+			+ (max_racing_cups+max_battle_cups) * sizeof(ctcode_cup1_data_t);
+    ctcode->cup		= CALLOC(ctcode->cup_size,1);
+    ctcode->cup_racing	= ctcode->cup->data;
+    ctcode->cup_battle	= ctcode->cup_racing + max_racing_cups;
+    memcpy(ctcode->cup,cup1_header,sizeof(cup1_header));
+
+    //ctcode->n_racing_cups = 0;
+    ctcode->max_racing_cups = max_racing_cups;
+    ctcode->n_unused_cups   = max_racing_cups;
+    ctcode->n_battle_cups   = max_battle_cups;
+    ctcode->max_battle_cups = max_battle_cups;
+
+    uint cidx, tidx = MKW_ARENA_BEG;
+    for ( cidx = 0; cidx < max_battle_cups; cidx++ )
+    {
+	ctcode_cup1_data_t *cd = ctcode->cup_battle + cidx;
+	snprintf(namebuf,sizeof(namebuf),"Battle %u",cidx+1);
+	SetName16(cd->name,namebuf);
+
+	if ( !ctcode->ctb.le_phase )
+	{
+	    uint t;
+	    for ( t = 0; t < 5; t++ )
+		cd->track_id[t] = htonl(tidx++);
+	}
+    }
+
+
+    //--- create empty tracks: data
+
+    const uint max_tracks = ctcode->ctb.le_phase ? LE_CODE_MAX_TRACKS : CT_CODE_MAX_TRACKS;
+    ctcode->crs_size = sizeof(ctcode_crs1_head_t)
+		     + max_tracks * sizeof(ctcode_crs1_data_t);
+    ctcode->crs = CALLOC(ctcode->crs_size,1);
+
+    struct tab_t
+    {
+	u32	tidx;
+	u32	music_id;
+	u32	property_id;
+	ccp	name;
+    };
+
+    static const struct tab_t tab[] =
+    {
+	{ 0x36, 0xc9, 0x36, "ring_mission" },
+	{ 0x37,    0,    0, "winningrun_demo" },
+	{ 0x38,    0,    0, "loser_demo" },
+	{ 0x39,    0,    0, "draw_demo" },
+	{ 0x3a, 0x75, 0x08, "ending_demo" },
+    //	{ 0x42,    0,    0, "invalid" },
+	{ 0x43,    0,    0, "- " TOOLSET_LONG " v" VERSION " r" REVISION },
+	{0,0,0,0}
+    };
+
+    const struct tab_t *ptr;
+    for ( ptr = tab; ptr->name; ptr++ )
+    {
+	ctcode_crs1_data_t *td = ctcode->crs->data + ptr->tidx;
+	td->music_id = htonl(ptr->music_id);
+	td->property_id = htonl(ptr->property_id);
+
+	ccp src = ptr->name;
+	if ( *src == '-' )
+	    src++;
+	else
+	    strcpy(td->filename,ptr->name);
+
+	char buf[200], *dest = buf;
+	bool upper = true;
+	while (*src)
+	{
+	    int ch = (uchar)*src++;
+	    if ( ch == '_' )
+	    {
+		upper = true;
+		ch = ' ';
+	    }
+	    else if (upper)
+	    {
+		upper = false;
+		ch = toupper((int)ch);
+	    }
+	    *dest++ = ch;
+	}
+	*dest = 0;
+	SetTrackString(ctcode,ptr->tidx,buf);
+    }
+
+
+    //--- create empty tracks: header
+
+    memcpy(ctcode->crs,crs1_header,sizeof(crs1_header));
+
+    uint i;
+    const u32 val = htonl(crs1_property);
+    for ( i = 0; i < 8; i++ )
+	ctcode->crs->property[i] = val;
+
+    //ctcode->n_tracks	    = 0;
+    ctcode->max_tracks	    = max_tracks;
+    ctcode->used_arenas     = 5 * max_battle_cups;
+
+    ctcode_crs1_data_t *td = ctcode->crs->data;
+    for ( tidx = 0; tidx < max_tracks; tidx++, td++ )
+    {
+	if ( tidx >= MKW_N_TRACKS && tidx < MKW_N_TRACKS + MKW_N_ARENAS )
+	{
+	    const TrackInfo_t *info = arena_info + (tidx-MKW_N_TRACKS);
+	    SetName16(td->tname,info->name_en);
+	    StringCopyS(td->filename,sizeof(td->filename),info->track_fname);
+
+	    if ( ctcode->ctb.le_phase )
+	    {
+		td->music_id	= htonl(arena_info[tidx-MKW_N_TRACKS].music_id);
+		td->property_id	= htonl(tidx);
+	    }
+	}
+	else if (!ctcode->used_slot[tidx])
+	{
+	    snprintf(namebuf,sizeof(namebuf),"Slot %u = 0x%03x",tidx,tidx);
+	    SetName16(td->tname,namebuf);
+	    snprintf(namebuf,sizeof(namebuf),"slot_%02x",tidx);
+	    StringCopyS(td->filename,sizeof(td->filename),namebuf);
+
+	    td->music_id	= htonl(0x75);
+	    td->property_id	= htonl(0);
+	    td->cup_id		= htonl(0xff);
+	}
+    }
+
+
+    //--- LE-CODE: battles again
+
+    if ( ctcode->ctb.le_phase )
+    {
+	ctcode_cup1_data_t *cd = ctcode->cup_battle;
+	uint aid;
+	for ( aid = 0; aid < MKW_N_ARENAS; aid++ )
+	{
+	    uint tid = arena_info[aid].def_index;
+	    cd[tid/5].track_id[tid%5] = htonl(aid+MKW_N_TRACKS);
+	}
+	//HexDump16(stdout,0,0,cd[0].track_id,sizeof(cd[0].track_id));
+	//HexDump16(stdout,0,0,cd[1].track_id,sizeof(cd[1].track_id));
+    }
+
+
+    //--- terminate
+
+    ctcode->cupref_dirty = false;
+
+    PRINT("STAT/CUP: racing: %u/%u, battle: %u/%u, unused: %u\n",
+		ctcode->n_racing_cups, ctcode->max_racing_cups,
+		ctcode->n_battle_cups, ctcode->max_battle_cups,
+		ctcode->n_unused_cups );
+    PRINT("STAT/TRACK: %u/%u\n", ctcode->n_tracks, ctcode->max_tracks );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CalcCupRefCTCODE ( ctcode_t * ctcode, bool force )
+{
+    DASSERT(ctcode);
+    if ( !force && !ctcode->cupref_dirty )
+	return;
+
+
+    //--- clear data
+
+    ctcode->used_tracks = 0;
+    ctcode->used_arenas = 0;
+    memset(ctcode->cupref,0,sizeof(ctcode->cupref));
+
+
+    //--- source available?
+
+    if ( !ctcode->cup || !ctcode->crs )
+    {
+	ctcode->cupref_dirty = true;
+	return;
+    }
+    ctcode->cupref_dirty = false;
+
+
+    //--- cup loop
+
+    uint cidx;
+    for ( cidx = 0; cidx < ctcode->n_racing_cups + ctcode->n_battle_cups; cidx++ )
+    {
+	const bool is_battle = cidx >= ctcode->n_racing_cups;
+	const ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	DASSERT(cd);
+
+	uint ti;
+	for ( ti = 0; ti < 4 + is_battle; ti++ )
+	{
+	    const uint tidx = be32(cd->track_id+ti);
+	    if ( tidx < ctcode->max_tracks )
+	    {
+		ctcode_cupref_t *cr = ctcode->cupref + tidx;
+		if (!cr->n)
+		{
+		    if (is_battle)
+			ctcode->used_arenas++;
+		    else
+			ctcode->used_tracks++;
+		}
+
+		if (is_battle)
+		    cr->n_battle++;
+		else
+		    cr->n_racing++;
+
+		if ( cr->n < CT_CODE_MAX_CUPREF )
+		{
+		    cr->cup[cr->n] = is_battle
+					? cidx	- ctcode->n_racing_cups
+						+ ctcode->max_racing_cups
+					: cidx;
+		    cr->idx[cr->n] = ti;
+		    cr->n++;
+		}
+	    }
+	}
+    }
+
+    PRINT("STAT/REF: nT=%u, nA=%u, total=%u/%u\n",
+		ctcode->used_tracks, ctcode->used_arenas,
+		ctcode->n_tracks, ctcode->max_tracks );
+
+    //HexDump16(stderr,0,0x16,ctcode->cupref+0,sizeof(*ctcode->cupref));
+    //HexDump16(stderr,0,0x16,ctcode->cupref+1,sizeof(*ctcode->cupref));
+
+
+    //--- hidden tracks: create reference
+
+    ParamField_t ref;
+    InitializeParamField(&ref);
+    char namebuf[TNAME_BUF_SIZE];
+
+    uint tidx;
+    for ( tidx = 0; tidx < ctcode->n_tracks; tidx++ )
+    {
+	if (ctcode->hidden[tidx])
+	    continue;
+
+	GetTrackIdentifier(namebuf,sizeof(namebuf),ctcode,tidx,0);
+	if (*namebuf && !FindParamField(&ref,namebuf) )
+	    InsertParamField(&ref,namebuf,false,tidx,0);
+    }
+
+
+    //--- hidden tracks: use reference
+
+    for ( tidx = 0; tidx < ctcode->n_tracks; tidx++ )
+    {
+	if (!ctcode->hidden[tidx])
+	    continue;
+
+	GetTrackIdentifier(namebuf,sizeof(namebuf),ctcode,tidx,0);
+	if (*namebuf)
+	{
+	    const ParamFieldItem_t *it = FindParamField(&ref,namebuf);
+	    if (it)
+		memcpy(	ctcode->cupref+tidx,
+			ctcode->cupref+it->num,
+			sizeof(*ctcode->cupref) );
+	}
+    }
+
+    ResetParamField(&ref);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PrepareExportCTCODE ( ctcode_t * ctcode )
+{
+    DASSERT(ctcode);
+    DASSERT(ctcode->cup);
+    DASSERT(ctcode->cup_racing);
+    DASSERT(ctcode->cup_battle);
+    DASSERT(ctcode->crs);
+
+    if ( !ctcode->cup || !ctcode->cup_racing || !ctcode->cup_battle || !ctcode->crs )
+	return;
+
+    //--- setup ctcode header
+
+    ctcode_header_t *ch = &ctcode->ct_head;
+    memcpy(ch,ctcode_header,sizeof(*ch));
+    u32 off = sizeof(*ch);
+
+
+    //--- setup CUP1
+
+    DASSERT( ctcode->max_racing_cups >= ctcode->n_racing_cups );
+    DASSERT( ctcode->cup_racing == ctcode->cup->data );
+    ctcode->max_racing_cups = ctcode->n_racing_cups;
+
+    ctcode_cup1_data_t *battle = ctcode->cup_racing + ctcode->n_racing_cups;
+    DASSERT( ctcode->cup_battle >= battle );
+    if ( ctcode->cup_battle > battle )
+    {
+	memmove( battle,ctcode->cup_battle, ctcode->n_battle_cups * sizeof(*battle) );
+	ctcode->cup_battle = battle;
+	ctcode->cupref_dirty = true;
+    }
+
+    ctcode->cup->n_racing_cups = htonl(ctcode->n_racing_cups);
+    ctcode->cup->n_battle_cups = htonl(ctcode->n_battle_cups);
+    const u8 *end = (u8*)(battle + ctcode->n_battle_cups);
+    DASSERT( end <= (u8*)ctcode->cup + ctcode->cup_size );
+    ctcode->cup_size = end - (u8*)ctcode->cup;
+    ctcode->cup->size = htonl(ctcode->cup_size);
+    ch->sect_info[0].off = htonl(off);
+    off += ctcode->cup_size;
+
+
+    //--- setup CRS1
+
+    DASSERT( ctcode->max_tracks >= ctcode->n_tracks );
+    ctcode->max_tracks = ctcode->n_tracks;
+    end = (u8*)( ctcode->crs->data + ctcode->n_tracks );
+    DASSERT( end <= (u8*)ctcode->crs + ctcode->crs_size );
+    ctcode->crs_size =  end - (u8*)ctcode->crs;
+    ctcode->crs->size = htonl(ctcode->crs_size);
+    ctcode->crs->n_tracks = htonl(ctcode->n_tracks);
+    ch->sect_info[1].off = htonl(off);
+    //off += ctcode->crs_size;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PatchNamesCTCODE ( ctcode_t * ctcode )
+{
+    uint cidx;
+    for ( cidx = 0; cidx < ctcode->n_racing_cups + ctcode->n_battle_cups; cidx++ )
+    {
+	const bmg_item_t *bi
+		= FindItemBMG(&opt_load_bmg,ctcode->ctb.rcup_name.beg+cidx);
+	if ( bi && bi->len )
+	{
+	    ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	    memset(cd->name,0,sizeof(cd->name));
+	    const uint len = bi->len < CT_NAME_SIZE-1 ? bi->len : CT_NAME_SIZE-1;
+	    memcpy(cd->name,bi->text,len*sizeof(*cd->name));
+	}
+    }
+
+    uint tidx;
+    for ( tidx = 0; tidx < ctcode->n_tracks; tidx++ )
+    {
+	const bmg_item_t *bi
+	    = FindItemBMG(&opt_load_bmg,ctcode->ctb.track_name1.beg+tidx);
+	if ( bi && bi->len )
+	    SetTrackInfo16(ctcode,tidx,bi->text,bi->len);
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			PrepareSaveCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp  opt_image_dir		= 0;
+bool opt_dynamic_ctcode		= false;
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enum { MAX_KEY = 200 };
+typedef struct track_info_t
+{
+    char key[MAX_KEY];	// sort key
+    uint order;		// index reflecting inital order
+    uint tidx;		// track index
+}
+track_info_t;
+
+static int cmp_track_info ( const track_info_t * a, const track_info_t * b )
+{
+    const int stat = strcoll(a->key,b->key);
+    return stat ? stat : a->order < b->order ? -1 : 1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ReorderTracksCTCODE ( ctcode_t * ctcode )
+{
+    DASSERT(ctcode);
+    PRINT("ReorderTracksCTCODE()\n");
+    setlocale(LC_COLLATE,"");
+
+    if ( !opt_order_by || !*opt_order_by )
+	return ERR_NOTHING_TO_DO;
+
+    bmg_t bmg;
+    enumError err = LoadXBMG(&bmg,true,opt_order_by,true,false);
+    if (!err)
+    {
+	track_info_t info[CODE_MAX_TRACKS];
+	memset(info,0,sizeof(info));
+
+	track_info_t *ptr = info;
+	uint cidx;
+	for ( cidx = opt_order_all ? 0 : 8;
+		cidx < ctcode->n_racing_cups; cidx++ )
+	{
+	    const ctcode_cup1_data_t *cd = ctcode->cup->data + cidx;
+
+	    uint ti;
+	    for ( ti = 0; ti < 4; ti++, ptr++ )
+	    {
+		DASSERT( ptr < info + ctcode->max_tracks );
+		const uint tidx = be32(cd->track_id+ti);
+		const bmg_item_t *bi
+			= FindItemBMG(&bmg,tidx+ctcode->ctb.track_name1.beg);
+		if ( bi && bi->len )
+		{
+		    *ptr->key = 'A';
+		    PrintString16BMG(ptr->key+1,sizeof(ptr->key)-1,
+				bi->text,bi->len,BMG_UTF8_MAX,0,opt_bmg_colors);
+		}
+		else
+		    *ptr->key = 'B';
+		ptr->tidx = tidx;
+		ptr->order = ptr - info;
+
+		noPRINT("KEY: %02x %s\n",*ptr->key,ptr->key+1);
+	    }
+	}
+
+	const uint n = ptr - info;
+	if ( n > 1 )
+	    qsort( info, n, sizeof(*info), (qsort_func)cmp_track_info );
+
+	track_info_t *src = info;
+	for ( cidx = opt_order_all ? 0 : 8;
+		cidx < ctcode->n_racing_cups; cidx++ )
+	{
+	    ctcode_cup1_data_t *cd = ctcode->cup->data + cidx;
+
+	    uint ti;
+	    for ( ti = 0; ti < 4; ti++, src++ )
+	    {
+		noPRINT("KEY: %3u,%02x: %02x %s\n",
+			src->order, src->tidx, *src->key, src->key+1 );
+		write_be32(cd->track_id+ti,src->tidx);
+	    }
+	}
+    }
+
+    ResetBMG(&bmg);
+    CalcCupRefCTCODE(ctcode,true);
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void PrepareSaveCTCODE ( ctcode_t * ctcode )
+{
+    DASSERT(ctcode);
+    PRINT("PrepareSaveCTCODE()\n");
+
+    if (ctcode->save_prepared)
+	return;
+    ctcode->save_prepared++;
+
+    ReorderTracksCTCODE(ctcode);
+    if (opt_write_tracks)
+	SaveTrackTableCTCODE(ctcode,opt_write_tracks,false);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			DumpCTCODE()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void hexdump
+	( FILE *f, uint indent, const void *vdata, uint size, ccp title )
+{
+    DASSERT(f);
+    DASSERT(title);
+
+    if ( !vdata || !size )
+	return;
+
+    fprintf(f,"\n%*s%s\n",indent+2,"",title);
+    const u8* data = vdata;
+
+    uint addr;
+    for ( addr = 0; addr < size; )
+    {
+	fprintf(f,"%*x:",indent+6,addr);
+	uint i;
+	for ( i = 0; i < 4 && addr < size; i++, addr+=4 )
+	    fprintf(f," %8x",be32(data+addr));
+	fputc('\n',f);
+    }
+};
+
+//-----------------------------------------------------------------------------
+
+void DumpCTCODE ( FILE *f, uint indent, ctcode_t * ctcode )
+{
+    DASSERT(f);
+    DASSERT(ctcode);
+    indent = NormalizeIndent(indent);
+    const uint numindent = indent + 5;
+    char namebuf[TNAME_BUF_SIZE];
+
+
+    //--- statistics
+
+    fprintf(f,"\n%*sStatistics:\n\n",indent,"");
+    fprintf(f,"%*u racing cups defined.\n",numindent,ctcode->n_racing_cups);
+    fprintf(f,"%*u battle cups defined.\n",numindent,ctcode->n_battle_cups);
+    fprintf(f,"%*u tracks defined.\n",numindent,ctcode->n_tracks);
+    fprintf(f,"%*u track slots available.\n",numindent,ctcode->max_tracks);
+
+
+    //--- track reference
+
+    u8 count[CODE_MAX_TRACKS] = {0};
+    u8 usage[CODE_MAX_TRACKS] = {0};
+    uint invalid_track_ref = 0;
+    const uint max = ctcode->max_tracks;
+
+    uint cidx;
+    for ( cidx = 0; cidx < ctcode->n_racing_cups; cidx++ )
+    {
+	const ctcode_cup1_data_t *cd = ctcode->cup_racing + cidx;
+	DASSERT(cd);
+	uint ti;
+	for ( ti = 0; ti < 4; ti++ )
+	{
+	    uint tidx = be32(cd->track_id+ti);
+	    if ( tidx < max )
+	    {
+		count[tidx]++;
+		usage[tidx] |= 1;
+	    }
+	    else
+		invalid_track_ref++;
+	}
+    }
+
+    for ( cidx = 0; cidx < ctcode->n_battle_cups; cidx++ )
+    {
+	const ctcode_cup1_data_t *cd = ctcode->cup_battle + cidx;
+	DASSERT(cd);
+	uint ti;
+	for ( ti = 0; ti < 5; ti++ )
+	{
+	    uint tidx = be32(cd->track_id+ti);
+	    if ( tidx < max )
+	    {
+		count[tidx]++;
+		usage[tidx] |= 2;
+	    }
+	    else
+		invalid_track_ref++;
+	}
+    }
+
+    if (invalid_track_ref)
+	fprintf(f,"%*u invalid `cup to track´ references.\n",
+			numindent, invalid_track_ref );
+
+    fprintf(f,"\n%*sTrack usage:\n\n",indent,"");
+    uint tidx = 0;
+    while ( tidx < max )
+    {
+	uint end = tidx + 0x40;
+	if ( end > max )
+	    end = max;
+	fprintf(f,"%*s%02x-%02x:",indent+2,"",tidx,end-1);
+	uint i;
+	for ( i = 0; i < 0x40 && tidx < max; i++, tidx++ )
+	{
+	    if (!(i%8))
+		fputc(' ',f);
+	    if (!usage[tidx])
+	    {
+	     #if 1
+		fputc('-',f);
+	     #else
+		ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+		fputc( td->filename[0] && td->filename[1] ? '+' : '-', f );
+	     #endif
+	    }
+	    else if ( usage[tidx] == 1 )
+	    {
+		const uint n = count[tidx];
+		if ( n < 10 )
+		    fputc('0'+n,f);
+		else
+		    fputc('*',f);
+	    }
+	    else if ( usage[tidx] == 2 )
+	    {
+		const uint n = count[tidx] < 26 ? count[tidx] : 26;
+		fputc('a'-1+n,f);
+	    }
+	    else
+		fputc('?',f);
+	}
+	fputc('\n',f);
+    }
+
+
+    //--- memory dump
+
+    PrepareExportCTCODE(ctcode);
+
+    if ( ctcode->fform == FF_CT_TEXT )
+	fprintf(f,"\n%*sSections in virtual binary code:\n\n",indent,"");
+    else
+	fprintf(f,"\n%*sSections:\n\n",indent,"");
+
+    const ctcode_header_t *ch = &ctcode->ct_head;
+    const u32 n_sect = be32(&ch->n_sect);
+
+    uint sect;
+    for ( sect = 0; sect < n_sect; sect++ )
+    {
+	u32 off = be32(&ch->sect_info[sect].off);
+	if (!off)
+	    continue;
+	fprintf(f,"%*u: %6x : %s\n",
+		numindent, sect,
+		off, PrintID(ch->sect_info[sect].name,4,0) );
+    }
+
+
+    //--- hexdump of headers
+
+    if (long_count)
+    {
+	if ( ctcode->fform == FF_CT_TEXT )
+	    fprintf(f,"\n%*sHexdump of headers in virtual binary code:\n",indent,"");
+	else
+	    fprintf(f,"\n%*sHexdump of headers:\n",indent,"");
+
+	hexdump(f,indent,&ctcode->ct_head,sizeof(ctcode->ct_head),"CT-CODE Header");
+	hexdump(f,indent,ctcode->cup,sizeof(*ctcode->cup),"Section CUP1 Header");
+	hexdump(f,indent,ctcode->crs,sizeof(*ctcode->crs),"Section CRS1 Header");
+    }
+
+
+    //--- dump a track listing
+
+    if ( long_count > 2 )
+    {
+	fprintf(f,"\n%*sTechnical Track list:\n\n",indent,"");
+	CalcCupRefCTCODE(ctcode,false);
+
+	const ctcode_cupref_t *cr = ctcode->cupref;
+
+	uint tidx;
+	for ( tidx = 0; tidx < ctcode->max_tracks; tidx++, cr++ )
+	{
+	    if (cr->n_racing)
+	    {
+		const bmg_item_t *bi
+			= FindItemBMG(&opt_load_bmg,tidx+ctcode->ctb.track_name1.beg);
+		GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+		const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+
+		fprintf(f,"%*s%s [M=%s,P=%s,S=0x%02x,F=%s]\n",
+			indent+2,"", namebuf,
+			PrintMusicID(ntohl(td->music_id),false),
+			PrintPropertyID(ntohl(td->property_id),false),
+			tidx,
+			td->filename );
+	    }
+	}
+    }
+
+
+    //--- terminate
+
+    fputc('\n',f);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			setup ctcode parser		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const VarMap_t * SetupVarsCTCODE()
+{
+    static VarMap_t vm = {0};
+    if (!vm.used)
+	DefineMkwVars(&vm);
+    return &vm;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan CTCODE helpers		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanSetup ( ctcode_t *ctcode, ScanInfo_t * si )
+{
+    // nothing to do (ignore all yet)
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static char * ReplaceName ( char * str, ccp search, ccp replace )
+{
+    ccp pos = strstr(str,search);
+    if ( !pos || !*search )
+	return str;
+
+    char fb_buf[1000];
+    FastBuf_t *fb = InitializeFastBuf(fb_buf,sizeof(fb_buf));
+
+
+    const int search_len = strlen(search);
+    const int repl_len = strlen(replace);
+    char *src = str;
+    do
+    {
+	AppendFastBuf(fb,src,pos-src);
+	AppendFastBuf(fb,replace,repl_len);
+	src = (char*)pos + search_len;
+	pos = strstr(src,search);
+
+    } while (pos);
+
+    AppendFastBuf(fb,src,strlen(src));
+    FreeString(str);
+    return MoveFromFastBufString(fb);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int InsertTrackIntoCup ( ctcode_t *ctcode, uint tidx, bool hidden );
+
+static void AddWiimmCup ( ctcode_t *ctcode )
+{
+    PRINT("+++++ ADD WIIMM CUP +++++\n");
+    ctcode->add_wiimm_cup = 0;
+
+    uint slot;
+    for ( slot = LE_SLOT_RND_ALL; slot <= LE_SLOT_RND_NEW; slot++ )
+    {
+	ctcode->used_slot[slot] = 1;
+	if ( ctcode->n_tracks < slot+1 )
+	    ctcode->n_tracks = slot+1;
+
+	ctcode_crs1_data_t *td = ctcode->crs->data + slot;
+	td->cup_id = htonl( InsertTrackIntoCup(ctcode,slot,false) );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int InsertTrackIntoCup ( ctcode_t *ctcode, uint tidx, bool hidden )
+{
+    DASSERT(ctcode);
+    DASSERT( tidx < ctcode->max_tracks );
+
+// [[2do]] [[hidden]]
+
+    if (hidden)
+    {
+	ctcode->tracks_defined++;
+	return HIDDEN_CUP;
+    }
+
+    uint cidx = ctcode->n_racing_cups;
+    if (ctcode->track_of_cup)
+    {
+	DASSERT( cidx > 0 );
+	DASSERT( ctcode->track_of_cup < 4 );
+	cidx--;
+    }
+    else if ( ctcode->add_wiimm_cup
+		&& ctcode->ctb.le_phase
+		&& cidx == 8 )
+    {
+	AddWiimmCup(ctcode);
+	// redo this function again
+	return InsertTrackIntoCup(ctcode,tidx,hidden);
+    }
+    else
+    {
+	if ( cidx == ctcode->max_racing_cups )
+	{
+	    ERROR0(ERR_WARNING,"No more track cups available!\n");
+	    return -1;
+	}
+	ctcode->n_racing_cups++;
+
+	char buf[20];
+	ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	ccp cname = ctcode->next_cup_name;
+	if ( cname && *cname )
+	    SetName16(cd->name,cname);
+	else
+	{
+	    const bmg_item_t *bi
+		= FindItemBMG(&opt_load_bmg,ctcode->ctb.rcup_name.beg+cidx);
+	    if ( bi && bi->len )
+	    {
+		memset(cd->name,0,sizeof(cd->name));
+		const uint len = bi->len < CT_NAME_SIZE-1 ? bi->len : CT_NAME_SIZE-1;
+		memcpy(cd->name,bi->text,len*sizeof(*cd->name));
+	    }
+	    else
+	    {
+		snprintf(buf,sizeof(buf),"Cup %02x",cidx);
+		SetName16(cd->name,buf);
+	    }
+	}
+	FreeString(ctcode->next_cup_name);
+	ctcode->next_cup_name = 0;
+    }
+
+    noPRINT("INSERT TRACK %u INTO CUP %u.%u/%u\n",
+		tidx, cidx, ctcode->track_of_cup, ctcode->max_racing_cups );
+
+    ctcode->cup_racing[cidx].track_id[ctcode->track_of_cup++] = htonl(tidx);
+    if ( ctcode->track_of_cup == 4 )
+	ctcode->track_of_cup = 0;
+
+    ctcode->tracks_defined++;
+
+    return cidx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ctcode_crs1_data_t * GetNextTrackSlot ( ctcode_t *ctcode, bool hidden )
+{
+    DASSERT(ctcode);
+
+    //--- next_slot available
+
+    uint slot = 0;
+    while (ctcode->n_next_slot)
+    {
+	slot = ctcode->next_slot[--ctcode->n_next_slot];
+	if ( !ctcode->used_slot[slot] || ctcode->force_slot[ctcode->n_next_slot] )
+	{
+	 found:
+	    ctcode->used_slot[slot] = 1;
+	    if ( ctcode->n_tracks < slot+1 )
+		ctcode->n_tracks = slot+1;
+
+	    ctcode_crs1_data_t *td = ctcode->crs->data + slot;
+	    td->cup_id = htonl( InsertTrackIntoCup(ctcode,slot,hidden) );
+	    return td;
+	}
+    }
+
+    //--- search first free slot
+
+    for ( slot = 0; slot < ctcode->max_tracks; slot++ )
+	if (!ctcode->used_slot[slot])
+	    goto found;
+
+    ERROR0(ERR_WARNING,"No more track slots available!\n");
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ctcode_crs1_data_t * GetNextArenaSlot
+	( ctcode_t *ctcode, uint prop, ScanInfo_t * si )
+{
+    if (!ctcode->ctb.le_phase)
+    {
+	static int err_done = 0;
+	if (!err_done++)
+	    ERROR0(ERR_WARNING,"Battle arenas only supported for LE-CODE!\n");
+	return 0;
+    }
+
+    const uint arena = prop - MKW_N_TRACKS;
+    if ( arena >= MKW_N_ARENAS )
+    {
+	ERROR0(ERR_WARNING,
+		"Invalid arena slot 0x%02x, use A11..A25 (0x%x..0x%x) instead: %s @%u\n",
+		prop, MKW_N_TRACKS, MKW_N_TRACKS + MKW_N_ARENAS - 1,
+		si->cur_file->name, si->cur_file->line );
+	return 0;
+    }
+
+    if (ctcode->arena_usage[arena])
+    {
+	ERROR0(ERR_WARNING,
+		"Arena slot 0x%02x already used: %s @%u\n",
+		prop, si->cur_file->name, si->cur_file->line );
+	return 0;
+    }
+    ctcode->arena_usage[arena]++;
+    ctcode->assigned_arenas++;
+
+    return ctcode->crs->data + prop;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRTL_Option ( ctcode_t *ctcode, ScanInfo_t * si )
+{
+    DASSERT(ctcode);
+    DASSERT(si);
+
+    ScanFile_t *sf = si->cur_file;
+    ccp start = sf->ptr;
+
+    while ( NextCharSI(si,false) == '%' )
+	sf->ptr++;
+
+    char name[50];
+    const uint namelen = ScanNameSI(si,name,sizeof(name),true,true,0);
+    if (!namelen)
+    {
+	if ( si->no_warn <= 0 )
+	{
+	    ccp eol = FindNextLineFeedSI(si,true);
+	    ERROR0(ERR_WARNING,
+			"Missing name for option: [%s @%u]: %.*s\n",
+			sf->name, sf->line, (int)(eol - start), start );
+	}
+	return ERR_WARNING;
+    }
+
+    if ( NextCharSI(si,false) == '=' )
+	sf->ptr++;
+
+    if (!strcmp(name,"LE-PHASE")) // [[obsolete]] since 2019-12
+    {
+	long num;
+	enumError err = ScanUValueSI(si,&num,false);
+	if (err)
+	    return err;
+	ctcode->use_lecode = num > 0;
+	PRINT("%%LE-PHASE: lecode=%d\n",ctcode->use_lecode);
+    }
+    else if (!strcmp(name,"LE-FLAGS"))
+    {
+	long num;
+	enumError err = ScanUValueSI(si,&num,false);
+	if (err)
+	    return err;
+	ctcode->use_le_flags = num > 0;
+	PRINT("%%LE-FLAGS = %d\n",ctcode->use_le_flags);
+    }
+    else if (!strcmp(name,"REPLACE-AT"))
+    {
+	long num;
+	enumError err = ScanUValueSI(si,&num,false);
+	if (err)
+	    return err;
+	ctcode->replace_at = num > 0;
+	PRINT("%%REPLACE-AT = %d\n",ctcode->use_le_flags);
+    }
+    else if (!strcmp(name,"WIIMM-CUP"))
+    {
+	long num;
+	enumError err = ScanUValueSI(si,&num,false);
+	if (err)
+	    return err;
+	ctcode->add_wiimm_cup = num > 0;
+	PRINT("%%WIIMM-CUP = %d\n",ctcode->use_le_flags);
+    }
+    else
+    {
+	if ( si->no_warn <= 0 )
+	    ERROR0(ERR_WARNING,
+			"Unknown option [%s @%u]: %s\n",
+			sf->name, sf->line, name );
+	return ERR_WARNING;
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRTL_Nintendo ( ctcode_t *ctcode, ScanInfo_t * si )
+{
+    DASSERT(ctcode);
+    DASSERT(si);
+
+    if (ctcode->tracks_defined)
+    {
+	ccp eol = FindNextLineFeedSI(si,true);
+	ScanFile_t *sf = si->cur_file;
+	ERROR0(ERR_WARNING,
+		"The 'N' command can only be used before"
+		" the first track definition [%s @%u]: %.*s\n",
+		sf->name, ctcode->tracks_defined /*sf->line*/, (int)(eol - sf->ptr), sf->ptr );
+	GotoEolSI(si);
+	return ERR_WARNING;
+    }
+
+    DEFINE_VAR(val);
+    enumError err = ScanExprSI(si,&val);
+    if (err)
+	return err;
+    uint mode = GetIntV(&val);
+    const uint flag_hex = mode & RTL_N_F_HEX;
+    const uint flag_wii = mode & RTL_N_F_WII;
+
+    struct coldef_t { uint flag; const char name[8]; };
+    static const struct coldef_t coltab[] =
+    {
+	{ RTL_N_F_RED1,		"red1" },
+	{ RTL_N_F_RED2,		"red2" },
+	{ RTL_N_F_RED3,		"red3" },
+	{ RTL_N_F_RED4,		"red4" },
+	{ RTL_N_F_YELLOW,	"yellow" },
+	{ RTL_N_F_GREEN,	"green" },
+	{ RTL_N_F_BLUE1,	"blue1" },
+	{ RTL_N_F_BLUE2,	"blue2" },
+	{ RTL_N_F_WHITE,	"white" },
+	{ RTL_N_F_CLEAR,	"clear" },
+
+	{ 0, "" }
+    };
+
+    ccp col = 0;
+    static const struct coldef_t *colptr;
+    for ( colptr = coltab; colptr->flag; colptr++ )
+    {
+	if ( mode & colptr->flag )
+	{
+	    col = colptr->name;
+	    break;
+	}
+    }
+
+    mode &= RTL_N_M_MODE;
+    if ( mode == RTL_N_HIDE || mode == RTL_N_SHOW || mode == RTL_N_SWAP )
+    {
+	const TrackInfo_t *info = track_info;
+	ctcode_crs1_data_t *td = ctcode->crs->data;
+	const u32 *tpos = mode == RTL_N_SWAP ? track_pos_swap : track_pos;
+
+	uint ti;
+	for ( ti = 0; ti < MKW_N_TRACKS; ti++, info++, td++ )
+	{
+	    //--- here we insert the correct cup index ...
+
+	    const uint tidx = tpos[ti];
+	    InsertTrackIntoCup(ctcode,tidx,false);
+
+	    //--- and here we fill the track data independent of the cup index
+
+	    td->music_id	= htonl(info->music_id);
+	    td->property_id	= htonl(ti);
+	    td->cup_id		= htonl(info->def_slot/10-1);
+
+	    char buf1[50], buf2[80];
+
+	    ccp name = info->name_en;
+	    bool have_prefix = info->def_slot >= 50;
+	    if ( !have_prefix && flag_wii )
+	    {
+		snprintf(buf1,sizeof(buf1),"Wii %s",name);
+		name = buf1;
+		have_prefix = true;
+	    }
+
+	    if ( have_prefix && col )
+	    {
+		ccp space = strchr(name,' ');
+		if (space)
+		{
+		    snprintf(buf2,sizeof(buf2),"\\c{%s}%.*s \\c{OFF}%s",
+				col, (int)(space-name), name, space+1 );
+		    name = buf2;
+		}
+	    }
+	    SetName16(td->tname,name);
+	    SetTrackFile(ctcode,ti,info->track_fname);
+
+	    if (flag_hex)
+		snprintf(td->filename,sizeof(td->filename),"%02x",ti);
+	    else
+		StringCopyS(td->filename,sizeof(td->filename),info->track_fname);
+	}
+	memset(ctcode->used_slot,1,MKW_N_TRACKS);
+	ctcode->tracks_defined = MKW_N_TRACKS;
+	if ( mode == RTL_N_HIDE )
+	    ctcode->n_racing_cups = 0;
+	ctcode->cmd_n_used = true;
+    }
+
+
+    if ( ctcode->ctb.le_phase )
+    {
+	const TrackInfo_t *info = arena_info;
+	uint ti;
+	for ( ti = MKW_N_TRACKS; ti < MKW_N_TRACKS+MKW_N_ARENAS; ti++, info++ )
+	    SetTrackFile(ctcode,ti,info->track_fname);
+
+	// special files
+	SetTrackFile(ctcode,0x36,"ring_mission");
+	SetTrackFile(ctcode,0x37,"winningrun_demo");
+	SetTrackFile(ctcode,0x38,"loser_demo");
+	SetTrackFile(ctcode,0x39,"draw_demo");
+	SetTrackFile(ctcode,0x3a,"ending_demo");
+    }
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRTL_Slot
+	( ctcode_t *ctcode, ScanInfo_t * si, bool mark_reserved )
+{
+    DASSERT(ctcode);
+    DASSERT(si);
+
+    ScanFile_t *sf = si->cur_file;
+    DASSERT(sf);
+    sf->disable_comma++;
+
+    enumError err = ERR_OK;
+
+    uint idx = ctcode->max_tracks;
+    for(;;)
+    {
+	char ch = NextCharSI(si,false);
+	if (!ch)
+	    break;
+
+	if ( ch == ',' )
+	{
+	    sf->ptr++;
+	    continue;
+	}
+
+	long n1, n2;
+	err = ScanUValueSI(si,&n1,0);
+	if (err)
+	    break;
+
+	if ( NextCharSI(si,false) == ':' )
+	{
+	    sf->ptr++;
+	    err = ScanUValueSI(si,&n2,0);
+	    if (err)
+		break;
+	}
+	else
+	    n2 = n1;
+
+	const bool force = NextCharSI(si,false) == '!';
+	if (force)
+	     sf->ptr++;
+
+	if ( n1 < 0 )
+	    n1 = 0;
+	if ( ++n2 > ctcode->max_tracks )
+	    n2 = ctcode->max_tracks;
+	noPRINT("SLOT: %02lx:%02lx = %lu:%lu%s\n",n1,n2,n1,n2,force ? " /FORCE" : "");
+
+	if ( n1 >= n2 )
+	    continue;
+
+	if (mark_reserved)
+	{
+	    if (force)
+		memset(ctcode->used_slot+n1,2,n2-n1);
+	    else
+		for ( ; n1 < n2; n1++ )
+		    if (!ctcode->used_slot[n1])
+			ctcode->used_slot[n1] = 2;
+	}
+	else
+	    for ( ; idx > 0 && n1 < n2; n1++ )
+	    {
+		idx--;
+		ctcode->next_slot[idx]  = n1;
+		ctcode->force_slot[idx] = force;
+	    }
+    }
+
+    if (!mark_reserved)
+    {
+	ctcode->n_next_slot = ctcode->max_tracks - idx;
+	if (ctcode->n_next_slot)
+	{
+	    memmove(ctcode->next_slot,ctcode->next_slot+idx,ctcode->n_next_slot);
+	    memmove(ctcode->force_slot,ctcode->force_slot+idx,ctcode->n_next_slot);
+	}
+    }
+
+    sf->disable_comma--;
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRTL_Track
+	( ctcode_t *ctcode, ScanInfo_t * si, bool is_arena, bool hidden )
+{
+    DASSERT(ctcode);
+    DASSERT(si);
+    //ScanFile_t *sf = si->cur_file;
+    //DASSERT(sf);
+
+    char buf[100];
+
+
+    //--- scan music id
+
+    ulong music_id;
+    enumError err = ScanUValueSI(si,(long*)&music_id,0);
+    if (err)
+	return err;
+
+    if ( NextCharSI(si,false) == '!' )
+	si->cur_file->ptr++;
+    else
+    {
+	if ( music_id < MKW_N_TRACKS )
+	    music_id = track_info[music_id].music_id;
+	else if ( music_id < MKW_N_TRACKS + MKW_N_ARENAS )
+	    music_id = arena_info[music_id-MKW_N_TRACKS].music_id;
+
+	if ( MusicID2TrackId(music_id,music_id,-1) == -1 )
+	    music_id = track_info[0].music_id;
+    }
+    SkipCharSI(si,';');
+
+
+    //--- scan property id
+
+    ulong property_id;
+    err = ScanUValueSI(si,(long*)&property_id,0);
+    if (err)
+	return err;
+
+    if ( NextCharSI(si,false) == '!' )
+	si->cur_file->ptr++;
+    else if (!is_arena)
+	property_id &= 0x1f;
+    SkipCharSI(si,';');
+
+
+    //--- scan le-flags
+
+    le_flags_t le_flags = 0;
+    if (ctcode->use_le_flags)
+    {
+	long flags;
+	err = ScanUValueSI(si,&flags,0);
+	if (err)
+	    return err;
+	le_flags = flags;
+	SkipCharSI(si,';');
+    }
+
+
+    //--- scan track_file, track_string and track_ident => create fname
+
+    char *track_file = 0, *track_string = 0, *track_ident = 0;
+    char fname[100];
+
+    err = ConcatStringsSI(si,&track_file,0);
+    if (err)
+    {
+      abort:
+	FreeString(track_file);
+	FreeString(track_string);
+	FreeString(track_ident);
+	return err;
+    }
+
+
+    //--- setup 'fname' and remove unwanted characters
+
+    *fname = 0;
+    if (track_file)
+    {
+
+	char *src = track_file, *dest = fname;
+	while ( *src && dest < fname+sizeof(fname) )
+	{
+	    int ch = *src++;
+	    if ( isalnum(ch) || strchr("+-._",ch) )
+		*dest++ = ch;
+	}
+	*dest = 0;
+    }
+
+    if ( NextCharSI(si,false) == ';' )
+    {
+	SkipCharSI(si,';');
+	err = ConcatStringsSI(si,&track_string,0);
+	if (err)
+	    goto abort;
+
+	if ( NextCharSI(si,false) == ';' )
+	{
+	    SkipCharSI(si,';');
+	    err = ConcatStringsSI(si,&track_ident,0);
+	    if (err)
+		goto abort;
+	}
+    }
+
+    CheckEolSI(si);
+
+
+    //--- insert new track
+
+    ctcode_crs1_data_t *td = is_arena
+				? GetNextArenaSlot(ctcode,property_id,si)
+				: GetNextTrackSlot(ctcode,hidden);
+    if (!td)
+	return ERR_WARNING;
+
+    const int tidx = td - ctcode->crs->data;
+    if (ctcode->replace_at)
+    {
+	PRINT(">>> REPLACE:  %s\n",track_string);
+	snprintf(buf,sizeof(buf),"%03X",tidx);
+	track_string = ReplaceName(track_string,"@SLOT@",buf);
+	track_string = ReplaceName(track_string,"@@","@");
+	PRINT(">>> REPLACED: %s\n",track_string);
+    }
+
+    SetTrackFile(ctcode,tidx,track_file);
+    SetTrackString(ctcode,tidx,track_string);
+    SetTrackIdentifier(ctcode,tidx,track_ident);
+
+    td->music_id    = htonl(music_id);
+    td->property_id = htonl(property_id);
+
+    ctcode->property[tidx] = property_id;
+    ctcode->music[tidx]	   = music_id;
+    ctcode->le_flags[tidx] = le_flags;
+    ctcode->hidden[tidx]   = hidden != 0;
+
+    if (!*fname)
+    {
+	if (ctcode->use_lecode)
+	    snprintf(fname,sizeof(fname),"%03x",tidx);
+	else
+	    snprintf(fname,sizeof(fname),"slot_%02x",tidx);
+    }
+    StringCopyS(td->filename,sizeof(td->filename),fname);
+
+    FreeString(track_file);
+    FreeString(track_string);
+    FreeString(track_ident);
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRacingTrackList ( ctcode_t *ctcode, ScanInfo_t * si )
+{
+    DASSERT(ctcode);
+    DASSERT(si);
+
+    ctcode->use_le_flags = 0;
+
+    enumError max_err = ERR_OK;
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	ScanFile_t *sf = si->cur_file;
+	DASSERT(sf);
+
+	enumError err = ERR_OK;
+	switch (ch)
+	{
+	    case '%':
+		err = ScanRTL_Option(ctcode,si);
+		break;
+
+	    case 'n':
+	    case 'N':
+		sf->ptr++;
+		err = ScanRTL_Nintendo(ctcode,si);
+		break;
+
+	    case 'c':
+	    case 'C':
+		ctcode->track_of_cup = 0;
+		sf->ptr++;
+		err = ConcatStringsSI(si,&ctcode->next_cup_name,0);
+		break;
+
+	    case 's':
+	    case 'S':
+		sf->ptr++;
+		err = ScanRTL_Slot(ctcode,si,false);
+		break;
+
+	    case 'x':
+	    case 'X':
+		sf->ptr++;
+		err = ScanRTL_Slot(ctcode,si,true);
+		break;
+
+	    case 't':
+	    case 'T':
+		sf->ptr++;
+		err = ScanRTL_Track(ctcode,si,false,false);
+		break;
+
+	    case 'h':
+	    case 'H':
+		sf->ptr++;
+		err = ScanRTL_Track(ctcode,si,false,true);
+		break;
+
+	    case 'a':
+	    case 'A':
+		sf->ptr++;
+		err = ScanRTL_Track(ctcode,si,true,false);
+		break;
+
+	    default:
+		{
+		    ccp eol = FindNextLineFeedSI(si,true);
+		    err = ERROR0(ERR_WARNING,
+			"Line ignored [%s @%u]: %.*s\n",
+			sf->name, sf->line, (int)(eol - sf->ptr), sf->ptr );
+		}
+		break;
+	}
+	CheckEolSI(si);
+	if ( max_err < err )
+	     max_err = err;
+    }
+
+    CheckLEFlagsUsage(ctcode);
+    return max_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ScanTextCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanSetup ( ctcode_t *ctcode, ScanInfo_t * si );
+static enumError ScanRacingTrackList ( ctcode_t *ctcode, ScanInfo_t * si );
+
+//-----------------------------------------------------------------------------
+
+enumError ScanTextCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size	// size of 'data'
+)
+{
+    DASSERT(ctcode);
+
+    const uint CTCODE_VERSION = 1;
+
+    if (ct_mode)
+	InitializeCTCODE(ctcode,ct_mode);
+    ResetDataCTCODE(ctcode,true);
+
+
+    //--- setup data
+
+    ctcode->n_next_slot = 0;
+    ctcode->track_of_cup = 0;
+    //ctcode->n_tracks = MKW_ARENA_END;
+    FreeString(ctcode->next_cup_name);
+    ctcode->next_cup_name = 0;
+    //HEXDUMP16(6,0,ctcode->used_slot,sizeof(ctcode->used_slot));
+
+
+    //--- setup parser
+
+    enum { SECT_SETUP, SECT_RACING_TRACK_LIST, N_SECT };
+    const KeywordTab_t sect_names[] =
+    {
+	    { SECT_SETUP,		"SETUP",		0, 0 },
+	    { SECT_RACING_TRACK_LIST,	"RACING-TRACK-LIST",	0, 0 },
+	    { 0,0,0,0 }
+    };
+
+    ScanInfo_t si;
+    InitializeSI(&si,data,data_size,ctcode->fname,CTCODE_VERSION);
+    si.predef = SetupVarsCTCODE();
+
+
+    //--- main loop
+
+    enumError max_err = ERR_OK;
+
+    for(;;)
+    {
+	char ch = NextCharSI(&si,true);
+	if (!ch)
+	    break;
+
+	if ( ch != '[' )
+	{
+	    NextLineSI(&si,true,false);
+	    continue;
+	}
+	ResetLocalVarsSI(&si,CTCODE_VERSION);
+
+	si.cur_file->ptr++;
+	char name[20];
+	ScanNameSI(&si,name,sizeof(name),true,true,0);
+
+	int abbrev_count;
+	const KeywordTab_t *cmd = ScanKeyword(&abbrev_count,name,sect_names);
+	if ( !cmd || abbrev_count )
+	    continue;
+	NextLineSI(&si,false,false);
+	PRINT("--> %-6s #%-4u |%.3s|\n",cmd->name1,si.cur_file->line,si.cur_file->ptr);
+
+	if ( cmd->id < 0 || cmd->id > N_SECT )
+	    continue;
+
+	enumError err = ERR_OK;
+	switch (cmd->id)
+	{
+	    case SECT_SETUP:
+		PRINT("SCAN [SETUP]\n");
+		err = ScanSetup(ctcode,&si);
+		break;
+
+	    case SECT_RACING_TRACK_LIST:
+		PRINT("SCAN [RACING-TRACK-LIST]\n");
+		err = ScanRacingTrackList(ctcode,&si);
+		break;
+
+	    default:
+		// ignore all other section without any warnings
+		break;
+	}
+
+	if ( max_err < err )
+	     max_err = err;
+    }
+
+ #if HAVE_PRINT0
+    printf("VAR DUMP/GLOBAL:\n");
+    DumpVarMap(stdout,3,&si.gvar,false);
+ #endif
+
+    CheckLevelSI(&si);
+    if ( max_err < ERR_WARNING && si.total_err )
+	max_err = ERR_WARNING;
+    PRINT("ERR(ScanTextCTCODE) = %u (errcount=%u)\n", max_err, si.total_err );
+    ResetSI(&si);
+
+// [[file-name]]
+    UsePatchingListBMG(&ctcode->track_string);
+    CalcCupRefCTCODE(ctcode,true);
+    return max_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ScanRawCTCODE()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int scan_raw_ctcode_func
+(
+    struct szs_iterator_t	*it,	// iterator struct with all infos
+    bool			term	// true: termination hint
+)
+{
+    DASSERT(it);
+    DASSERT(it->szs);
+    ctcode_t *ctcode = it->param;
+    DASSERT(ctcode);
+
+    noPRINT("--> %3d,%3d term=%u size=%4u : %s\n",
+	it->group, it->entry, term, it->size, it->path );
+    if ( term || it->size <= 0 )
+	return 0;
+
+    const u8 *data = it->szs->data + it->off;
+    if (!memcmp(data,"CUP1",4))
+    {
+	const ctcode_cup1_head_t *hd = (ctcode_cup1_head_t*)data;
+	uint size = be32(&hd->size);
+	if ( size > it->size )
+	    size = it->size;
+
+	const uint nc1  = be32(&hd->n_racing_cups);
+	const uint nc2  = be32(&hd->n_battle_cups);
+
+	if ( it->off + size <= it->szs->size )
+	{
+	 #if USE_NEW_CONTAINER_CTC
+	    PRINT("CTCODE/CUP1 found, SIZEx=%x/%x/%x, Nx=%x+%x, Nd=%d+%d, IN-C=%d\n",
+		size, be32(&hd->size), it->size,
+		nc1, nc2, nc1, nc2, InContainerP(&ctcode->container,data) );
+	 #else
+	    PRINT("CTCODE/CUP1 found, SIZEx=%x/%x/%x, Nx=%x+%x, Nd=%d+%d, IN-C=%d\n",
+		size, be32(&hd->size), it->size,
+		nc1, nc2, nc1, nc2, InDataContainer(ctcode->old_container,data) );
+	 #endif
+
+	    if (ctcode->cup_alloced)
+		FREE(ctcode->cup);
+
+	 #if USE_NEW_CONTAINER_CTC
+	    if (InContainerP(&ctcode->container,data))
+	 #else
+	    if (InDataContainer(ctcode->old_container,data))
+	 #endif
+	    {
+		ctcode->cup_alloced = false;
+		ctcode->cup = (ctcode_cup1_head_t*)data;
+	    }
+	    else
+	    {
+		ctcode->cup_alloced = true;
+		ctcode->cup = MEMDUP(data,size);
+	    }
+	    ctcode->cup_size = size;
+
+	    ctcode->cup_racing = ctcode->cup->data;
+	    ctcode->cup_battle = ctcode->cup_racing + nc1;
+
+	    ctcode->n_racing_cups   = nc1;
+	    ctcode->max_racing_cups = nc1;
+	    ctcode->n_battle_cups   = nc2;
+
+	    const uint max_cups	= ( data+size - (u8*)ctcode->cup_racing )
+				/ sizeof(ctcode_cup1_data_t);
+
+	    ctcode->max_battle_cups = max_cups - nc1;
+	    if ( ctcode->max_battle_cups > 2 )
+		ctcode->max_battle_cups = 2;
+	    if ( ctcode->max_battle_cups < nc2 )
+		ctcode->max_battle_cups = nc2;
+
+	    if ( max_cups > nc1 + ctcode->max_battle_cups )
+		ctcode->n_unused_cups = max_cups - nc1 - ctcode->max_battle_cups;
+
+	    PRINT("STAT/CUP: racing: %u/%u, battle: %u/%u, unused: %u\n",
+			ctcode->n_racing_cups, ctcode->max_racing_cups,
+			ctcode->n_battle_cups, ctcode->max_battle_cups,
+			ctcode->n_unused_cups );
+	}
+    }
+    else if (!memcmp(data,"CRS1",4))
+    {
+	const ctcode_crs1_head_t *hd = (ctcode_crs1_head_t*)data;
+	uint size = be32(&hd->size);
+	if ( size > it->size )
+	    size = it->size;
+
+	const uint nt   = be32(&hd->n_tracks);
+
+	if ( it->off + size <= it->szs->size )
+	{
+	 #if USE_NEW_CONTAINER_CTC
+	    PRINT("CTCODE/CRS1 found, SIZEx=%x/%x/%x, Nxd=%x,%d, IN-C=%d\n",
+		size, be32(&hd->size), it->size,
+		nt, nt, InContainerP(&ctcode->container,data) );
+	 #else
+	    PRINT("CTCODE/CRS1 found, SIZEx=%x/%x/%x, Nxd=%x,%d, IN-C=%d\n",
+		size, be32(&hd->size), it->size,
+		nt, nt, InDataContainer(ctcode->old_container,data) );
+	 #endif
+
+	    if (ctcode->crs_alloced)
+		FREE(ctcode->crs);
+
+	 #if USE_NEW_CONTAINER_CTC
+	    if (InContainerP(&ctcode->container,data))
+	 #else
+	    if (InDataContainer(ctcode->old_container,data))
+	 #endif
+	    {
+		ctcode->crs_alloced = false;
+		ctcode->crs = (ctcode_crs1_head_t*)data;
+	    }
+	    else
+	    {
+		ctcode->crs_alloced = true;
+		ctcode->crs = MEMDUP(data,size);
+	    }
+	    ctcode->crs_size = size;
+
+	    ctcode->n_tracks = nt;
+	    ctcode->max_tracks = ( data + size - (u8*)ctcode->crs->data )
+			       / sizeof(ctcode_crs1_data_t);
+
+	    PRINT("STAT/TRACK: %u/%u\n", ctcode->n_tracks, ctcode->max_tracks );
+	}
+    }
+    MARK_USED(ctcode);
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int IterateFilesCTCODE
+(
+    szs_iterator_t	*it,		// iterator struct with all infos
+    bool		multi_img	// false: mipmaps, true: multi images
+)
+{
+    DASSERT(it);
+    DASSERT(it->func_it);
+    szs_file_t * szs = it->szs;
+    DASSERT(szs);
+    const u8 * data = szs->data;
+    DASSERT(data);
+
+    if ( !data || szs->size < sizeof(ctcode_header_t) )
+	return -1;
+
+    const ctcode_header_t *ch = (ctcode_header_t*)data;
+    const u32 n_sect = be32(&ch->n_sect);
+    const u32 size = be32(&ch->size);
+    const u32 min_data_off = sizeof(ctcode_header_t)
+			   + n_sect * sizeof(ctcode_sect_info_t)
+			   - sizeof(ch->sect_info);
+    if	(  n_sect < 2 || szs->size < min_data_off || szs->size < size )
+	return -1;
+
+    it->no_recurse++;
+
+    it->index	= 0;
+    it->off	= 0;
+    it->size	= min_data_off;
+    it->is_dir	= 0;
+    StringCopyS(it->path,sizeof(it->path),".CTCODE.header");
+    int stat = it->func_it(it,false);
+
+    uint sect;
+    for ( sect = 0; sect < n_sect && !stat; sect++ )
+    {
+	u32 off = be32(&ch->sect_info[sect].off);
+	if ( off < min_data_off || off >= szs->size )
+	    continue;
+
+	u32 max_off = szs->size;
+	if ( sect+1 < n_sect )
+	{
+	    const u32 next_off = be32(&ch->sect_info[sect+1].off);
+	    noPRINT("NEXT-OFF: %x\n",next_off);
+	    if ( next_off > off && max_off > next_off )
+		max_off = next_off;
+	}
+
+	it->index++;
+	it->off	= off;
+	it->size = max_off - off;
+	ccp name = ch->sect_info[sect].name;
+	if ( off + 8 < szs->size )
+	{
+	    u32 *ptr = (u32*)(data + off);
+	    const u32 new_size = be32(ptr+1);
+	    if ( it->size > new_size )
+		it->size = new_size;
+	    name = (ccp)ptr;
+	}
+	snprintf(it->path,sizeof(it->path),
+			"ctcode-%i-%s.bin", sect, PrintID(name,4,0));
+	noPRINT("MAX-OFF: %x..%x [%x] %x/%zx / sect %u/%u : %s\n",
+			off, off+it->size, it->size,
+			max_off, szs->size, sect, n_sect, it->path );
+	stat = it->func_it(it,false);
+    }
+
+    return stat;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void ScanSetupCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size,	// size of 'data'
+    ContainerCTC_t	* cdata		// NULL or container-data
+)
+{
+    DASSERT(ctcode);
+
+ #if USE_NEW_CONTAINER_CTC // ---------------------------------------
+
+    if (ct_mode)
+	InitializeCTCODE(ctcode,ct_mode);
+    else
+	ResetDataCTCODE(ctcode,false);
+
+    CatchContainerData(&ctcode->container,0,cdata);
+    AssignContainer(&ctcode->container,0,data,data_size,CPM_COPY);
+  #ifdef TEST
+    DumpInfoContainer(stdlog,collog,2,"CTC: ",&ctcode->container,0);
+  #endif
+
+ #else // !USE_NEW_CONTAINER_CTC // ---------------------------------
+
+    if (ct_mode)
+	InitializeCTCODE(ctcode,ct_mode);
+    else
+	ResetDataCTCODE(ctcode,false);
+    ctcode->old_container = cdata;
+
+ #endif // !USE_NEW_CONTAINER_CTC // --------------------------------
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanRawCTCODE_helper
+(
+    ctcode_t		* ctcode,	// initialized CTCODE data structure
+    const void		* data,		// data to scan
+    uint		data_size	// size of 'data'
+)
+{
+    DASSERT(ctcode);
+    DASSERT( IsValidCTCODE(data,data_size,data_size,0) < VALID_ERROR );
+
+    memcpy(&ctcode->ct_head,data,sizeof(ctcode->ct_head));
+
+    //--- scan CTCODE header & sections
+
+    cut_iter_func[FF_CT1_DATA] = IterateFilesCTCODE; // enable CTCODE support
+// [[fname-]]
+    IterateFilesData( data, data_size, scan_raw_ctcode_func, ctcode, FF_CT1_DATA, 0 );
+    CalcCupRefCTCODE(ctcode,true);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanRawCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size,	// size of 'data'
+    ContainerCTC_t	* cdata		// NULL or container-data
+)
+{
+    DASSERT(ctcode);
+    ScanSetupCTCODE(ctcode,ct_mode,data,data_size,cdata);
+
+    if ( IsValidCTCODE(data,data_size,data_size,ctcode->fname) >= VALID_ERROR )
+    {
+	return ERROR0(ERR_INVALID_DATA,
+		"Invalid CT-CODE file: %s\n", ctcode->fname ? ctcode->fname : "?");
+    }
+
+    return ScanRawCTCODE_helper(ctcode,data,data_size);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanTexCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size,	// size of 'data'
+    ContainerCTC_t	* cdata		// NULL or container-data
+)
+{
+    DASSERT(ctcode);
+    ScanSetupCTCODE(ctcode,ct_mode,data,data_size,cdata);
+
+    if ( IsValidTEXCT(data,data_size,data_size,0,ctcode->fname) >= VALID_ERROR )
+    {
+	return ERROR0(ERR_INVALID_DATA,
+		"Invalid TEX+CT file: %s\n", ctcode->fname ? ctcode->fname : "?");
+    }
+
+    const brsub_header_t *bh = (brsub_header_t*)data;
+    const u32 img_off = be32(bh->grp_offset);
+    return ScanRawCTCODE_helper( ctcode,
+				data + CT_CODE_TEX_OFFSET,
+				img_off - CT_CODE_TEX_OFFSET );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int iter_brres_ctcode
+(
+    struct szs_iterator_t	*it,	// iterator struct with all infos
+    bool			term	// true: termination hint
+)
+{
+    DASSERT(it);
+    if (term)
+	return 0;
+
+    szs_file_t * szs = it->szs;
+    DASSERT(szs);
+    const u8 * data = szs->data;
+    DASSERT(data);
+    data += it->off;
+
+    ctcode_t *ctcode = it->param;
+    DASSERT(ctcode);
+
+    noPRINT("%6x %6x : %02x %02x %02x %02x : %s\n",
+		it->off, it->size,
+		data[0],  data[1],  data[2],  data[3], it->name );
+
+    if ( IsValidTEXCT(data,it->size,it->size,0,ctcode->fname) <  VALID_ERROR )
+    {
+	const brsub_header_t *bh = (brsub_header_t*)data;
+	const u32 img_off = be32(bh->grp_offset);
+	ScanRawCTCODE_helper( ctcode,
+				data + CT_CODE_TEX_OFFSET,
+				img_off - CT_CODE_TEX_OFFSET );
+	return 1;
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanBrresCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size,	// size of 'data'
+    ContainerCTC_t	* cdata		// NULL or container-data
+)
+{
+    DASSERT(ctcode);
+    ScanSetupCTCODE(ctcode,ct_mode,data,data_size,cdata);
+
+    szs_file_t szs;
+    AssignSZS(&szs,true,(void*)data,data_size,false,FF_BRRES,0);
+    IterateFilesSZS(&szs,iter_brres_ctcode,ctcode,false,0,-1,SORT_NONE);
+    ResetSZS(&szs);
+
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			ScanLEBinCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanLEBinCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size	// size of 'data'
+)
+{
+    DASSERT(ctcode);
+
+    if (ct_mode)
+    {
+	ct_mode = NormalizeCtModeBMG(ct_mode,opt_ct_mode);
+	InitializeCTCODE( ctcode, ct_mode < CTM_CTCODE ? CTM_CTCODE : ct_mode );
+    }
+    ResetDataCTCODE(ctcode,true);
+
+    le_analyse_t ana;
+    AnalyseLEBinary(&ana,data,data_size);
+
+
+    //--- copy racing cups
+
+    ctcode->n_racing_cups = 0;
+    ctcode_cup1_data_t *cup = ctcode->cup_racing;
+    const le_cup_track_t *cup_dest = ana.cup_track;
+    if ( cup && cup_dest )
+    {
+	uint cup_idx, max = ctcode->max_racing_cups;
+	if ( max > ana.n_cup_track )
+	     max = ana.n_cup_track ;
+
+	for ( cup_idx = 0; cup_idx < max; cup_idx++, cup++ )
+	{
+	    if ( cup_dest[0] || cup_dest[1] || cup_dest[2] || cup_dest[3] )
+	    {
+		cup->track_id[0] = *cup_dest++;
+		cup->track_id[1] = *cup_dest++;
+		cup->track_id[2] = *cup_dest++;
+		cup->track_id[3] = *cup_dest++;
+		ctcode->n_racing_cups++;
+	    }
+	    else
+		cup_dest += 4;
+	}
+    }
+
+
+    //--- copy battle cups
+
+    ctcode->n_battle_cups = 0;
+    cup = ctcode->cup_battle;
+    cup_dest = ana.cup_arena;
+    if ( cup && cup_dest )
+    {
+	uint cup_idx, max = ctcode->max_battle_cups;
+	if ( max > ana.n_cup_arena )
+	     max = ana.n_cup_arena ;
+
+	for ( cup_idx = 0; cup_idx < max; cup_idx++, cup++ )
+	{
+	    if ( cup_dest[0] || cup_dest[1] || cup_dest[2] || cup_dest[3] || cup_dest[4] )
+	    {
+		cup->track_id[0] = *cup_dest++;
+		cup->track_id[1] = *cup_dest++;
+		cup->track_id[2] = *cup_dest++;
+		cup->track_id[3] = *cup_dest++;
+		cup->track_id[4] = *cup_dest++;
+		ctcode->n_battle_cups++;
+	    }
+	    else
+		cup_dest += 4;
+	}
+    }
+
+
+    //--- copy track properties
+
+    ctcode->n_tracks		= 0;
+    ctcode_crs1_data_t	*td	= ctcode->crs->data;
+    const le_property_t	*prop	= ana.property;
+    const le_music_t	*music	= ana.music;
+    const le_flags_t	*flags	= ana.flags;
+    le_flags_t	     *ct_flags	= ctcode->le_flags;
+
+    if ( td && prop && music && flags )
+    {
+	uint tidx, max = ctcode->max_tracks;
+	if ( max > ana.n_slot )
+	     max = ana.n_slot ;
+
+	int max_tidx = -1;
+	for ( tidx = 0; tidx < max;
+		tidx++, td++, prop++, music++, flags++, ct_flags++ )
+	{
+	    if ( tidx >= 0x2a && tidx < LE_FIRST_LOWER_CT_SLOT )
+	    {
+		td->music_id	= htonl(0x75);
+		td->property_id	= htonl(0);
+		*ct_flags	= 0;
+	    }
+	    else
+	    {
+		if ( *music || *prop )
+		    max_tidx = tidx;
+		td->music_id	= htonl(*music);
+		td->property_id	= htonl(*prop);
+		*ct_flags	= *flags;
+		snprintf(td->filename,sizeof(td->filename),"%03x",tidx);
+	    }
+	}
+	ctcode->n_tracks = max_tidx+1;
+    }
+
+
+    //--- terminate
+
+    ResetLEAnalyse(&ana);
+    CalcCupRefCTCODE(ctcode,true);
+    CheckLEFlagsUsage(ctcode);
+
+    PRINT("STAT/CUP: racing: %u/%u, battle: %u/%u, unused: %u\n",
+		ctcode->n_racing_cups, ctcode->max_racing_cups,
+		ctcode->n_battle_cups, ctcode->max_battle_cups,
+		ctcode->n_unused_cups );
+    PRINT("STAT/TRACK: %u/%u\n", ctcode->n_tracks, ctcode->max_tracks );
+
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			CTCODE scan + load		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    const void		* data,		// data to scan
+    uint		data_size,	// size of 'data'
+    ContainerCTC_t	* cdata,	// NULL or container-data
+    CheckMode_t		mode		// not NULL: call CheckCTCODE(mode)
+)
+{
+    DASSERT(ctcode);
+    PRINT("ScanCTCODE(mode=%x) size=%u\n",mode,data_size);
+
+    enumError err;
+// [[analyse-magic]]
+    switch (GetByMagicFF(data,data_size,data_size))
+    {
+	case FF_BRRES:
+	    err = ScanBrresCTCODE(ctcode,ct_mode,data,data_size,cdata);
+	    if ( !ctcode->cup && !ctcode->crs )
+	    {
+		ERROR0(ERR_INVALID_DATA,
+		    "No CTCODE in BRRES found: %s\n", ctcode->fname ? ctcode->fname : "?");
+		ResetCTCODE(ctcode);
+		return ERR_INVALID_DATA;
+	    }
+	    ctcode->fform = FF_BRRES;
+	    break;
+
+	case FF_TEX_CT:
+	    err = ScanTexCTCODE(ctcode,ct_mode,data,data_size,cdata);
+	    ctcode->fform = FF_TEX_CT;
+	    break;
+
+	case FF_CT1_DATA:
+	    err = ScanRawCTCODE(ctcode,ct_mode,data,data_size,cdata);
+	    ctcode->fform = FF_CT1_DATA;
+	    break;
+
+	case FF_CT_TEXT:
+	 #if USE_NEW_CONTAINER_CTC
+	    FreeContainerData(cdata);
+	 #else
+	    FreeContainer(cdata);
+	 #endif
+	    err =  ScanTextCTCODE(ctcode,ct_mode,data,data_size);
+	    ctcode->fform = FF_CT_TEXT;
+	    break;
+
+	case FF_LE_BIN:
+	 #if USE_NEW_CONTAINER_CTC
+	    FreeContainerData(cdata);
+	 #else
+	    FreeContainer(cdata);
+	 #endif
+	    err =  ScanLEBinCTCODE(ctcode,ct_mode,data,data_size);
+	    ctcode->fform = FF_LE_BIN;
+	    break;
+
+	default:
+	 #if USE_NEW_CONTAINER_CTC
+	    FreeContainerData(cdata);
+	 #else
+	    FreeContainer(cdata);
+	 #endif
+	    if (ct_mode)
+		InitializeCTCODE(ctcode,ct_mode);
+	    return ERROR0(ERR_INVALID_DATA,
+		"No CTCODE file: %s\n", ctcode->fname ? ctcode->fname : "?");
+    }
+
+    if ( !err && opt_patch_names )
+	PatchNamesCTCODE(ctcode);
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanRawDataCTCODE
+(
+    ctcode_t		* ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    struct raw_data_t	* raw,		// valid raw data
+    CheckMode_t		mode		// not NULL: call CheckCTCODE(mode)
+)
+{
+    DASSERT(ctcode);
+    DASSERT(raw);
+    if (ct_mode)
+	InitializeCTCODE(ctcode,ct_mode);
+    else
+	ResetCTCODE(ctcode);
+    if (!raw->data)
+	return ERR_OK;
+
+    ctcode->fname = raw->fname;
+    raw->fname = 0;
+ #if USE_NEW_CONTAINER_CTC
+    return ScanCTCODE( ctcode, CTM_NO_INIT, raw->data, raw->data_size,
+			LinkContainerRawData(raw), mode );
+ #else
+    return ScanCTCODE( ctcode, CTM_NO_INIT, raw->data, raw->data_size,
+			ContainerRawData(raw), mode );
+ #endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError LoadCTCODE
+(
+    ctcode_t		*ctcode,	// CTCODE data structure
+    ct_mode_t		ct_mode,	// not CTM_NO_INIT: Initialize
+    ccp			fname,		// valid pointer to filenname
+    bool		ignore_no_file,	// ignore if file does not exists
+					// and return warning ERR_NOT_EXISTS
+    CheckMode_t		mode		// not NULL: call CheckCTCODE(mode)
+)
+{
+    DASSERT(ctcode);
+    DASSERT(fname);
+    if (ct_mode)
+	InitializeCTCODE(ctcode,ct_mode);
+    else
+	ResetCTCODE(ctcode);
+
+    if (!strcmp(fname,"0"))
+    {
+	ctcode->fform = FF_CT_TEXT;
+	ctcode->fname = STRDUP(fname);
+	return ERR_OK;
+    }
+
+    //--- load and scan data
+
+    raw_data_t raw;
+    enumError err = LoadRawData(&raw,true,fname,0,ignore_no_file,false);
+    if (!err)
+    {
+	ctcode->fname = raw.fname;
+	raw.fname = 0;
+     #if USE_NEW_CONTAINER_CTC
+	err = ScanCTCODE( ctcode, CTM_NO_INIT, raw.data, raw.data_size,
+				LinkContainerRawData(&raw),mode);
+     #else
+	err = ScanCTCODE( ctcode, CTM_NO_INIT, raw.data, raw.data_size,
+				ContainerRawData(&raw), mode );
+     #endif
+    }
+
+    ResetRawData(&raw);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveTextCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_track
+(
+    FILE		*f,		// output file
+    ctcode_t		*ctcode,	// pointer to valid CTCODE
+    char		letter,		// record letter
+    uint		tidx,		// valid track index
+    bool		print_hex	// true: force hex output
+)
+{
+    DASSERT( f );
+    DASSERT( ctcode );
+    DASSERT( letter == 'T' || letter == 'H' || letter == 'A' );
+    DASSERT( tidx < ctcode->n_tracks );
+
+    char namebuf[TNAME_BUF_SIZE];
+
+    const bmg_item_t *bi
+	    = FindItemBMG(&opt_load_bmg,tidx+ctcode->ctb.track_name1.beg);
+    GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+    const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+
+    fprintf(f,"%c %s\t; %s\t;",
+	letter,
+	PrintMusicID(ntohl(td->music_id),print_hex),
+	PrintPropertyID(ntohl(td->property_id),print_hex) );
+
+    if (ctcode->use_le_flags)
+	fprintf(f," 0x%02x\t;",ctcode->le_flags[tidx]);
+
+    GetTrackFile(namebuf,sizeof(namebuf),ctcode,tidx,0);
+    fprintf(f," \"%s\"",namebuf);
+
+    ccp placeholder;
+    GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+    if (*namebuf)
+    {
+	fprintf(f," ; \"%s\"",namebuf);
+	placeholder = "";
+    }
+    else
+	placeholder = " ; \"\"";
+
+    GetTrackIdentifier(namebuf,sizeof(namebuf),ctcode,tidx,0);
+    if (*namebuf)
+	fprintf(f,"%s ; \"%s\"\r\n",placeholder,namebuf);
+    else
+	fputs("\r\n",f);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveTextCTCODE
+(
+    ctcode_t		* ctcode,	// pointer to valid CTCODE
+    ccp			fname,		// filename of destination
+    bool		set_time,	// true: set time stamps
+    const output_mode_t	* outmode	// output mode, if NULL: use defaults
+)
+{
+    // use DOS/Windows line format -> unix can handle it ;)
+
+    DASSERT(ctcode);
+    PrepareSaveCTCODE(ctcode);
+
+    DASSERT(fname);
+    PRINT("SaveTextCTCODE(%s,%d)\n",fname,set_time);
+
+    output_mode_t omode;
+    if (outmode)
+	memcpy(&omode,outmode,sizeof(omode));
+    else
+	InitializeOutputMode(&omode);
+    CalcCupRefCTCODE(ctcode,false);
+
+    char namebuf[TNAME_BUF_SIZE], keybuf[20];
+
+    //--- open file
+
+    File_t F;
+    enumError err = CreateFileOpt(&F,true,fname,testmode,ctcode->fname);
+    if ( err > ERR_WARNING || !F.f )
+	return err;
+    SetFileAttrib(&F.fatt,&ctcode->fatt,0);
+
+
+    //--- print file header + syntax info
+
+    if (omode.syntax)
+    {
+	fprintf( F.f, text_ctcode_head_cr );
+	fputs(section_sep,F.f);
+    }
+    else
+	fprintf(F.f,"%s\r\n\r\n",CT_TEXT_MAGIC8);
+
+    MARK_USED(keybuf,namebuf);
+    fprintf( F.f, text_ctcode_setup_cr,
+		tool_name, SYSTEM, VERSION, REVISION_NUM, DATE,
+		 ctcode->ctb.ct_mode,
+		ctcode->n_racing_cups,
+		ctcode->max_racing_cups,
+		ctcode->n_battle_cups,
+		ctcode->max_battle_cups,
+		 ctcode->used_tracks,
+		 ctcode->used_arenas,
+		 ctcode->n_tracks,
+		 ctcode->max_tracks,
+		ctcode->n_racing_cups,
+		ctcode->max_racing_cups,
+		ctcode->n_battle_cups,
+		ctcode->max_battle_cups,
+		ctcode->n_unused_cups );
+
+
+    //--- print track list
+
+    if ( omode.mode & 1 && ctcode->used_tracks )
+    {
+	fprintf(F.f,"%s[RACING-TRACK-LIST]\r\n%s",
+			section_sep,
+			omode.syntax
+				? text_ctcode_list_syntax_full_cr
+				: text_ctcode_list_syntax_brief_cr );
+
+	if (ctcode->use_le_flags)
+	    fputs("\n%LE-FLAGS = 1 # 0:disabled, 1:enabled\n",F.f);
+
+	if (ctcode->replace_at)
+	    fputs("\n%REPLACE-AT = 1"
+		  " # replace @*@ codes in track names (1:enabled)\n",F.f);
+
+
+	//-- print battle cups
+
+	if (ctcode->assigned_arenas)
+	{
+	    fprintf(F.f,"\n#--- battle arenas\n\nC \"Wii Arenas\"\n");
+
+	    uint arena;
+	    for ( arena = 0; arena < MKW_N_ARENAS; arena++ )
+	    {
+		if ( arena == 5 )
+		    fprintf(F.f,"\nC \"Retro Arenas\"\n");
+
+		const uint tidx = arena_pos_default[arena] + MKW_N_TRACKS;
+		print_track(F.f,ctcode,'A',tidx,omode.hex);
+	    }
+	    fprintf(F.f,"\n#--- racing tracks\n");
+	}
+
+
+	//-- racing cups
+
+	u8 done[CODE_MAX_TRACKS];
+	memset(done,0,sizeof(done));
+	memset(done+0x20,1,10);
+	memset(done+0x36,1, 5);
+	memset(done+0x42,1, 2);
+
+	uint cidx;
+	for ( cidx = 0; cidx < ctcode->n_racing_cups; cidx++ )
+	{
+	    const ctcode_cup1_data_t *cd = ctcode->cup->data + cidx;
+	    const bmg_item_t *bi
+		= FindItemBMG(&opt_load_bmg,ctcode->ctb.rcup_name.beg+cidx);
+	    if ( bi && bi->len )
+		PrintString16BMG(namebuf,sizeof(namebuf),bi->text,bi->len,
+				BMG_UTF8_MAX,2,opt_bmg_colors);
+	    else
+		PrintString16BMG(namebuf,sizeof(namebuf),cd->name,-1,
+				BMG_UTF8_MAX,2,opt_bmg_colors);
+	    fprintf(F.f,"\r\nC %s # 0x%02x = %2u\r\n",namebuf,cidx,cidx);
+
+	    fprintf(F.f,"S 0x%02x!, 0x%02x!, 0x%02x!, 0x%02x!\r\n",
+		be32(cd->track_id+0),
+		be32(cd->track_id+1),
+		be32(cd->track_id+2),
+		be32(cd->track_id+3) );
+
+	    uint ti;
+	    for ( ti = 0; ti < 4; ti++ )
+	    {
+		const uint tidx = be32(cd->track_id+ti);
+		if ( tidx < ctcode->n_tracks )
+		{
+		    print_track(F.f,ctcode,'T',tidx,omode.hex);
+		    done[tidx] = 2;
+		}
+		else
+		    fprintf(F.f,"T= -\r\n");
+	    }
+	}
+
+	uint tidx, h_count = 0;
+	DASSERT( ctcode->n_tracks <= ctcode->max_tracks );
+	for ( tidx = 0; tidx < ctcode->n_tracks; tidx++ )
+	{
+	    if ( done[tidx] )
+		continue;
+
+	    const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+	    if ( ntohl(td->music_id) == 0x75 && !ntohl(td->property_id) )
+		continue;
+
+	    if (!h_count++)
+		fprintf(F.f,"\r\n#--- hidden tracks (not linked to a cup)\r\n\r\n");
+
+	    fprintf(F.f,"S 0x%02x!\r\n",tidx);
+	    print_track(F.f,ctcode,'H',tidx,omode.hex);
+	}
+    }
+
+
+    //--- print track reference
+
+    if ( omode.mode & 2 && ctcode->n_tracks )
+    {
+	fputs(section_sep,F.f);
+
+	const uint keyfw = 8;
+	uint tidx;
+	for ( tidx = 0; tidx < ctcode->n_tracks; tidx++ )
+	{
+	    const ctcode_crs1_data_t *td = ctcode->crs->data+tidx;
+	    fprintf(F.f,"[TRACK-REF]\r\n%-*s = 0x%02x # %u\r\n",keyfw,"index",tidx,tidx);
+	    const bool is_battle = IsMkwArena(tidx);
+	    if (is_battle)
+		fprintf(F.f,"%-*s = %2u\r\n",keyfw,"battle",tidx-MKW_ARENA_BEG);
+
+	    GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,0);
+	    fprintf(F.f,"%-*s = %s\r\n",keyfw,"name",namebuf);
+
+	    const bmg_item_t *bi
+		= FindItemBMG(&opt_load_bmg,tidx+ctcode->ctb.track_name1.beg);
+	    if ( bi && bi->len )
+	    {
+		PrintString16BMG(namebuf,sizeof(namebuf),bi->text,bi->len,
+				BMG_UTF8_MAX,0,opt_bmg_colors);
+		fprintf(F.f,"%-*s = %s\r\n",keyfw,"bmg",namebuf);
+	    }
+
+	    fprintf(F.f,"%-*s = %s\r\n",keyfw,"file",td->filename);
+
+	    GetTrackFile(namebuf,sizeof(namebuf),ctcode,tidx,0);
+	    if (*namebuf)
+		fprintf(F.f,"%-*s = %s\r\n",keyfw,"filename",namebuf);
+
+	    const uint music_id = be32(&td->music_id);
+	    fprintf(F.f,"%-*s = 0x%02x",keyfw,"music",music_id);
+	    const uint mtrack = MusicID2TrackId(music_id,0xff,0xff);
+	    if ( omode.cross_ref && mtrack < MKW_N_TRACKS + MKW_N_ARENAS )
+	    {
+		const TrackInfo_t *info = GetTrackInfo(mtrack);
+		fprintf(F.f," # %s, %s, %s\r\n",
+			info->sound_n_fname, info->sound_f_fname, info->name_en );
+	    }
+	    else
+		fputs("\r\n",F.f);
+
+	    const uint prop_id = be32(&td->property_id);
+	    fprintf(F.f,"%-*s = 0x%02x",keyfw,"property",prop_id);
+	    if ( omode.cross_ref && prop_id < ctcode->n_tracks )
+	    {
+		GetTrackString(namebuf,sizeof(namebuf),ctcode,prop_id,0);
+		const ctcode_crs1_data_t *pd = ctcode->crs->data+prop_id;
+		fprintf(F.f," # %s, %s\r\n", pd->filename, namebuf );
+	    }
+	    else
+		fputs("\r\n",F.f);
+
+	    const uint cup_id = be32(&td->cup_id);
+	    fprintf(F.f,"%-*s = 0x%02x",keyfw,"cup",cup_id);
+	    if ( omode.cross_ref && !is_battle && tidx < ctcode->max_tracks )
+	    {
+		ctcode_cupref_t *cr = ctcode->cupref + tidx;
+		if (!cr->n)
+		    fprintf(F.f," # not used in any cup!\r\n");
+		else
+		{
+		    if ( cup_id == cr->cup[0] )
+		    {
+			const ctcode_cup1_data_t *cd = GetCupData(ctcode,cup_id);
+			if (cd)
+			{
+			    const ctcode_cup1_data_t *cd = ctcode->cup->data+cup_id;
+			    PrintString16BMG(namebuf,sizeof(namebuf),cd->name,-1,
+						BMG_UTF8_MAX,0,opt_bmg_colors);
+			    fprintf(F.f," # used in cup '%s' @%d\r\n",
+				namebuf, cr->idx[0] );
+			}
+		    }
+		    else
+		    {
+			const uint cup_id2 = cr->cup[0];
+			const ctcode_cup1_data_t *cd = GetCupData(ctcode,cup_id2);
+			if (cd)
+			{
+			    PrintString16BMG(namebuf,sizeof(namebuf),cd->name,-1,
+						BMG_UTF8_MAX,0,opt_bmg_colors);
+			    fprintf(F.f," # not used in cup 0x%02x,"
+					" but in cup 0x%02x '%s' @%d\r\n",
+					cup_id, cup_id2, namebuf, cr->idx[0] );
+			}
+		    }
+
+		    uint i;
+		    for ( i = 1; i < cr->n; i++ )
+		    {
+			const ctcode_cup1_data_t *cd = GetCupData(ctcode,cr->cup[i]);
+			if (cd)
+			{
+			    PrintString16BMG(namebuf,sizeof(namebuf),cd->name,-1,
+						BMG_UTF8_MAX,0,opt_bmg_colors);
+			    fprintf(F.f,"%-*s = 0x%02x # Also used in cup '%s' @%d\r\n",
+				    keyfw, "#cup", cr->cup[i], namebuf, cr->idx[i] );
+			}
+		    }
+		}
+	    }
+	    else
+		fputs("\r\n",F.f);
+
+	    fputs("\r\n",F.f);
+	}
+    }
+
+
+    //--- print cup reference
+
+    if ( omode.mode & 2 && ctcode->n_racing_cups + ctcode->n_battle_cups )
+    {
+	fputs(section_sep,F.f);
+
+	const uint keyfw = 7;
+	uint cidx;
+	for ( cidx = 0; cidx < ctcode->n_racing_cups + ctcode->n_battle_cups; cidx++ )
+	{
+	    const ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	    DASSERT(cd);
+
+	    fprintf(F.f,"[CUP-REF]\r\n%-*s = 0x%02x # %u\r\n",keyfw,"index",cidx,cidx);
+	    const bool is_battle = cidx >= ctcode->n_racing_cups;
+	    if (is_battle)
+		fprintf(F.f,"%-*s = %u\r\n",keyfw,"battle",cidx-ctcode->n_racing_cups);
+	    PrintString16BMG(namebuf,sizeof(namebuf),cd->name,-1,
+				BMG_UTF8_MAX,0,opt_bmg_colors);
+	    fprintf(F.f,"%-*s = %s\r\n",keyfw,"name",namebuf);
+
+	    const bmg_item_t *bi
+		= FindItemBMG(&opt_load_bmg,cidx+ctcode->ctb.rcup_name.beg);
+	    if ( bi && bi->len )
+	    {
+		PrintString16BMG(namebuf,sizeof(namebuf),bi->text,bi->len,
+				BMG_UTF8_MAX,0,opt_bmg_colors);
+		fprintf(F.f,"%-*s = %s\r\n",keyfw,"bmg",namebuf);
+	    }
+
+	    uint ti;
+	    for ( ti = 0; ti < 4+is_battle; ti++ )
+	    {
+		snprintf(keybuf,sizeof(keybuf),"track-%u",ti);
+		const uint tidx = be32(cd->track_id+ti);
+		fprintf(F.f,"%-*s = 0x%02x",keyfw,keybuf,tidx);
+
+		if ( omode.cross_ref && tidx < ctcode->n_tracks )
+		{
+		    const bmg_item_t *bi
+			= FindItemBMG(&opt_load_bmg,tidx+ctcode->ctb.track_name1.beg);
+		    GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+		    const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+
+		    fprintf(F.f," # M=%02x, P=%02x, %s, %s\r\n",
+			be32(&td->music_id), be32(&td->property_id),
+			td->filename, namebuf );
+		}
+		else
+		    fputs("\r\n",F.f);
+	    }
+	    fputs("\r\n",F.f);
+	}
+    }
+
+
+    //--- terminate
+
+    fputs(section_end,F.f);
+    ResetFile(&F,set_time);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveMessageCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveMessageCTCODE
+(
+    ctcode_t		* ctcode,	// pointer to valid CTCODE
+    ccp			fname,		// filename of destination
+    bool		set_time	// true: set time stamps
+)
+{
+    DASSERT(ctcode);
+    DASSERT(fname);
+
+    PRINT("SaveMessageCTCODE(%s,%d)\n",fname,set_time);
+    PrepareSaveCTCODE(ctcode);
+
+    const bool brief = brief_count > 0 || export_count > 0;
+    if ( brief || long_count > 1 )
+	CalcCupRefCTCODE(ctcode,false);
+
+    bmg_t bmg;
+    InitializeBMG(&bmg);
+
+
+    //--- identification
+
+    PatchIdentificationBMG(&bmg,&ctcode->ctb);
+
+
+    //--- define cup names
+
+    if ( long_count > 0 )
+    {
+	uint cidx, max = ctcode->n_racing_cups;
+	if (!brief)
+	    max += ctcode->n_battle_cups;
+	for ( cidx = 0; cidx < max; cidx++ )
+	{
+	    const ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	    DASSERT(cd);
+	    bmg_item_t *bi = InsertItemBMG(&bmg,ctcode->ctb.rcup_name.beg+cidx,0,0,0);
+	    DASSERT(bi);
+	    uint len = GetLength16BMG(cd->name,sizeof(cd->name)/sizeof(*cd->name));
+	    AssignItemText16BMG(bi,cd->name,len);
+	}
+    }
+
+
+    //--- define track names
+
+    uint tidx, max = ctcode->n_tracks;
+    if ( brief && max > ctcode->max_tracks )
+	max = ctcode->max_tracks;
+
+    uint begin	= brief_count > 2 || brief_count > 1 && ctcode->cmd_n_used
+		? 32 : 0;
+
+    const u16 *prev_cup = 0;
+    uint prev_cup_len = 0;
+
+    for ( tidx = begin; tidx < max; tidx++ )
+    {
+	if ( brief && !ctcode->cupref[tidx].n_racing )
+	    continue;
+
+	const uint mid = tidx + ctcode->ctb.track_name1.beg;
+	const bmg_item_t *bi0 = FindItemBMG(&opt_load_bmg,mid);
+	uint tlen;
+	const u16 *text = GetTrackName16(&tlen,ctcode,tidx,bi0);
+	bmg_item_t *bi = InsertItemBMG(&bmg,mid,0,0,0);
+	DASSERT(bi);
+	AssignItemText16BMG(bi,text,tlen);
+
+	if ( long_count > 1 && tidx < ctcode->max_tracks )
+	{
+	    char buf[1000], *dest = buf;
+	    ctcode_cupref_t *cr = ctcode->cupref + tidx;
+
+	    if (cr->n)
+	    {
+		uint i;
+		for ( i = 0; i < cr->n; i++ )
+		{
+		    dest += snprintf(dest,buf+sizeof(buf)-dest,
+			    ",%u.%u", cr->cup[i]+1, cr->idx[i]+1 );
+		}
+		bmg_item_t *bi
+			= InsertItemBMG(&bmg,ctcode->ctb.cup_ref.beg+tidx,0,0,0);
+		DASSERT(bi);
+		AssignItemTextBMG(bi,buf+1,dest-buf-1);
+		prev_cup     = bi->text;
+		prev_cup_len = bi->len;
+	    }
+	    else if ( prev_cup && tidx >= LE_FIRST_LOWER_CT_SLOT )
+	    {
+		bmg_item_t *bi
+			= InsertItemBMG(&bmg,ctcode->ctb.cup_ref.beg+tidx,0,0,0);
+		DASSERT(bi);
+		AssignItemText16BMG(bi,prev_cup,prev_cup_len);
+	    }
+	}
+    }
+
+
+    //--- save messages
+
+    long_count		= 1; // no special groups
+    brief_count		= 1; // no header, but magic
+    opt_bmg_single_line	= 2; // only pure messages in one line
+
+    UsePatchingListBMG(&bmg);
+    enumError err = SaveTextXBMG(&bmg,fname,set_time);
+    ResetBMG(&bmg);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveTrackListCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveTrackListCTCODE
+(
+    ctcode_t		* ctcode,	// pointer to valid CTCODE
+    ccp			fname,		// filename of destination
+    bool		set_time,	// true: set time stamps
+    uint		select,		// track selection
+					//   0: only custom tracks
+					//   1: standard + custom tracks
+					//   2: standard + custom + battle tracks
+    bool		print_slots,	// true: print music and property slots
+    bool		print_head,	// true: print table header
+    bool		raw_mode	// true: print raw text without escapes
+
+)
+{
+    DASSERT(ctcode);
+    DASSERT(fname);
+
+    PrepareSaveCTCODE(ctcode);
+    PRINT("SaveTrackListCTCODE(%s,%d)\n",fname,set_time);
+
+    char namebuf[TNAME_BUF_SIZE];
+
+    //--- open file
+
+    File_t F;
+    enumError err = CreateFileOpt(&F,true,fname,testmode,ctcode->fname);
+    if ( err > ERR_WARNING || !F.f )
+	return err;
+    SetFileAttrib(&F.fatt,&ctcode->fatt,0);
+
+
+    //--- print header
+
+    if (print_head)
+    {
+	if (print_slots)
+	    fprintf(F.f, "\n Slot\tProp\tMusic\tTrack name\n%.79s\n",Minus300);
+	else
+	    fprintf(F.f, "\n Slot\tTrack name\n%.63s\n",Minus300);
+    }
+
+
+    //--- print track list
+
+    uint cidx, max = ctcode->n_racing_cups;
+    if ( select > 1 )
+	max += ctcode->n_battle_cups;
+    for ( cidx = select ? 0 : 8; cidx < max; cidx++ )
+    {
+	const bool is_battle = cidx >= ctcode->n_racing_cups;
+	const ctcode_cup1_data_t *cd = GetCupData(ctcode,cidx);
+	DASSERT(cd);
+	fputc('\n',F.f);
+
+	uint ti;
+	for ( ti = 0; ti < 4+is_battle; ti++ )
+	{
+	    const uint tidx = be32(cd->track_id+ti);
+	    if ( tidx < ctcode->n_tracks )
+	    {
+		const ctcode_crs1_data_t *td = ctcode->crs->data + tidx;
+		uint music_id = ntohl(td->music_id);
+		uint property_id = ntohl(td->property_id);
+
+		if (is_battle)
+		{
+		    fprintf(F.f," A%u.%u", cidx - ctcode->n_racing_cups + 1, ti+1 );
+
+		    if (!music_id)
+			music_id = arena_info[tidx-MKW_N_TRACKS].music_id;
+		    if (!property_id)
+			property_id = tidx;
+		}
+		else
+		    fprintf(F.f,"%3u.%u", cidx+1, ti+1 );
+
+		if (print_slots)
+		{
+		    fprintf(F.f,"\t%s\t%s",
+			PrintPropertyID(property_id,false),
+			PrintMusicID(music_id,false) );
+		}
+
+		const uint mid = tidx + ctcode->ctb.track_name1.beg;
+		const bmg_item_t *bi = FindItemBMG(&opt_load_bmg,mid);
+		if (raw_mode)
+		    GetRawTrackInfo(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+		else
+		    GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+		fprintf(F.f,"\t%s\n",namebuf);
+	    }
+	}
+    }
+    fputc('\n',F.f);
+
+
+    //--- terminate
+
+    ResetFile(&F,set_time);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveTrackTableCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveTrackTableCTCODE
+(
+    ctcode_t		* ctcode,	// pointer to valid CTCODE
+    ccp			fname,		// filename of destination
+    bool		set_time	// true: set time stamps
+)
+{
+    DASSERT(ctcode);
+    DASSERT(fname);
+
+    PrepareSaveCTCODE(ctcode);
+    PRINT("SaveTrackTableCTCODE(%s,%d)\n",fname,set_time);
+
+    char namebuf[TNAME_BUF_SIZE];
+
+
+    //--- open file
+
+    File_t F;
+    enumError err = CreateFileOpt(&F,true,fname,testmode,ctcode->fname);
+    if ( err > ERR_WARNING || !F.f )
+	return err;
+    SetFileAttrib(&F.fatt,&ctcode->fatt,0);
+
+
+    //--- print track list
+
+    uint cidx;
+    for ( cidx = 0; cidx < ctcode->n_racing_cups; cidx++ )
+    {
+	const ctcode_cup1_data_t *cd = ctcode->cup->data + cidx;
+
+	uint ti;
+	for ( ti = 0; ti < 4; ti++ )
+	{
+	    const uint tidx = be32(cd->track_id+ti);
+	    if ( tidx < ctcode->n_tracks )
+	    {
+		const uint mid = tidx + ctcode->ctb.track_name1.beg;
+		const bmg_item_t *bi = FindItemBMG(&opt_load_bmg,mid);
+		GetTrackString(namebuf,sizeof(namebuf),ctcode,tidx,bi);
+		fprintf(F.f,"%02u%u|%04x|%s\n",cidx,ti,mid,namebuf);
+	    }
+	}
+    }
+
+
+    //--- terminate
+
+    ResetFile(&F,set_time);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    SaveCTCODE()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static uint DeactivateMOD2
+(
+    BZ2Source_t		*bz2s,		// data
+    ctlang_save_t	lang_mode,	// language mode
+    const u32		*search_pal,	// PAL list
+    const u32		*search_usa,	// USA list
+    const u32		*search_jap,	// JAP list
+    const u32		*search_kor	// KOR list
+)
+{
+    DASSERT(bz2s);
+
+    uint patch_count = 0;
+    u8 *data = NonConstDataBZ2S(bz2s);
+    if (data)
+    {
+	const u32 *search_list;
+	switch (lang_mode)
+	{
+	    case CTL_US: search_list = search_usa; break;
+	    case CTL_JP: search_list = search_jap; break;
+	    case CTL_KO: search_list = search_kor; break;
+	    default:     search_list = search_pal; break;
+	}
+
+	if (search_list)
+	{
+	    u8 *end = data + bz2s->size - 0x10;
+	    while ( *search_list )
+	    {
+		const u32 search = *search_list++;
+		u8 *ptr = data + 0x20;
+		for ( ; ptr < end; ptr += 0x10 )
+		    if ( be32(ptr) == search && be32(ptr+8) == 4 && !be32(ptr+12) )
+		    {
+			ptr[11] = 0;
+			patch_count++;
+			break;
+		    }
+	    }
+	}
+    }
+    return patch_count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveCTCODE
+(
+    ctcode_t		* ctcode,	// pointer to valid CTCODE
+    ccp			fname,		// filename of destination
+    bool		set_time,	// true: set time stamps
+    ctcode_save_t	save_mode,	// save mode
+    ctlang_save_t	lang_mode,	// language mode
+    const output_mode_t	* outmode	// output mode for text output
+					//   if NULL: use defaults
+)
+{
+    DASSERT(ctcode);
+    PrepareSaveCTCODE(ctcode);
+
+    char pathbuf[PATH_MAX];
+
+
+    //--- define sections
+
+    enum { BIDX_BAD0CODE, BIDX_BAD0DATA, BIDX_BAD1CODE,
+		BIDX_MOD1, BIDX_MOD2, BIDX_OVR1, BIDX__N };
+
+    #undef REF
+    #define REF(p,n,a) p "/" n ";" n, a, sizeof(a)
+    static BZ2Source_t srctab[] =
+    {
+	{ REF("rmcp","boot_code.bin", ctcode_boot_code_pal_bz2), FF_CT0_CODE },
+	{ REF("rmcp","boot_data.bin", ctcode_boot_data_pal_bz2), FF_CT0_DATA },
+	{ REF("rmcp","bad1code.bin",  ctcode_bad1code_pal_bz2),  FF_CT1_CODE },
+	{ REF("rmcp","mod1.bin",      ctcode_mod1_pal_bz2),      FF_MOD1 },
+	{ REF("rmcp","mod2.bin",      ctcode_mod2_pal_bz2),      FF_MOD2 },
+	{ REF("rmcp","ovr1.bin",      ctcode_ovr1_pal_bz2),      FF_OVR1 },
+
+	{ REF("rmce","boot_code.bin", ctcode_boot_code_usa_bz2), FF_CT0_CODE },
+	{ REF("rmce","boot_data.bin", ctcode_boot_data_usa_bz2), FF_CT0_DATA },
+	{ REF("rmce","bad1code.bin",  ctcode_bad1code_usa_bz2),  FF_CT1_CODE },
+	{ REF("rmce","mod1.bin",      ctcode_mod1_usa_bz2),      FF_MOD1 },
+	{ REF("rmce","mod2.bin",      ctcode_mod2_usa_bz2),      FF_MOD2 },
+	{ REF("rmce","ovr1.bin",      ctcode_ovr1_usa_bz2),      FF_OVR1 },
+
+	{ REF("rmcj","boot_code.bin", ctcode_boot_code_jap_bz2), FF_CT0_CODE },
+	{ REF("rmcj","boot_data.bin", ctcode_boot_data_jap_bz2), FF_CT0_DATA },
+	{ REF("rmcj","bad1code.bin",  ctcode_bad1code_jap_bz2),  FF_CT1_CODE },
+	{ REF("rmcj","mod1.bin",      ctcode_mod1_jap_bz2),      FF_MOD1 },
+	{ REF("rmcj","mod2.bin",      ctcode_mod2_jap_bz2),      FF_MOD2 },
+	{ REF("rmcj","ovr1.bin",      ctcode_ovr1_jap_bz2),      FF_OVR1 },
+
+	// [[2do]] [[ct-korea]]
+	{ REF("rmck","boot_code.bin", 0), FF_CT0_CODE },
+	{ REF("rmck","boot_data.bin", 0), FF_CT0_DATA },
+	{ REF("rmck","bad1code.bin",  0), FF_CT1_CODE },
+	{ REF("rmck","mod1.bin",      0), FF_MOD1 },
+	{ REF("rmck","mod2.bin",      0), FF_MOD2 },
+	{ REF("rmck","ovr1.bin",      0), FF_OVR1 },
+
+	{0}
+    };
+    #undef REF
+
+    ClearBZ2S(srctab,-1);
+
+
+    //--- setup jobs
+
+    bool copy_brres	= false;  // copy BRRES header and string pool
+    bool copy_tex	= false;  // copy TEX0 header and IMAGE
+    bool copy_ct0code	= false;  // copy CT0CODE = boot_code
+    bool copy_ct0data	= false;  // copy CT0DATA = boot_data
+    bool copy_ct1code	= false;  // copy CT1CODE
+    bool copy_ct1data	= false;  // copy CT1DATA (header + CUP1 + CRS1 + MOD1 + MOD2 + OVR )
+    bool copy_cup1	= false;  // copy CUP1 section
+    bool copy_crs1	= false;  // copy CRS1 section
+    bool copy_mod1	= false;  // copy MOD1 section
+    bool copy_mod2	= false;  // copy MOD2 section
+    bool copy_ovr1	= false;  // copy OVR1 section
+
+    uint load_data	= 0;      // load data from external files, bit field: 1<<BIDX_*
+    bool use_dynamic	= false;  // if true: enable dynamic CTGP_CODE size
+
+    switch (save_mode)
+    {
+     case CTS_CUP1:
+	copy_cup1	= true;
+	break;
+
+     case CTS_CRS1:
+	copy_crs1	= true;
+	break;
+
+     case CTS_MOD1:
+	copy_mod1	= true;
+	load_data	= 1 << BIDX_MOD1;
+	break;
+
+     case CTS_MOD2:
+	copy_mod2	= true;
+	load_data	= 1 << BIDX_MOD2;
+	break;
+
+     case CTS_OVR1:
+	copy_ovr1	= true;
+	load_data	= 1 << BIDX_OVR1;
+	break;
+
+     case CTS_CT0CODE:
+	copy_ct0code	= true;
+	load_data	= 1 << BIDX_BAD0CODE;
+	break;
+
+     case CTS_CT0DATA:
+	copy_ct0data	= true;
+	load_data	= 1 << BIDX_BAD0DATA;
+	break;
+
+     case CTS_CT1CODE:
+	copy_ct1code	= true;
+	load_data	= 1 << BIDX_BAD1CODE;
+	break;
+
+     case CTS_CT1DATA:
+	copy_ct1data	= true;
+	load_data	= 1 << BIDX_MOD1 | 1 << BIDX_MOD2 | 1 << BIDX_OVR1;
+	break;
+
+     case CTS_BRRES:
+     case CTS_SZS:
+	copy_brres	= true;
+	// fall through
+
+     case CTS_TEX0:
+	copy_tex	= true;
+	copy_ct1data	= true;
+	load_data	= 1 << BIDX_BAD1CODE
+			| 1 << BIDX_MOD1
+			| 1 << BIDX_MOD2
+			| 1 << BIDX_OVR1;
+	use_dynamic	= opt_dynamic_ctcode;
+	break;
+
+     case CTS_BMG:
+	return SaveMessageCTCODE(ctcode,fname,set_time);
+	break;
+
+     case CTS_TRACKS:
+	return SaveTrackListByOptCTCODE(ctcode,fname,set_time);
+	break;
+
+     case CTS_LIST:
+     case CTS_REF:
+     case CTS_FULL:
+	{
+	    output_mode_t omode;
+	    if (outmode)
+		memcpy(&omode,outmode,sizeof(omode));
+	    else
+		InitializeOutputMode(&omode);
+
+	    switch (save_mode)
+	    {
+		case CTS_LIST: omode.mode = 1; break;
+		case CTS_REF:  omode.mode = 2; break;
+		case CTS_FULL: omode.mode = 3; break;
+		default: break;
+	    }
+	    return SaveTextCTCODE(ctcode,fname,set_time,&omode);
+	}
+
+     default:
+	return ERROR0(ERR_INTERNAL,0);
+    }
+
+
+    //--- setup sections
+
+    DASSERT( CTL_US == CTL_EU + 1 );
+    DASSERT( CTL_JP == CTL_EU + 2 );
+    DASSERT( CTL_KO == CTL_EU + 3 );
+    BZ2Source_t *bz2s = srctab + BIDX__N * ( lang_mode < CTL_EU ? 0 : lang_mode - CTL_EU );
+    DASSERT( bz2s >= srctab && bz2s < srctab + sizeof(srctab)/sizeof(*srctab) );
+
+    if (load_data)
+    {
+	if ( SearchListBZ2S( bz2s, BIDX__N, ct_dir_list.field,
+				ct_dir_list.used, opt_ct_log ) != BIDX__N )
+	{
+	    uint i, count = 0;
+	    char *dest = pathbuf;
+	    for ( i = 0; i < BIDX__N; i++ )
+	    {
+		if ( load_data & 1 << i )
+		{
+		    BZ2Source_t *bs = bz2s + i;
+		    if ( !bs->data || !bs->size )
+		    {
+			count++;
+			ccp sem = strchr(bs->search,';');
+			dest = snprintfE(dest,pathbuf+sizeof(pathbuf),", %.*s",
+				(int)( sem ? sem - bs->search : strlen(bs->search) ),
+				bs->search );
+		    }
+		}
+	    }
+	    if (count)
+		return ERROR0(ERR_INVALID_DATA,
+			    "Missing CT-CODE file%s: %s\n",
+			    count == 1 ? "" : "s", pathbuf+2 );
+	}
+
+
+	//--- deactivate region patch
+
+	{
+	    static const u32 pal[] = { 0x8065920c, 0x80653644, 0x8065a034, 0 };
+	    static const u32 usa[] = { 0x80654d84, 0x8064f1bc, 0x80655bac, 0 };
+	    static const u32 jap[] = { 0x80658878, 0x80652cb0, 0x806596a0, 0 };
+	    static const u32 kor[] = { 0 }; // [[2do]] [[ct-korea]]
+	    DeactivateMOD2( bz2s+BIDX_MOD2, lang_mode, pal, usa, jap, kor );
+	}
+
+
+	//--- re-activate old spiny
+
+	if ( old_spiny )
+	{
+	    static const u32 pal[] = { 0x808a5b30, 0 };
+	    static const u32 usa[] = { 0x808a1058, 0 };
+	    static const u32 jap[] = { 0x808a4c90, 0 };
+	    static const u32 kor[] = { 0 }; // [[2do]] [[ct-korea]]
+	    DeactivateMOD2( bz2s+BIDX_MOD2, lang_mode, pal, usa, jap, kor );
+	}
+    }
+
+
+    //--- setup
+
+    size_t cur_off = 0, off = 0, tex_off = 0;
+    PrepareExportCTCODE(ctcode);
+
+
+    //--- open mem file
+
+    MemFile_t mf;
+    InitializeMemFile(&mf,CT_CODE_BRRES_SIZE,0);
+    SetFileAttrib(&mf.fatt,&ctcode->fatt,0);
+    enumError err = ERR_OK;
+
+
+    //--- setup dynamic CTGP_CODE size
+
+    // all offsets are relative to CT_CODE_TEX_OFFSET
+
+    u32 off_head	= 0;
+    u32 off_cup		= off_head	+ sizeof(ctcode->ct_head);
+    u32 off_crs		= off_cup	+ ctcode->cup_size;
+    u32 off_mod1	= CT_CODE_EXTEND_OFFSET + CT_CODE_MOD1_OFFSET;
+    u32 off_mod2	= CT_CODE_EXTEND_OFFSET + CT_CODE_MOD2_OFFSET;
+    u32 off_ovr1	= CT_CODE_EXTEND_OFFSET + CT_CODE_OVR1_OFFSET;
+    u32 off_image	= CT_CODE_TEX_IMAGE_OFF - CT_CODE_TEX_OFFSET;
+    u32 off_term	= CT_CODE_TEX_SIZE - CT_CODE_TEX_OFFSET;
+
+    if (use_dynamic)
+    {
+	fprintf(stderr,"off: %x %x %x %x %x %x | %x %x\n",
+		off_head, off_cup, off_crs, off_mod1, off_mod2, off_ovr1,
+		off_image, off_term );
+    }
+
+
+    //--- write strap header
+
+    if ( !err && copy_brres )
+    {
+	u8 *data;
+	uint size;
+	DecodeBZIP2(&data,&size,0,ctcode_brres_base_bz2,sizeof(ctcode_brres_base_bz2));
+
+	if (opt_image_dir)
+	{
+	    struct ftab_t
+	    {
+		u32 offset;
+		u32 width;
+		ccp fname;
+	    };
+
+	    const uint height_of_all = 456;
+	    static const struct ftab_t ftab[] =
+	    {
+		{ 0x000140, 832, "strapA_16_9_832x456"	},
+		{ 0x0b9580, 608, "strapA_608x456"	},
+		{ 0x140bc0, 832, "strapB_16_9_832x456"	},
+		{ 0x1fa000, 608, "strapB_608x456"	},
+		{ 0x281640, 832, "strapC_832x456"	},
+		{ 0x33aa80, 608, "strapC_608x456"	},
+		{ 0x3c20c0, 832, "strapD_832x456"	}, // relevant image for 16:9 and 4:3
+		{ 0x47b500, 608, "strapD_608x456"	},
+		{0,0,0}
+	    };
+
+	    static const ccp exttab[] =
+	    {
+		".png", ".PNG",
+		".tex", ".TEX",
+		".tex0",".TEX0",
+		"",
+		0
+	    };
+
+	    Image_t img;
+	    InitializeIMG(&img);
+
+	    const struct ftab_t *fi;
+	    for ( fi = ftab; fi->width; fi++ )
+	    {
+		const ccp *ext;
+		for ( ext = exttab; *ext; ext++ )
+		{
+		    ccp path = PathCatPPE(pathbuf,sizeof(pathbuf),opt_image_dir,fi->fname,*ext);
+
+		    if (LoadIMG(&img,false,path,0,false,false,true))
+			continue;
+
+		    if ( img.width != fi->width || img.height != height_of_all )
+		    {
+			if ( verbose >= 0 )
+			    fprintf(stdlog," - load image [%s,%ux%u -> %ux%u]: %s\n",
+				PrintFormatIMG(&img), img.width, img.height,
+				fi->width, height_of_all, path );
+			SmartResizeIMG(&img,false,0,fi->width,height_of_all);
+		    }
+		    else if ( verbose >= 0 )
+			fprintf(stdlog," - load image [%s,%ux%u]: %s\n",
+				PrintFormatIMG(&img), img.width, img.height, path );
+
+		    ConvertIMG(&img,false,0,IMG_RGB565,0);
+		    TRACE(" -> [%s,%ux%u]: *** %u *** %s\n",
+				PrintFormatIMG(&img), img.width, img.height,
+				img.data_size, path );
+
+		    const uint size = fi->width * height_of_all * 2;
+		    if ( img.iform == IMG_RGB565 && img.data_size == size )
+		    {
+			memcpy(data+fi->offset,img.data,size);
+			break;
+		    }
+		}
+	    }
+	    ResetIMG(&img);
+	}
+
+	err = WriteMemFileAt( &mf, 0, data, size );
+	FREE(data);
+	off = tex_off = size;
+    }
+
+
+    //--- write tex header
+
+    if ( !err && copy_tex )
+    {
+	err = WriteMemFileAt( &mf, off, ctcode_tex_header, sizeof(ctcode_tex_header) );
+	if ( !err && bz2s[BIDX_BAD1CODE].status  )
+	    err = WriteMemFileAt( &mf, off+0x40, bz2s[BIDX_BAD1CODE].data,
+						 bz2s[BIDX_BAD1CODE].size );
+
+	if (copy_brres)
+	{
+	    u8 *ptr = GetDataMemFile(&mf,off+12,4);
+	    if (ptr)
+		write_be32(ptr,0xffafd500);
+	}
+	off += CT_CODE_TEX_OFFSET;
+    }
+
+
+    //--- write CTCODE data
+
+    if ( !err && copy_ct1data )
+    {
+//-----------------
+if (use_dynamic) {
+//-----------------
+	err = WriteMemFileAt( &mf, off + off_term, "", 0 );
+
+	if (!err)
+	    err = WriteMemFileAt( &mf, off + off_head,
+				&ctcode->ct_head, sizeof(ctcode->ct_head) );
+
+	if ( !err && ctcode->cup )
+	    err = WriteMemFileAt( &mf, off + off_cup, ctcode->cup, ctcode->cup_size );
+PRINT("space behind cup: %x\n",off_crs-off_cup-ctcode->cup_size);
+
+	if ( !err && ctcode->crs )
+	    err = WriteMemFileAt( &mf, off + off_crs, ctcode->crs, ctcode->crs_size );
+#if 1
+{
+    uint space = off_mod1 - off_crs - ctcode->crs_size;
+    fprintf(stderr,"space behind crs: %x => (%zu) + %zu tracks\n",
+	space,
+	(ctcode->crs_size-sizeof(*ctcode->crs))/sizeof(ctcode_crs1_data_t),
+	space/sizeof(ctcode_crs1_data_t) );
+}
+#endif
+
+	if ( !err && bz2s[BIDX_MOD1].data )
+	    err = WriteMemFileAt( &mf, off + off_mod1,
+					bz2s[BIDX_MOD1].data, bz2s[BIDX_MOD1].size );
+
+	if ( !err && bz2s[BIDX_MOD2].data )
+	    err = WriteMemFileAt( &mf, off + off_mod2,
+					bz2s[BIDX_MOD2].data, bz2s[BIDX_MOD2].size );
+
+	if ( !err && bz2s[BIDX_OVR1].data )
+	    err = WriteMemFileAt( &mf, off + off_ovr1,
+					bz2s[BIDX_OVR1].data, bz2s[BIDX_OVR1].size );
+//--------------
+} else {
+//--------------
+	if (!err)
+	    err = WriteMemFileAt( &mf, off + CT_CODE_EXTEND_OFFSET + CT_CODE_EXTEND_SIZE,
+					"", 0 );
+
+	err = WriteMemFileAt( &mf, off,
+				&ctcode->ct_head, sizeof(ctcode->ct_head) );
+
+	if ( !err && ctcode->cup )
+	    err = WriteMemFile( &mf, ctcode->cup, ctcode->cup_size );
+
+	if ( !err && ctcode->crs )
+	    err = WriteMemFile( &mf, ctcode->crs, ctcode->crs_size );
+
+	if ( !err && bz2s[BIDX_MOD1].data )
+	    err = WriteMemFileAt( &mf, off + CT_CODE_EXTEND_OFFSET + CT_CODE_MOD1_OFFSET,
+					bz2s[BIDX_MOD1].data, bz2s[BIDX_MOD1].size );
+
+	if ( !err && bz2s[BIDX_MOD2].data )
+	    err = WriteMemFileAt( &mf, off + CT_CODE_EXTEND_OFFSET + CT_CODE_MOD2_OFFSET,
+					bz2s[BIDX_MOD2].data, bz2s[BIDX_MOD2].size );
+
+	if ( !err && bz2s[BIDX_OVR1].data )
+	    err = WriteMemFileAt( &mf, off + CT_CODE_EXTEND_OFFSET + CT_CODE_OVR1_OFFSET,
+					bz2s[BIDX_OVR1].data, bz2s[BIDX_OVR1].size );
+//--------------
+}
+//--------------
+    }
+
+
+    //--- write isolated sections
+
+    if ( !err && copy_cup1 && ctcode->cup )
+	err = WriteMemFileAt( &mf, cur_off, ctcode->cup, ctcode->cup_size );
+
+    if ( !err && copy_crs1 && ctcode->crs )
+	err = WriteMemFileAt( &mf, cur_off, ctcode->crs, ctcode->crs_size );
+
+    if ( !err && copy_mod1 && bz2s[BIDX_MOD1].status )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_MOD1].data, bz2s[BIDX_MOD1].size );
+
+    if ( !err && copy_mod2 && bz2s[BIDX_MOD2].status )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_MOD2].data, bz2s[BIDX_MOD2].size );
+
+    if ( !err && copy_ovr1 && bz2s[BIDX_OVR1].status )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_OVR1].data, bz2s[BIDX_OVR1].size );
+
+    if ( !err && copy_ct1code && bz2s[BIDX_BAD1CODE].status  )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_BAD1CODE].data, bz2s[BIDX_BAD1CODE].size );
+
+    if ( !err && copy_ct0code && bz2s[BIDX_BAD0CODE].status  )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_BAD0CODE].data, bz2s[BIDX_BAD0CODE].size );
+
+    if ( !err && copy_ct0data && bz2s[BIDX_BAD0DATA].status  )
+	err = WriteMemFileAt( &mf, cur_off, bz2s[BIDX_BAD0DATA].data, bz2s[BIDX_BAD0DATA].size );
+
+
+    //--- write image
+
+    if ( !err && copy_tex )
+    {
+	u8 *data;
+	uint size;
+	DecodeBZIP2(&data,&size,0,ctcode_image_bz2, sizeof(ctcode_image_bz2));
+	err = WriteMemFileAt( &mf, tex_off+CT_CODE_TEX_IMAGE_OFF, data, size );
+	FREE(data);
+    }
+
+
+    //--- write strap string-pool
+
+    if ( !err && copy_brres )
+    {
+	if (use_dynamic)
+	    fprintf(stderr,"str-pool: %x %zx\n",CT_CODE_STRINGS_OFF,off+off_term);
+	u8 *data;
+	uint size;
+	DecodeBZIP2(&data,&size,0,ctcode_brres_strings_bz2, sizeof(ctcode_brres_strings_bz2));
+	err = WriteMemFileAt( &mf, CT_CODE_STRINGS_OFF, data, size );
+	FREE(data);
+    }
+
+
+    //--- terminate
+
+    FileMode_t fmode = GetFileModeByOpt(testmode,0,0);
+    if ( save_mode == CTS_SZS )
+    {
+	szs_file_t szs;
+	AssignSZS(&szs,true,mf.data,mf.fend,true,FF_BRRES,0);
+	mf.data = 0;
+	err = SaveSZS(&szs,fname,opt_overwrite,true);
+	ResetSZS(&szs);
+    }
+    else
+	err = SaveMemFile(&mf,fname,0,fmode,false);
+
+    ResetMemFile(&mf);
+    ClearBZ2S(srctab,-1);
+    return err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    options			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int	opt_ct_log	= 0;
+bool	old_spiny	= false;
+u32	crs1_property	= 0x800;
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptCtLog ( ccp arg )
+{
+    static const KeywordTab_t keytab[] =
+    {
+	{ SEA_LOG_OFF,		"OFF",		"NONE", 0 },
+	{ SEA_LOG_SUCCESS,	"SUCCESS",	0, 0 },
+	{ SEA_LOG_FOUND,	"FOUND",	0, 0 },
+	{ SEA_LOG_ALL,		"ALL",		0, 0 },
+	{0,0,0,0}
+    };
+
+    if ( !arg || !*arg )
+	opt_ct_log++;
+    else if ( *arg >= '0' && *arg <= '9' )
+    {
+	opt_ct_log = str2l(arg,0,10);
+	if ( opt_ct_log < 0 )
+	    opt_ct_log = 0 ;
+    }
+    else
+    {
+	int abbrev;
+	const KeywordTab_t *key = ScanKeyword(&abbrev,arg,keytab);
+	if (!key)
+	{
+	    PrintKeywordError(keytab,arg,abbrev,0,
+		    "keyword for option --ct-log");
+	    return 1;
+	}
+	opt_ct_log = key->id;
+    }
+
+    if ( opt_ct_log > SEA_LOG_ALL )
+	opt_ct_log = SEA_LOG_ALL;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptCRS1 ( ccp arg )
+{
+    return ERR_OK != ScanSizeOptU32(
+			&crs1_property,		// u32 * num
+			arg,			// ccp source
+			1,			// default_factor1
+			0,			// int force_base
+			"crs1",			// ccp opt_name
+			0,			// u64 min
+			0xffffffff,		// u64 max
+			1,			// u32 multiple
+			0,			// u32 pow2
+			true			// bool print_err
+			);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int ScanOptAllowSlots ( ccp arg )
+{
+    enum { K_TRACKS, K_ARENAS, K_SPECIAL, K_CTCODE };
+
+    static const KeywordTab_t keytab[] =
+    {
+	{ K_TRACKS,	"TRACKS",		0, 0 },
+	{ K_ARENAS,	"ARENAS",		0, 0 },
+	{ K_SPECIAL,	"SPECIAL",		0, 0 },
+	{ K_CTCODE,	"CTCODE",	"CT-CODE", 0 },
+	{0,0,0,0}
+    };
+
+    SetupUsedSlots();
+    if ( !arg || !*arg )
+	return 0;
+
+    for(;;)
+    {
+	while ( *arg == ' ' || *arg == '\t' || *arg == ',' )
+	    arg++;
+
+	const u8 value = *arg == '-' ? 2 : 0;
+	if (value)
+	    arg++;
+
+	while ( *arg == ' ' || *arg == '\t' )
+	    arg++;
+	if (!*arg)
+	    break;
+
+	u32 stat = 0, n1 = 0, n2 = 0;
+	if ( *arg >= '0' && *arg <= '9' )
+	{
+	    arg = ScanRangeU32(arg,&stat,&n1,&n2,0,BMG_N_CT_TRACK-1);
+	}
+	else
+	{
+	    char namebuf[50];
+	    char *dest = namebuf;
+	    while ( isalnum((int)*arg) )
+	    {
+		if ( dest < namebuf + sizeof(namebuf)-1 )
+		    *dest++ = *arg;
+		arg++;
+	    }
+	    *dest = 0;
+
+	    int abbrev;
+	    const KeywordTab_t *key = ScanKeyword(&abbrev,namebuf,keytab);
+	    if (!key)
+	    {
+		PrintKeywordError(keytab,namebuf,abbrev,0,
+			"keyword for option --allow-slots");
+		return 1;
+	    }
+	    DASSERT(key);
+
+	    switch(key->id)
+	    {
+		case K_TRACKS:
+		    stat = 2;
+		    n1 = 0;
+		    n2 = BMG_N_TRACK-1;
+		    break;
+
+		case K_ARENAS:
+		    stat = 2;
+		    n1 = BMG_N_TRACK;
+		    n2 = BMG_N_TRACK + BMG_N_ARENA - 1;
+		    break;
+
+		case K_CTCODE:
+		    memset(ctcode_used_slot,value,BMG_N_TRACK+BMG_N_ARENA);
+		    // fall through
+
+		case K_SPECIAL:
+		    stat = 2;
+		    n1 = 0x36;
+		    n2 = 0x3a;
+		    break;
+	    }
+	}
+
+	noPRINT("RANGE[%d]: 0x%02x .. 0x%02x\n",stat,n1,n2);
+	if ( stat && n1 <= n2 )
+	{
+	    DASSERT( n2 < BMG_N_CT_TRACK );
+	    memset(ctcode_used_slot + n1, value, n2+1-n1 );
+	}
+    }
+
+    if ( logging > 1 ) // must be set before --allow-slots
+	HexDump16(stdlog,0,0,ctcode_used_slot,sizeof(ctcode_used_slot));
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    END				///////////////
+///////////////////////////////////////////////////////////////////////////////
+