SZS v2.18a

1 files changed, 7192 insertions, 0 deletions

diff --git a/project/src/lib-kmp-text.c b/project/src/lib-kmp-text.c
new file mode 100644
index 0000000..c30c57b
--- /dev/null
+++ b/project/src/lib-kmp-text.c
@@ -0,0 +1,7192 @@
+
+/***************************************************************************
+ *                         _______ _______ _______                         *
+ *                        |  ___  |____   |  ___  |                        *
+ *                        | |   |_|    / /| |   |_|                        *
+ *                        | |_____    / / | |_____                         *
+ *                        |_____  |  / /  |_____  |                        *
+ *                         _    | | / /    _    | |                        *
+ *                        | |___| |/ /____| |___| |                        *
+ *                        |_______|_______|_______|                        *
+ *                                                                         *
+ *                            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-kmp.h"
+#include "lib-kcl.h"
+#include "lib-szs.h"
+#include "lib-bzip2.h"
+#include "kmp.inc"
+
+#include <math.h>
+#include <stddef.h>
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			cond_ref table			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const gobj_cond_ref_t cond_ref_tab[COR__N+1] =
+{
+    { COR_NEVER,	"NEVER",	"",	0,"never",		0x0000,0x00,0 },
+    { COR_LECODE,	"LECODE",	"P1234",2,"lecode",		0xffff,0xff,0 },
+    { COR_SINGLE,	"SINGLE",	"P1",	2,"1 player @Wii",	0x5551,0x00,0 },
+    { COR_MULTI,	"MULTI",	"P234",	2,"2-4 players @Wii",	0xaaae,0x00,0 },
+    { COR_OFFLINE,	"OFFLINE",	"OFF",	2,"offline",		0x400f,0x00,0 },
+    { COR_ONLINE,	"ONLINE",	"ON",	2,"online",		0xbff0,0x00,0 },
+
+    { COR_LE6,		"LE6",		"1_6",	3,"≤6 players",		0xc03f,0x00,0 },
+    { COR_GE7,		"GE7",		"7_99",	2,"≥7 players",		0x3fc0,0x00,0 },
+    { COR_LE9,		"LE9",		"1_9",	2,"≤9 players",		0xc0ff,0x00,0 },
+    { COR_GE10,		"GE10",		"10_99",2,"≥10 players",	0x3f00,0x00,0 },
+    { COR_LE12,		"LE12",		"1_12",	2,"≤12 players",	0xc3ff,0x00,0 },
+    { COR_GE13,		"GE13",		"13_99",2,"≥13 players",	0x3c00,0x00,0 },
+    { COR_LE18,		"LE18",		"1_18",	2,"≤18 players",	0xcfff,0x00,0 },
+    { COR_GE19,		"GE19",		"19_99",2,"≥19 players",	0x3000,0x00,0 },
+
+    { COR_7_9,		"7_9",		"",	3,"7-9 players",	0x00c0,0x00,0 },
+    { COR_NOT_7_9,	"NOT_7_9",	"",	2,"<7 or >9 players",	0xff3f,0x00,0 },
+    { COR_7_12,		"7_12",		"",	2,"7-12 players",	0x03c0,0x00,0 },
+    { COR_NOT_7_12,	"NOT_7_12",	"",	2,"<7 or >12 players",	0xfc3f,0x00,0 },
+    { COR_7_18,		"7_18",		"",	2,"7-18 players",	0x0fc0,0x00,0 },
+    { COR_NOT_7_18,	"NOT_7_18",	"",	2,"<7 or >18 players",	0xf03f,0x00,0 },
+    { COR_10_12,	"10_12",	"",	2,"10-12 players",	0x0300,0x00,0 },
+    { COR_NOT_10_12,	"NOT_10_12",	"",	2,"<10 or >12 players",	0xfcff,0x00,0 },
+    { COR_10_18,	"10_18",	"",	2,"10-18 players",	0x0f00,0x00,0 },
+    { COR_NOT_10_18,	"NOT_10_18",	"",	2,"<10 or >18 players",	0xf0ff,0x00,0 },
+    { COR_13_18,	"13_18",	"",	2,"13-18 players",	0x0c00,0x00,0 },
+    { COR_NOT_13_18,	"NOT_13_18",	"",	2,"<13 or >18 players",	0xf3ff,0x00,0 },
+
+    { COR_TIMETRIAL,	"TIMETRIAL",	"TT",	3,"time trial",		0x4000,0x04,1 },
+    { COR_NO_TIMETRIAL,	"NOT_TIMETRIAL","NOTT",	2,"not time trial",	0xbfff,0xfb,0 },
+    { COR_BATTLE,	"BATTLE",	"",	2,"battle",		0x0000,0x03,0 },
+    { COR_RACE,		"RACE",		"",	2,"race",		0x0000,0xfc,0 },
+
+    { COR_BALLOON,	"BALLOON",	"",	3,"balloon",		0x0000,0x01,0 },
+    { COR_NO_BALLOON,	"NOT_BALLOON",	"",	2,"not balloon",	0x0000,0xfe,0 },
+    { COR_COIN,		"COIN",		"",	2,"coin",		0x0000,0x02,0 },
+    { COR_NO_COIN,	"NOT_COIN",	"",	2,"not coin",		0x0000,0xfd,0 },
+    { COR_VERSUS,	"VERSUS",	"",	2,"versus",		0x0000,0x04,0 },
+    { COR_NO_VERSUS,	"NOT_VERSUS",	"",	2,"not versus",		0x0000,0xfb,0 },
+    { COR_ITEMRAIN,	"ITEMRAIN",	"",	2,"item rain",		0x0000,0x08,0 },
+    { COR_NO_ITEMRAIN,	"NOT_ITEMRAIN",	"",	2,"not item rain",	0x0000,0xf7,0 },
+    { COR_SETTING5,	"SETTING5",	"",	2,"settings 5",		0x0000,0x10,0 },
+    { COR_NO_SETTING5,	"NOT_SETTING5",	"",	2,"not setting 5",	0x0000,0xef,0 },
+    { COR_SETTING6,	"SETTING6",	"",	2,"settings 6",		0x0000,0x20,0 },
+    { COR_NO_SETTING6,	"NOT_SETTING6",	"",	2,"not setting 6",	0x0000,0xdf,0 },
+    { COR_SETTING7,	"SETTING7",	"",	2,"settings 7",		0x0000,0x40,0 },
+    { COR_NO_SETTING7,	"NOT_SETTING7",	"",	2,"not setting 7",	0x0000,0xbf,0 },
+    { COR_SETTING8,	"SETTING8",	"",	2,"settings 8",		0x0000,0x80,0 },
+    { COR_NO_SETTING8,	"NOT_SETTING8",	"",	2,"not setting 8",	0x0000,0x7f,0 },
+
+    { COR_P2,		"P2",		"",	3,"2 players @Wii",	0xaaa2,0x00,0 },
+    { COR_P134,		"P134",		"",	2,"1|3|4 players @Wii",	0x555d,0x00,0 },
+    { COR_P3,		"P3",		"",	2,"3 players @Wii",	0x0004,0x00,0 },
+    { COR_P124,		"P124",		"",	2,"1|2|4 players @Wii",	0xfffb,0x00,0 },
+    { COR_P4,		"P4",		"",	2,"4 players @Wii",	0x0008,0x00,0 },
+    { COR_P123,		"P123",		"",	2,"1-3 players @Wii",	0xfff7,0x00,0 },
+    { COR_P12,		"P12",		"",	2,"1-2 players @Wii",	0xfff3,0x00,0 },
+    { COR_P34,		"P34",		"",	2,"3-4 players @Wii",	0x000c,0x00,0 },
+    { COR_P13,		"P13",		"",	2,"1|3 players @Wii",	0x5555,0x00,0 },
+    { COR_P24,		"P24",		"",	2,"2|4 players @Wii",	0xaaaa,0x00,0 },
+    { COR_P14,		"P14",		"",	2,"1|4 players @Wii",	0x5559,0x00,0 },
+    { COR_P23,		"P23",		"",	2,"2-3 players @Wii",	0xaaa6,0x00,0 },
+
+    { CORD_DEBUG,	"DEBUG",	"",	5,"if LE-CODE debug",	0x0001,0x00,2 },
+    { CORD_RELEASE,	"RELEASE",	"",	4,"if LE-CODE release",	0x0002,0x00,2 },
+    { CORD_TESTVAL,	"TESTVAL",	"",	4,"have test values",	0x0004,0x00,2 },
+    { CORD_NO_TESTVAL,	"NOT_TESTVAL",	"",	4,"haven't test values",0x0008,0x00,2 },
+
+    { 0,"","",0,"",0,0,0 },
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+const gobj_cond_ref_t * FindConditionRef ( u16 ref_id )
+{
+    const gobj_cond_ref_t *rc = cond_ref_tab;
+    if ( ref_id < COR__N )
+    {
+	const gobj_cond_ref_t *rc2 = cond_ref_tab + ref_id - 0x1000;
+	if ( rc2->ref_id <= ref_id )
+	    rc = rc2;
+    }
+
+    for ( ; rc->ref_id; rc++ )
+	if ( rc->ref_id == ref_id )
+	    return rc;
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool IsConditionRefEnabled
+	( const gobj_cond_mask_t *cm, u16 ref_id, const gobj_cond_ref_t *cref )
+{
+    DASSERT(cm);
+
+    //--- check predefinied condition for ENGINE
+
+    if (IsConditionRefEngineId(ref_id))
+	return ref_id & cm->engine_mask;
+
+
+    //--- check predefinied condition for RANDOM
+
+    if (IsConditionRefRandomId(ref_id))
+	return ref_id & cm->random_mask;
+
+
+    //--- check hard coded condition => search list
+
+    if (IsConditionRefId(ref_id))
+    {
+	if (!cref)
+	    cref = FindConditionRef(ref_id);
+	if (cref)
+	{
+	    switch (cref->op)
+	    {
+	     case 0:
+		return cref->cond_mask & cm->bit_mask
+		    || cref->set_mask  & cm->game_mask;
+
+	     case 1:
+		return cref->cond_mask & cm->bit_mask
+		    && cref->set_mask  & cm->game_mask;
+	    }
+	}
+	return false;
+    }
+
+    return false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool GetConditionRefInfo
+	( cond_ref_info_t *cri, u16 ref_id, u16 obj_id, bool create_cond  )
+{
+    DASSERT(cri);
+    memset(cri,0,sizeof(*cri));
+
+    if ( obj_id >= GOBJ_MIN_DEF || obj_id & GOBJ_M_LECODE )
+	cri->cmd_suffix = "ENABLE";
+    else
+    {
+	cri->cmd_suffix = "DISABLE";
+	cri->xor	= 1;
+    }
+
+    if (IsConditionRefTestId(ref_id))
+    {
+	cri->is_condref = true;
+	if (cri->xor)
+	{
+	    cri->xor = 1;
+	    ref_id  ^= 1;
+	}
+	if (create_cond)
+	{
+	    snprintf( cri->cond, sizeof(cri->cond),
+			"IF$TEST(%u,%u)", ref_id >> 6 & 15, ref_id >> 1 & 31 );
+	    StringCopyS(cri->info,sizeof(cri->info),
+			"Test condition for LE-CODE developers" );
+	}
+    }
+    else if (IsConditionRefEngineId(ref_id))
+    {
+	cri->is_condref = true;
+	if (cri->xor)
+	{
+	    cri->xor = GOBJ_MASK_COND_ENGINE;
+	    ref_id  ^= GOBJ_MASK_COND_ENGINE;
+	}
+	if (create_cond)
+	{
+	    char *end = cri->cond + sizeof(cri->cond) - 3;
+	    char *dest = StringCopyE(cri->cond,end,"if$engine(");
+	    static const char name[][7]
+		= { "battle", "50", "100", "150", "200", "150m", "200m", "" };
+
+	    uint i, m = ref_id;
+	    for ( i = 0; name[i][0]; i++, m >>= 1 )
+		if ( m&1 )
+		{
+		    if (dest[-1] != '(' )
+			*dest++ = ',';
+		    dest = StringCat2E(dest,end,"en$",name[i]);
+		}
+	    *dest++ = ')';
+	    *dest = 0;
+
+	    StringCopyS(cri->info,sizeof(cri->info),
+			"if selected engines are active" );
+	}
+    }
+    else if (IsConditionRefRandomId(ref_id))
+    {
+	cri->is_condref = true;
+	if (cri->xor)
+	{
+	    cri->xor = GOBJ_MASK_COND_RND;
+	    ref_id  ^= GOBJ_MASK_COND_RND;
+	}
+	if (create_cond)
+	{
+	    char *end = cri->cond + sizeof(cri->cond) - 4;
+	    char *dest = StringCopyE(cri->cond,end,"if$random(");
+	    uint i, m;
+	    for ( i = m = 1; i <= GOBJ_MAX_RANDOM; i++, m <<= 1 )
+		if ( ref_id & m && dest < end )
+		{
+		    if (dest[-1] != '(' )
+			*dest++ = ',';
+		    *dest++ = '0'+i;
+		}
+	    *dest++ = ')';
+	    *dest = 0;
+
+	    StringCopyS(cri->info,sizeof(cri->info),
+			"if selected random scenario is active" );
+	}
+    }
+    else
+    {
+	cri->condref = FindConditionRef(ref_id);
+	if (cri->condref)
+	{
+	    cri->is_condref = true;
+	    if (create_cond)
+	    {
+		const gobj_cond_ref_t *iref = cri->xor
+			    ? FindConditionRef(ref_id^cri->xor)
+			    : cri->condref;
+		if (iref)
+		{
+		    if ( iref->option & 4 )
+		    {
+			snprintf( cri->cond, sizeof(cri->cond), "IFDEV$%s",iref->name);
+			snprintf( cri->info, sizeof(cri->info),
+				"DEVELOPERS: %s", iref->info );
+		    }
+		    else
+		    {
+			snprintf( cri->cond, sizeof(cri->cond), "IF$%s",iref->name);
+			snprintf( cri->info, sizeof(cri->info), "%s%s",
+			    iref->option & 1 ? "if " : "",
+			    iref->info );
+		    }
+		}
+	    }
+	}
+	else
+	    cri->is_condref = IsConditionRefId(ref_id);
+
+	if ( cri->is_condref && !*cri->info )
+	    snprintf( cri->cond, sizeof(cri->cond), "%#x",ref_id^cri->xor );
+    }
+
+    return cri->is_condref;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			link info			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetRouteLinksKMP ( const kmp_t *ckmp )
+{
+    DASSERT(ckmp);
+    kmp_t *kmp = (kmp_t*)ckmp;
+    if (kmp->linfo)
+    {
+	memset(kmp->linfo,0,sizeof(*kmp->linfo));
+	kmp->linfo_sect = ~0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+kmp_linfo_t * SetupRouteLinksKMP ( const kmp_t *ckmp, uint sect, bool force )
+{
+    DASSERT(ckmp);
+    kmp_t *kmp = (kmp_t*)ckmp;
+    if (!kmp->linfo)
+    {
+	kmp->linfo = MALLOC(sizeof(*kmp->linfo));
+	kmp->linfo_sect = ~0;
+    }
+
+    if ( force || kmp->linfo_sect != sect )
+    {
+	kmp->linfo_sect = sect;
+	AnalyseRouteKMP(kmp->linfo,kmp,sect);
+	noPRINT("ROUTE INFO for section #%d [%s] => %u\n",
+		sect, kmp_section_name[sect].name1, kmp->linfo->used );
+    }
+    return (kmp_linfo_t*) kmp->linfo;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint AnalyseRouteKMP ( kmp_linfo_t *li, const kmp_t *kmp, uint sect )
+{
+    DASSERT(li);
+    DASSERT(kmp);
+
+    switch(sect)
+    {
+	case KMP_CKPH:
+	case KMP_ENPH:
+	case KMP_ITPH:
+	    return AnalyseGroupLinksKMP(li,kmp,sect);
+
+	case KMP_CKPT:
+	case KMP_ENPT:
+	case KMP_ITPT:
+	    return AnalyseRouteLinksKMP(li,kmp,sect);
+
+	default:
+	    ASSERT_MSG(0,"AnalyseRouteKMP(): Unsupported KMP section: %u",sect);
+	    memset(li,0,sizeof(*li));
+	    li->sect_pt = li->sect_ph = KMP_NO_SECT;
+    }
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AnalyseGroupLinksKMP ( kmp_linfo_t *li, const kmp_t *kmp, uint sect_ph )
+{
+    DASSERT(li);
+    DASSERT(kmp);
+    memset(li,0,sizeof(*li));
+
+
+    //--- section dependent setup
+
+    switch(sect_ph)
+    {
+	case KMP_CKPH:
+	case KMP_CKPT:
+	    li->sect_pt = KMP_CKPT;
+	    li->sect_ph = KMP_CKPH;
+	    break;
+
+	case KMP_ENPH:
+	case KMP_ENPT:
+	    li->sect_pt = KMP_ENPT;
+	    li->sect_ph = KMP_ENPH;
+	    break;
+
+	case KMP_ITPH:
+	case KMP_ITPT:
+	    li->sect_pt = KMP_ITPT;
+	    li->sect_ph = KMP_ITPH;
+	    break;
+
+	default:
+	    ASSERT_MSG(0,"AnalyseGroupLinksKMP(): Unsupported KMP section: %u",sect_ph);
+	    li->sect_pt = li->sect_ph = KMP_NO_SECT;
+	    return 0;
+    }
+
+
+    //--- setup
+
+    uint n = kmp->dlist[li->sect_ph].used;
+    if ( n > KMP_MAX_LINFO )
+	n = KMP_MAX_LINFO;
+
+
+    //--- iterate groups
+
+    uint i, max = 0;
+    const kmp_enph_entry_t * p = (kmp_enph_entry_t*)kmp->dlist[li->sect_ph].list;
+
+    for ( i = 0; i < n; i++, p++ )
+    {
+	li->n_point[i] = p->pt_len;
+	if (IsDispatchPointKMP(p))
+	    li->gmode[i] |= LINFOG_DISPATCH;
+
+	uint l;
+	for ( l = 0; l < KMP_MAX_PH_LINK; l++ )
+	{
+	    u8 j = p->prev[l];
+	    if ( j != 0xff )
+	    {
+		li->summary[i] |= LINFO_PREV;
+		li->list[i][j] |= LINFO_PREV;
+		li->summary[j] |= LINFO_BY_PREV;
+		li->list[j][i] |= LINFO_BY_PREV;
+		if ( max <= i ) max = i+1;
+		if ( max <= j ) max = j+1;
+	    }
+
+	    j = p->next[l];
+	    if ( j != 0xff )
+	    {
+		li->summary[i] |= LINFO_NEXT;
+		li->list[i][j] |= LINFO_NEXT;
+		li->summary[j] |= LINFO_BY_NEXT;
+		li->list[j][i] |= LINFO_BY_NEXT;
+		if ( max <= i ) max = i+1;
+		if ( max <= j ) max = j+1;
+	    }
+	}
+    }
+
+    noPRINT(">>> GMODE/group\n");
+    //HEXDUMP16(0,0,li->gmode,max);
+    return li->used = max;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint AnalyseRouteLinksPH ( kmp_linfo_t *li, const kmp_t *kmp, uint sect_ph )
+{
+    DASSERT(li);
+    DASSERT(kmp);
+    memset(li,0,sizeof(*li));
+
+
+    //--- section dependent setup
+
+    switch(sect_ph)
+    {
+	case KMP_CKPH:
+	case KMP_CKPT:
+	    li->sect_pt = KMP_CKPT;
+	    li->sect_ph = KMP_CKPH;
+	    break;
+
+	case KMP_ENPH:
+	case KMP_ENPT:
+	    li->sect_pt = KMP_ENPT;
+	    li->sect_ph = KMP_ENPH;
+	    break;
+
+	case KMP_ITPH:
+	case KMP_ITPT:
+	    li->sect_pt = KMP_ITPT;
+	    li->sect_ph = KMP_ITPH;
+	    break;
+
+	default:
+	    ASSERT_MSG(0,"AnalyseRouteLinksPH(): Unsupported KMP section: %u",sect_ph);
+	    li->sect_pt = li->sect_ph = KMP_NO_SECT;
+	    return 0;
+    }
+
+
+    //--- setup
+
+    uint n = kmp->dlist[li->sect_ph].used;
+    if ( n > KMP_MAX_LINFO )
+	n = KMP_MAX_LINFO;
+
+    const kmp_enph_entry_t *ph_list = (kmp_enph_entry_t*)kmp->dlist[li->sect_ph].list;
+
+
+    //--- iterate groups
+
+    uint i, max = 0;
+    const kmp_enph_entry_t *p = ph_list;
+
+    for ( i = 0; i < n; i++, p++ )
+    {
+	if (!p->pt_len)
+	    continue;
+
+	const uint iprev = p->pt_start;
+	const uint inext = p->pt_start + p->pt_len - 1;
+
+	kmp_linfo_g_mode gmode = 0;
+	if (IsDispatchPointKMP(p))
+	    gmode |= LINFOG_DISPATCH;
+	uint pi;
+	for ( pi = iprev; pi <= inext; pi++ )
+	{
+	    li->n_point[pi] = p->pt_len;
+	    li->gmode[pi] = gmode;
+	}
+
+	uint l;
+	for ( l = 0; l < KMP_MAX_PH_LINK; l++ )
+	{
+	    u8 j = p->prev[l];
+	    if ( j != 0xff && j < n )
+	    {
+		const uint link = ph_list[j].pt_start + ph_list[j].pt_len - 1;
+		if ( link < KMP_MAX_LINFO )
+		{
+		    li->summary[iprev]		|= LINFO_G_PREV;
+		    li->list[iprev][link]	|= LINFO_G_PREV;
+		    li->summary[link]		|= LINFO_G_BY_PREV;
+		    li->list[link][iprev]	|= LINFO_G_BY_PREV;
+		    if ( max <= iprev ) max = iprev+1;
+		    if ( max <= link  ) max = link+1;
+		}
+	    }
+
+	    if ( inext < KMP_MAX_LINFO )
+	    {
+		j = p->next[l];
+		if ( j != 0xff && j < n )
+		{
+		    const uint link = ph_list[j].pt_start;
+		    if ( link < KMP_MAX_LINFO )
+		    {
+			li->summary[inext]	|= LINFO_G_NEXT;
+			li->list[inext][link]	|= LINFO_G_NEXT;
+			li->summary[link]	|= LINFO_G_BY_NEXT;
+			li->list[link][inext]	|= LINFO_G_BY_NEXT;
+			if ( max <= inext ) max = inext+1;
+			if ( max <= link  ) max = link+1;
+		    }
+		}
+	    }
+	}
+    }
+
+    noPRINT(">>> GMODE/points\n");
+    //HEXDUMP16(0,0,li->gmode,max);
+
+    return li->used = max;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AnalyseRouteLinksKMP ( kmp_linfo_t *li, const kmp_t *kmp, uint sect_pt )
+{
+    DASSERT(li);
+    DASSERT(kmp);
+
+
+    //--- section dependent setup
+
+    switch(sect_pt)
+    {
+	case KMP_CKPT:
+	case KMP_CKPH:
+	    return AnalyseRouteLinksCKPT(li,kmp);
+	    break;
+
+	case KMP_ENPT:
+	case KMP_ENPH:
+	case KMP_ITPT:
+	case KMP_ITPH:
+	    break;
+
+	default:
+	    ASSERT_MSG(0,"AnalyseRouteLinksKMP(): Unsupported KMP section: %u",sect_pt);
+	    memset(li,0,sizeof(*li));
+	    li->sect_pt = li->sect_ph = KMP_NO_SECT;
+	    return 0;
+    }
+
+
+    //--- setup
+
+    uint max = AnalyseRouteLinksPH(li,kmp,sect_pt);
+
+    uint n = kmp->dlist[li->sect_pt].used;
+    if ( n > KMP_MAX_LINFO )
+	n = KMP_MAX_LINFO;
+    if ( max < n )
+	max = n;
+
+    const kmp_enpt_entry_t *p = (kmp_enpt_entry_t*)kmp->dlist[li->sect_pt].list;
+
+
+    //--- iterate points
+
+    uint i;
+    for ( i = 0; i < n; i++, p++ )
+    {
+	if ( i > 0 && !( li->summary[i] & LINFO_G_PREV ) )
+	{
+	    li->summary[i]	|= LINFO_D_PREV;
+	    li->list[i][i-1]	|= LINFO_D_PREV;
+	    li->summary[i-1]	|= LINFO_D_BY_PREV;
+	    li->list[i-1][i]	|= LINFO_D_BY_PREV;
+	}
+
+	if ( i < KMP_MAX_LINFO-1 && !( li->summary[i] & LINFO_G_NEXT ) )
+	{
+	    li->summary[i]	|= LINFO_D_NEXT;
+	    li->list[i][i+1]	|= LINFO_D_NEXT;
+	    li->summary[i+1]	|= LINFO_D_BY_NEXT;
+	    li->list[i+1][i]	|= LINFO_D_BY_NEXT;
+	}
+    }
+
+    return li->used = max;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint AnalyseRouteLinksCKPT ( kmp_linfo_t *li, const kmp_t *kmp )
+{
+    DASSERT(li);
+    DASSERT(kmp);
+    memset(li,0,sizeof(*li));
+    li->sect_pt = KMP_CKPT;
+    li->sect_ph = KMP_CKPH;
+
+
+    //--- setup
+
+    uint max = AnalyseRouteLinksPH(li,kmp,KMP_CKPH);
+
+    uint n = kmp->dlist[KMP_CKPT].used;
+    if ( n > KMP_MAX_LINFO )
+	n = KMP_MAX_LINFO;
+    if ( max < n )
+	max = n;
+
+    const kmp_ckpt_entry_t *p = (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list;
+
+
+    //--- iterate points
+
+    uint i;
+    for ( i = 0; i < n; i++, p++ )
+    {
+	uint j = p->prev;
+	if ( j != 0xff )
+	{
+	    li->summary[i] |= LINFO_D_PREV;
+	    li->list[i][j] |= LINFO_D_PREV;
+	    li->summary[j] |= LINFO_D_BY_PREV;
+	    li->list[j][i] |= LINFO_D_BY_PREV;
+	}
+
+	j = p->next;
+	if ( j != 0xff )
+	{
+	    li->summary[i] |= LINFO_D_NEXT;
+	    li->list[i][j] |= LINFO_D_NEXT;
+	    li->summary[j] |= LINFO_D_BY_NEXT;
+	    li->list[j][i] |= LINFO_D_BY_NEXT;
+	}
+    }
+
+    return li->used = max;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintLinkInfoMode ( kmp_linfo_mode mode, int print_group, bool adjust )
+{
+    // print_group: -1=never, 0:auto, 1:always
+    char *buf = GetCircBuf(10);
+    char *dest = buf;
+
+    if (adjust)
+    {
+	*dest++ = mode & LINFO_D_PREV		? 'P' : '-';
+	*dest++ = mode & LINFO_D_NEXT		? 'N' : '-';
+	*dest++ = mode & LINFO_D_BY_PREV	? 'p' : '-';
+	*dest++ = mode & LINFO_D_BY_NEXT	? 'n' : '-';
+
+	if ( print_group > 0 || !print_group && mode&LINFO_M_G )
+	{
+	    *dest++ = mode & LINFO_G_PREV	? 'P' : '-';
+	    *dest++ = mode & LINFO_G_NEXT	? 'N' : '-';
+	    *dest++ = mode & LINFO_G_BY_PREV	? 'p' : '-';
+	    *dest++ = mode & LINFO_G_BY_NEXT	? 'n' : '-';
+	}
+    }
+    else
+    {
+	if ( mode & LINFO_D_PREV )		*dest++ = 'P';
+	if ( mode & LINFO_D_NEXT )		*dest++ = 'N';
+	if ( mode & LINFO_D_BY_PREV )		*dest++ = 'p';
+	if ( mode & LINFO_D_BY_NEXT )		*dest++ = 'n';
+
+	if ( print_group >= 0 &&  mode&LINFO_M_G )
+	{
+	    *dest++ = ',';
+	    if ( mode & LINFO_G_PREV )		*dest++ = 'P';
+	    if ( mode & LINFO_G_NEXT )		*dest++ = 'N';
+	    if ( mode & LINFO_G_BY_PREV )	*dest++ = 'p';
+	    if ( mode & LINFO_G_BY_NEXT )	*dest++ = 'n';
+	}
+    }
+    *dest = 0;
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		    kmp parser function get()		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enum // get mode
+{
+    GTMD_N,		// number of elements
+
+    GTMD_HD_U16,	// head 'value' as u16
+    GTMD_HD_U8HI,	// hight byte of head 'value'
+    GTMD_HD_U8LO,	// low byte of head 'value'
+
+    GTMD__DATA,		// separator of header info and data info
+
+    GTMD_U8,		// unsigned 8 bit
+    GTMD_U8M1,		// unsigned 8 bit, but 0xff is -1
+    GTMD_U16,		// unsigned 16 bit
+    GTMD_U16M1,		// unsigned 16 bit, but 0xffff is -1
+
+    GTMD_DBL,		// double value
+    GTMD_DBL2,		// 2d vector
+    GTMD_DBL3,		// 3d double vector
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// [[kmp_func_t]]
+
+#define POTI_PT_OFF 0x10
+
+typedef struct kmp_func_t
+{
+    char	name[18];	// variable name
+    u16		sect;		// section
+    u16		off;		// data offset, for POTI: off>POTI_PT_OFF: route point
+    u16		get_mode;	// see enum above
+    u8		n_var;		// number of variables
+    u8		n_param;	// number of function parameters
+    ccp		get_info;	// NULL or function info for get function
+    ccp		set_info;	// NULL or function info for set function
+
+} kmp_func_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const kmp_func_t kmp_func_list[] =
+{
+    { "KTPT$N",			KMP_KTPT,    0,  GTMD_N,	0,0,
+			"Returns the number of start points.",
+			0 },
+    { "KTPT$POS",		KMP_KTPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns a start point position.",
+			0 },
+    { "KTPT$ROT",		KMP_KTPT, 0x0c,  GTMD_DBL3,	1,1,
+			"Returns a start point rotation.",
+			0 },
+    { "KTPT$ID",		KMP_KTPT, 0x18,  GTMD_U16M1,	1,1,
+			"Returns a start point ID.",
+			0 },
+    { "KTPT$UNKNOWN",		KMP_KTPT, 0x1a,  GTMD_U16,	1,1,
+			"Returns the unknown value of a start point.",
+			0 },
+
+    //---------------
+
+    { "ENPT$N",			KMP_ENPT,    0,  GTMD_N,	0,0,
+			"Returns the number of enemy points.",
+			0 },
+    { "ENPT$POS",		KMP_ENPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns the position of an enemy point.",
+			0 },
+    { "ENPT$SCALE",		KMP_ENPT, 0x0c,  GTMD_DBL,	1,1,
+			"Returns the scale of an enemy point.",
+			0 },
+    { "ENPT$PROP",		KMP_ENPT, 0x10,  GTMD_U16,	2,2,
+			"Returns property 0 or 1 of an enemy point.",
+			0 },
+
+    //---------------
+
+    { "ENPH$N",			KMP_ENPH,    0,  GTMD_N,	0,0,
+			"Returns the number of enemy point groups.",
+			0 },
+    { "ENPH$START",		KMP_ENPH, 0x00,  GTMD_U8,	1,1,
+			"Returns the enemy point start index of an enemy point group.",
+			0 },
+    { "ENPH$LEN",		KMP_ENPH, 0x01,  GTMD_U8,	1,1,
+			"Returns the number of enemy points of an enemy point group.",
+			0 },
+    { "ENPH$PREV",		KMP_ENPH, 0x02,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the previous enemy point group.",
+			0 },
+    { "ENPH$NEXT",		KMP_ENPH, 0x08,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the next enemy point group.",
+			0 },
+    { "ENPH$UNKNOWN",		KMP_ENPH, 0x0e,  GTMD_U16,	1,1,
+			"Returns the unknown value of an enemy point group.",
+			0 },
+
+    //---------------
+
+    { "ITPT$N",			KMP_ITPT,    0,  GTMD_N,	0,0,
+			"Returns the number of item points.",
+			0 },
+    { "ITPT$POS",		KMP_ITPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns the position of an item point.",
+			"Set the position of an item point"
+			" and returns 1 on success ans 0 , if failed." },
+    { "ITPT$SCALE",		KMP_ITPT, 0x0c,  GTMD_DBL,	1,1,
+			"Returns the scale of an item point.",
+			0 },
+    { "ITPT$PROP",		KMP_ITPT, 0x10,  GTMD_U16,	2,2,
+			"Returns property 0 or 1 of an item point.",
+			0 },
+
+    //---------------
+
+    { "ITPH$N",			KMP_ITPH,    0,  GTMD_N,	0,0,
+			"Returns the number of item point groups.",
+			0 },
+    { "ITPH$START",		KMP_ITPH, 0x00,  GTMD_U8,	1,1,
+			"Returns the item point start index of an item point group.",
+			0 },
+    { "ITPH$LEN",		KMP_ITPH, 0x01,  GTMD_U8,	1,1,
+			"Returns the number of item points of an item point group.",
+			0 },
+    { "ITPH$PREV",		KMP_ITPH, 0x02,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the previous item point group.",
+			0 },
+    { "ITPH$NEXT",		KMP_ITPH, 0x08,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the next item point group.",
+			0 },
+    { "ITPH$UNKNOWN",		KMP_ITPH, 0x0e,  GTMD_U16,	1,1,
+			"Returns the unknown value of an item point group.",
+			0 },
+
+    //---------------
+
+    { "CKPT$N",			KMP_CKPT,    0,  GTMD_N,	0,0,
+			"Returns the number of check points.",
+			0 },
+    { "CKPT$LEFT",		KMP_CKPT, 0x00,  GTMD_DBL2,	1,1,
+			"Returns the left position of a check point.",
+			0 },
+    { "CKPT$RIGHT",		KMP_CKPT, 0x08,  GTMD_DBL2,	1,1,
+			"Returns the right position of a check point.",
+			0 },
+    { "CKPT$RESPAWN",		KMP_CKPT, 0x10,  GTMD_U8,	1,1,
+			"Returns the respawn index of a check point.",
+			0 },
+    { "CKPT$MODE",		KMP_CKPT, 0x11,  GTMD_U8M1,	1,1,
+			"Returns the mode of check point.",
+			0 },
+    { "CKPT$PREV",		KMP_CKPT, 0x12,  GTMD_U8M1,	1,1,
+			"Returns the index of the previous check point.",
+			0 },
+    { "CKPT$NEXT",		KMP_CKPT, 0x13,  GTMD_U8M1,	1,1,
+			"Returns the index of the next check point.",
+			0 },
+
+    //---------------
+
+    { "CKPH$N",			KMP_CKPH,    0,  GTMD_N,	0,0,
+			"Returns the number of check point groups.",
+			0 },
+    { "CKPH$START",		KMP_CKPH, 0x00,  GTMD_U8,	1,1,
+			"Returns the check point start index of a check point group.",
+			0 },
+    { "CKPH$LEN",		KMP_CKPH, 0x01,  GTMD_U8,	1,1,
+			"Returns the number of check points of a check point group.",
+			0 },
+    { "CKPH$PREV",		KMP_CKPH, 0x02,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the previous check point group.",
+			0 },
+    { "CKPH$NEXT",		KMP_CKPH, 0x08,  GTMD_U8M1,	KMP_MAX_PH_LINK,2,
+			"Returns link 0..5 to the next check point group.",
+			0 },
+    { "CKPH$UNKNOWN",		KMP_CKPH, 0x0e,  GTMD_U16,	1,1,
+			"Returns the unknown value of a check point group.",
+			0 },
+
+    //---------------
+
+    { "GOBJ$N",			KMP_GOBJ,    0,  GTMD_N,	0,0,
+			"Returns the number of global objects.",
+			0 },
+    { "GOBJ$ID",		KMP_GOBJ, 0x00,  GTMD_U16,	1,1,
+			"Returns the object ID of a global object.",
+			0 },
+    { "GOBJ$UNKNOWN",		KMP_GOBJ, 0x02,  GTMD_U16,	1,1,
+			"Returns the unknown value of a global object.",
+			0 },
+    { "GOBJ$POS",		KMP_GOBJ, 0x04,  GTMD_DBL3,	1,1,
+			"Returns the position of a global object.",
+			0 },
+    { "GOBJ$ROT",		KMP_GOBJ, 0x10,  GTMD_DBL3,	1,1,
+			"Returns the rotation of a global object.",
+			0 },
+    { "GOBJ$SCALE",		KMP_GOBJ, 0x1c,  GTMD_DBL3,	1,1,
+			"Returns the scale of a global object.",
+			0 },
+    { "GOBJ$ROUTE",		KMP_GOBJ, 0x28,  GTMD_U16M1,	1,1,
+			"Returns -1 or the index of a related route"
+			" of a global object.",
+			0 },
+    { "GOBJ$SET",		KMP_GOBJ, 0x2a,  GTMD_U16,	8,2,
+			"Returns setting 0..7 of a global object.",
+			0 },
+    { "GOBJ$PFLAGS",		KMP_GOBJ, 0x3a,  GTMD_U16,	1,1,
+			"Returns the presence flags of a global object.",
+			0 },
+
+    //---------------
+
+    { "POTI$N",			KMP_POTI,    0,  GTMD_N,	0,0,
+			"Returns the number of routes.",
+			0 },
+     { "POTI$NN",		KMP_POTI,    0,  GTMD_HD_U16,	0,0,
+			"Returns the total number of points of all routes.",
+			0 },
+    { "POTI$NP",		KMP_POTI, 0x00,  GTMD_U8,	1,1,
+			"Returns the number of points of a route.",
+			0 },
+    { "POTI$SMOOTH",		KMP_POTI, 0x02,  GTMD_U8,	1,1,
+			"Returns the smooth value of a route"
+			" (route header byte at offset 0x02).",
+			0 },
+    { "POTI$BACK",		KMP_POTI, 0x03,  GTMD_U8,	1,1,
+			"Returns the forward+backward value of a route"
+			" (route header byte at offset 0x03).",
+			0 },
+     { "POTI$POS",		KMP_POTI, 0x10,  GTMD_DBL3,	1,2, // off+POTI_PT_OFF
+			"Returns the position of a point of a route."
+			" The point index is relative to the route.",
+			0 },
+     { "POTI$SET",		KMP_POTI, 0x1c,  GTMD_U16,	2,3, // off+POTI_PT_OFF
+			"Returns setting 0 or 1 of a point of a route."
+			" The point index is relative to the route.",
+			0 },
+
+    //---------------
+
+    { "AREA$N",			KMP_AREA,    0,  GTMD_N,	0,0,
+			"Returns the number of areas.",
+			0 },
+    { "AREA$MODE",		KMP_AREA, 0x00,  GTMD_U8M1,	1,1,
+			"Returns the mode of an area.",
+			0 },
+    { "AREA$TYPE",		KMP_AREA, 0x01,  GTMD_U8M1,	1,1,
+			"Returns the type of an area. Cameras are type 0.",
+			0 },
+    { "AREA$DEST",		KMP_AREA, 0x02,  GTMD_U8M1,	1,1,
+			"Returns the destination index (e.g. camera index) of an area.",
+			0 },
+    { "AREA$UNKNOWN",		KMP_AREA, 0x03,  GTMD_U8,	1,1,
+			"Returns the unknown value of an area.",
+			0 },
+    { "AREA$POS",		KMP_AREA, 0x04,  GTMD_DBL3,	1,1,
+			"Returns the position of an area.",
+			0 },
+    { "AREA$ROT",		KMP_AREA, 0x10,  GTMD_DBL3,	1,1,
+			"Returns the rotation of an area.",
+			0 },
+    { "AREA$SCALE",		KMP_AREA, 0x1c,  GTMD_DBL3,	1,1,
+			"Returns the scale of an area.",
+			0 },
+    { "AREA$SET",		KMP_AREA, 0x28,  GTMD_U16,	4,2,
+			"Returns setting 0..3 of an area.",
+			0 },
+
+    //---------------
+
+    { "CAME$N",			KMP_CAME,    0,  GTMD_N,	0,0,
+			"Returns the number of cameras.",
+			0 },
+     { "CAME$OCAM",		KMP_CAME,    0,  GTMD_HD_U8HI,	0,0,
+			"Returns the index of the opening camera.",
+			0 },
+     { "CAME$SCAM",		KMP_CAME,    0,  GTMD_HD_U8LO,	0,0,
+			"Returns the index of the selection camera.",
+			0 },
+    { "CAME$TYPE",		KMP_CAME, 0x00,  GTMD_U8,	1,1,
+			"Returns the type of a camera.",
+			0 },
+    { "CAME$NEXT",		KMP_CAME, 0x01,  GTMD_U8M1,	1,1,
+			"Returns -1 or the link to the next camera.",
+			0 },
+    { "CAME$UNKNOWN_02",	KMP_CAME, 0x02,  GTMD_U8,	1,1,
+			"Returns the unknown value at offser 0x02 of a camera.",
+			0 },
+    { "CAME$ROUTE",		KMP_CAME, 0x03,  GTMD_U8M1,	1,1,
+			"Returns -1 or the link to the related route.",
+			0 },
+    { "CAME$UNKNOWN_04",	KMP_CAME, 0x04,  GTMD_U16,	1,1,
+			"Returns the unknown value at offser 0x04 of a camera.",
+			0 },
+    { "CAME$ZOOM_SPEED",	KMP_CAME, 0x06,  GTMD_U16,	1,1,
+			"Returns the zoom speed in units per 100/60 sec.",
+			0 },
+    { "CAME$VIEWPT_SPEED",	KMP_CAME, 0x08,  GTMD_U16,	1,1,
+			"Returns the view point speed in units per 100/60 sec.",
+			0 },
+    { "CAME$UNKNOWN_0A",	KMP_CAME, 0x0a,  GTMD_U16,	1,1,
+			"Returns the unknown value at offser 0x0a of a camera.",
+			0 },
+    { "CAME$POS",		KMP_CAME, 0x0c,  GTMD_DBL3,	1,1,
+			"Returns the position of a camera.",
+			0 },
+    { "CAME$UNKNOWN_18",	KMP_CAME, 0x18,  GTMD_DBL3,	1,1,
+			"Returns the unknown value at offser 0x18 of a camera.",
+			0 },
+    { "CAME$ZOOM_BEGIN",	KMP_CAME, 0x24,  GTMD_DBL,	1,1,
+			"Returns the zoom beginning angle of a camera.",
+			0 },
+    { "CAME$ZOOM_END",		KMP_CAME, 0x28,  GTMD_DBL,	1,1,
+			"Returns the zoom ending angle of a camera.",
+			0 },
+    { "CAME$VIEWPT_BEGIN",	KMP_CAME, 0x2c,  GTMD_DBL3,	1,1,
+			"Returns the start position of the view point.",
+			0 },
+    { "CAME$VIEWPT_END",	KMP_CAME, 0x38,  GTMD_DBL3,	1,1,
+			"Returns the end position of the view point.",
+			0 },
+    { "CAME$TIME",		KMP_CAME, 0x44,  GTMD_DBL,	1,1,
+			"Returns the run time of a camera in 1/60 sec.",
+			0 },
+
+    //---------------
+
+    { "JGPT$N",			KMP_JGPT,    0,  GTMD_N,	0,0,
+			"Returns the number of respan points.",
+			0 },
+    { "JGPT$POS",		KMP_JGPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns the position of a respawn point.",
+			0 },
+    { "JGPT$ROT",		KMP_JGPT, 0x0c,  GTMD_DBL3,	1,1,
+			"Returns the rotation of a respawn point.",
+			0 },
+    { "JGPT$ID",		KMP_JGPT, 0x18,  GTMD_U16,	1,1,
+			"Returns the ID of a respawn point.",
+			0 },
+    { "JGPT$EFFECT",		KMP_JGPT, 0x1a,  GTMD_U16,	1,1,
+			"Returns the effect value of a respawn point.",
+			0 },
+
+    //---------------
+
+    { "CNPT$N",			KMP_CNPT,    0,  GTMD_N,	0,0,
+			"Returns the number of canon point points.",
+			0 },
+    { "CNPT$POS",		KMP_CNPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns the position of a canon point.",
+			0 },
+    { "CNPT$ROT",		KMP_CNPT, 0x0c,  GTMD_DBL3,	1,1,
+			"Returns the rotation of a canon point.",
+			0 },
+    { "CNPT$ID",		KMP_CNPT, 0x18,  GTMD_U16,	1,1,
+			"Returns the ID of a canon point.",
+			0 },
+    { "CNPT$EFFECT",		KMP_CNPT, 0x1a,  GTMD_U16,	1,1,
+			"Returns the efffect value of a canon point.",
+			0 },
+
+    //---------------
+
+    { "MSPT$N",			KMP_MSPT,    0,  GTMD_N,	0,0,
+			"Returns the number of battle points.",
+			0 },
+    { "MSPT$POS",		KMP_MSPT, 0x00,  GTMD_DBL3,	1,1,
+			"Returns the position of a battle point.",
+			0 },
+    { "MSPT$ROT",		KMP_MSPT, 0x0c,  GTMD_DBL3,	1,1,
+			"Returns the rotation of a battle point.",
+			0 },
+    { "MSPT$ID",		KMP_MSPT, 0x18,  GTMD_U16,	1,1,
+			"Returns the ID of a battle point.",
+			0 },
+    { "MSPT$EFFECT",		KMP_MSPT, 0x1a,  GTMD_U16,	1,1,
+			"Returns the efffect value of a battle point.",
+			0 },
+
+    //---------------
+
+    { "STGI$N",			KMP_STGI,    0,  GTMD_N,	0,0,
+			"Returns the number of stage infos.",
+			0 },
+    { "STGI$BYTE",		KMP_STGI, 0x00,  GTMD_U8,	12,2,
+			"Returns setting byte 0..11 of a stage info.",
+			0 },
+};
+
+#define KMP_FUNC_LIST_N (sizeof(kmp_func_list)/sizeof(*kmp_func_list))
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError F_get
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    const FuncParam_t	* fpar		// pointer to user parameter
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+    DASSERT(fpar);
+    DASSERT( fpar->user_id >= 0 && fpar->user_id < KMP_FUNC_LIST_N );
+
+    if ( si && si->kmp )
+    {
+	const kmp_func_t *fp = kmp_func_list + fpar->user_id;
+	DASSERT( n_param >= fp->n_param );
+	DASSERT( fp->sect < KMP_N_SECT );
+	DASSERT( fp->get_info );
+
+	const List_t *dlist = si->kmp->dlist + fp->sect;
+	uint max_index1 = dlist->used;
+	int val = n_param > 0 ? GetIntV(param) : 0;
+	uint index1 = val < 0 ? val + max_index1 : val;
+	const u8 *data = dlist->list + dlist->elem_size * index1 + fp->off;
+
+	if ( fp->sect == KMP_POTI && fp->off >= POTI_PT_OFF && index1 < max_index1 )
+	{
+	    param++;
+	    n_param--;
+
+	    const kmp_poti_group_t *pgrp = (kmp_poti_group_t*)dlist->list;
+	    uint pt_start = 0;
+	    while ( index1-- > 0 )
+		pt_start += (pgrp++)->n_point;
+
+	    dlist = &si->kmp->poti_point;
+	    max_index1 = pgrp->n_point;
+	    val = n_param > 0 ? GetIntV(param) : 0;
+	    index1 = val < 0 ? val + max_index1 : val;
+	    PRINT("POTI/PT: index= %u/%u  +%u\n",index1,max_index1,pt_start);
+	    data = dlist->list
+		 + dlist->elem_size * ( pt_start + index1 )
+		 + fp->off - POTI_PT_OFF;
+	}
+
+	val = n_param > 1 ? GetIntV(param+1) : 0;
+	const uint index2 = val < 0 ? val + fp->n_var : val;
+
+	const bool valid_index12 = index1 < max_index1 && index2 < fp->n_var;
+	noPRINT("index1=%d/%d, index2=%d/%d, valid=%d\n",
+		index1, max_index1, index2, fp->n_var, valid_index12 );
+
+	switch(fp->get_mode)
+	{
+	    case GTMD_N:
+		res->i = dlist->used;
+		res->mode = VAR_INT;
+		return ERR_OK;
+
+	    case GTMD_HD_U16:
+		res->i = si->kmp->value[fp->sect];
+		res->mode = VAR_INT;
+		return ERR_OK;
+
+	    case GTMD_HD_U8HI:
+		res->i = si->kmp->value[fp->sect] >> 8;
+		res->mode = VAR_INT;
+		return ERR_OK;
+
+	    case GTMD_HD_U8LO:
+		res->i = si->kmp->value[fp->sect] & 0xff;
+		res->mode = VAR_INT;
+		return ERR_OK;
+
+	    case GTMD_U8:
+	    case GTMD_U8M1:
+		if (valid_index12)
+		{
+		    const u8 val = data[index2];
+		    res->i = val == 0xff && fp->get_mode == GTMD_U8M1 ? -1 : (int)val;
+		    res->mode = VAR_INT;
+		    return ERR_OK;
+		}
+		break;
+
+	    case GTMD_U16:
+	    case GTMD_U16M1:
+		if (valid_index12)
+		{
+		    const u16 val = ((u16*)data)[index2];
+		    res->i = val == 0xffff && fp->get_mode == GTMD_U16M1
+				? -1 : (int)val;
+		    res->mode = VAR_INT;
+		    return ERR_OK;
+		}
+		break;
+
+	    case GTMD_DBL:
+		if (valid_index12)
+		    return ResultFloat( res, (float*)data + index2, 1 );
+		break;
+
+	    case GTMD_DBL2:
+		if (valid_index12)
+		    return ResultFloat( res, (float*)data + 2 * index2, 2 );
+		break;
+
+	    case GTMD_DBL3:
+		if (valid_index12)
+		    return ResultFloat( res, (float*)data + 3 * index2, 3 );
+		break;
+	}
+    }
+
+    res->i = 0;
+    res->mode = VAR_UNSET;
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+#ifdef TEST
+
+static enumError F_set
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    const FuncParam_t	* fpar		// pointer to user parameter
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+    DASSERT(fpar);
+    DASSERT( fpar->user_id >= 0 && fpar->user_id < KMP_FUNC_LIST_N );
+
+    if ( si && si->kmp )
+    {
+	const kmp_func_t *fp = kmp_func_list + fpar->user_id;
+	DASSERT( n_param >= fp->n_param );
+	DASSERT( fp->sect < KMP_N_SECT );
+	DASSERT( fp->set_info );
+
+	PRINT(">>> F_SET <<<\n");
+	// ...
+    }
+
+    res->i = 0;
+    res->mode = VAR_UNSET;
+    return ERR_OK;
+}
+
+#endif
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			  kmp_group_t			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void InitializeGL
+(
+    kmp_group_list_t	*gl,		// list to initialize
+    int			selector,
+    kmp_t		*kmp,		// related KMP
+    kmp_ph_t		*ph		// related PH info
+)
+{
+    DASSERT(gl);
+    DASSERT(kmp);
+    DASSERT(ph);
+
+    memset(gl,0,sizeof(*gl));
+    gl->kmp = kmp;
+    gl->ph  = ph;
+    gl->selector = toupper(selector);
+    InitializeLine(&gl->line);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static uint ScanGroupNames
+(
+    kmp_group_list_t	* gl,		// group list
+    kmp_group_elem_t	* elist,	// name list
+    ScanInfo_t		* si		// valid scan info
+)
+{
+    DASSERT(gl);
+    DASSERT(elist);
+    DASSERT(si);
+    ScanFile_t *sf = si->cur_file;
+    DASSERT(sf);
+
+    char name[KMP_MAX_NAME_LEN+3];
+
+    uint idx = 0;
+    while ( idx < KMP_MAX_PH_LINK )
+    {
+	const kmp_oneway_mode oneway
+		= NextCharSI(si,false) == '>' ? ONEWAY_BOTH : ONEWAY_NONE;
+	if ( oneway != ONEWAY_NONE )
+	    sf->ptr++;
+
+	ScanNameSI(si,name,sizeof(name),true,true,0);
+	if ( gl->selector && *sf->ptr == '!' )
+	{
+	    int ch = *++sf->ptr;
+	    if (ch)
+	    {
+		sf->ptr++;
+		if ( toupper(ch) != gl->selector )
+		    continue;
+	    }
+	}
+
+	uint n = 1;
+	if ( *sf->ptr == '*' )
+	{
+	    sf->ptr++;
+	    const uint num = *sf->ptr - '0';
+	    if ( num < 10 )
+	    {
+		sf->ptr++;
+		if ( gl->selector == 'E' )
+		    n = num;
+	    }
+	}
+
+	while ( n-- > 0 && idx < KMP_MAX_PH_LINK )
+	{
+	    memcpy(elist->name,name,sizeof(elist->name));
+	    elist->oneway = oneway;
+	    elist++;
+	    idx++;
+	}
+    }
+
+    return idx;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError GroupPrevGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si		// valid scan info
+)
+{
+    DASSERT(gl);
+    DASSERT(si);
+
+    if ( !gl->used)
+    {
+	GotoEolSI(si);
+	return ERR_OK;
+    }
+
+    SkipCharSI(si,':');
+    kmp_group_t *grp = gl->group + gl->used - 1;
+    ScanGroupNames(gl,grp->prev,si);
+    //HEXDUMP16(0,0,grp->prev,sizeof(grp->prev));
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError DefaultClassGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si		// valid scan info
+)
+{
+    DASSERT(gl);
+    DASSERT(gl->ph);
+    DASSERT(si);
+
+    char name[20];
+    SkipCharSI(si,':');
+    if (!ScanNameSI(si,name,sizeof(name),true,true,0))
+    {
+	GotoEolSI(si);
+	return ERR_WARNING;
+    }
+
+    int stat = InsertClassNamePH(gl->ph,name,false);
+    noPRINT("NEW DEFAULT CLASS: %d [%s]\n",stat,name);
+    if ( stat >= 0 )
+	gl->ph->default_class = stat;
+
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ClassGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// valid scan info
+    kmp_gopt2_t		* go2		// options to set
+)
+{
+    DASSERT(gl);
+    DASSERT(gl->ph);
+    DASSERT(si);
+
+    char name[20];
+    SkipCharSI(si,':');
+    if (!ScanNameSI(si,name,sizeof(name),true,true,0))
+    {
+	GotoEolSI(si);
+	return ERR_WARNING;
+    }
+
+    const int stat = InsertClassNamePH(gl->ph,name,false);
+    noPRINT("NEW CLASS: %d [%s]\n",stat,name);
+    if ( stat >= 0 )
+    {
+	go2->prev.rclass = go2->prev.lclass =
+	go2->next.rclass = go2->next.lclass = stat;
+
+	if ( SkipCharSI(si,',') && ScanNameSI(si,name,sizeof(name),true,true,0) )
+	{
+	    const int stat = InsertClassNamePH(gl->ph,name,false);
+	    noPRINT("NEW NEXT CLASS: %d [%s]\n",stat,name);
+	    if ( stat >= 0 )
+		go2->next.rclass = go2->next.lclass = stat;
+	}
+    }
+
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ACClassGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// valid scan info
+    kmp_gopt2_t		* go2,		// options to set
+    kmp_gopt_t		* gopt		// prev or next
+)
+{
+    DASSERT(gl);
+    DASSERT(gl->ph);
+    DASSERT(si);
+    DASSERT(gopt);
+
+    char name[20];
+    SkipCharSI(si,':');
+    if (!ScanNameSI(si,name,sizeof(name),true,true,0))
+    {
+	GotoEolSI(si);
+	return ERR_WARNING;
+    }
+
+    int stat = InsertClassNamePH(gl->ph,name,false);
+    noPRINT("NEW LINK CLASS: %d [%s]\n",stat,name);
+    if ( stat >= 0 )
+	gopt->lclass = stat;
+
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError GroupSettingsGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// valid scan info
+    kmp_gopt2_t		* go2		// options to set
+)
+{
+    DASSERT(gl);
+    DASSERT(si);
+    DASSERT(go2);
+
+    if (!gl->used)
+	return ERR_WARNING;
+
+    long set0 = 0, set1 = 0;
+    kmp_rtype_mode rtype = 0;
+
+    SkipCharSI(si,':');
+    enumError err = ScanUValueSI(si,&set0,0);
+    if ( !err && SkipCharSI(si,',') )
+    {
+	err = ScanUValueSI(si,&set1,0);
+	if ( !err && SkipCharSI(si,',') )
+	{
+	    char name[20];
+	    ScanNameSI(si,name,sizeof(name),true,true,0);
+	    int stat;
+	    const KeywordTab_t *key = ScanKeyword(&stat,name,kmp_rtype_name);
+	    if (!key)
+	    {
+		err = ERR_WARNING;
+		if (!si->no_warn)
+		    PrintKeywordError(kmp_rtype_name,name,stat,0,"$SETTINGS");
+	    }
+	    else
+		rtype = key->id;
+	}
+    }
+
+    go2->rtype_user = rtype;
+    go2->setting[0] = set0;
+    go2->setting[1] = set1;
+
+    noPRINT("\e[36;1m rtype %d, g-settings: %u 0x%02x [%d]\e[0m\n",
+		go2->rtype_user, go2->setting[0], go2->setting[1], err );
+    if (err)
+    {
+	GotoEolSI(si);
+	return err;
+    }
+
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError GroupOnewayGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// valid scan info
+    kmp_gopt2_t		* go2		// options to set
+)
+{
+    DASSERT(gl);
+    DASSERT(si);
+    DASSERT(go2);
+
+    if (!gl->used)
+	return ERR_WARNING;
+
+    SkipCharSI(si,':');
+
+    char name[20];
+    ScanNameSI(si,name,sizeof(name),true,true,0);
+    int stat;
+    const KeywordTab_t *key = ScanKeyword(&stat,name,kmp_oneway_name);
+    if (!key)
+    {
+	if (!si->no_warn)
+	    PrintKeywordError(kmp_oneway_name,name,stat,0,"$ONEWAY");
+	GotoEolSI(si);
+	return ERR_WARNING;
+    }
+
+    go2->ac_oneway = key->id;
+    return CheckEolSI(si);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError AddGroupGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// valid scan info
+    char		var_prefix,	// Prefix for var names
+    uint		index,		// index of first point
+    uint		n_dim		// Line_t support: number of dimensions
+)
+{
+    DASSERT(gl);
+    DASSERT(si);
+    ScanFile_t *sf = si->cur_file;
+    DASSERT(sf);
+
+    char name[KMP_MAX_NAME_LEN+3];
+    ScanNameSI(si,name,sizeof(name),true,true,0);
+
+    const bool split_group = !strcmp(name,"$SPLIT");
+    if (split_group)
+    {
+	if ( gl->ph && gl->ph->ac_mode != KMP_AC_PREV )
+	{
+	    si->total_err++;
+	    sf->line_err++;
+	    CheckEolSI(si);
+	    if (!si->no_warn)
+		ERROR0(ERR_WARNING,
+		    "Command '$SPLIT' only possible if AUTO-CONNECT is set to AC$PREV"
+		    " => ignored [%s @%u].\n", sf->name, sf->line );
+	    return ERR_WARNING;
+	}
+
+	if ( !gl->used || index == gl->group[gl->used-1].first_index )
+	{
+	    si->total_err++;
+	    sf->line_err++;
+	    CheckEolSI(si);
+	    if (!si->no_warn)
+		ERROR0(ERR_WARNING,
+		    "Command '$SPLIT' ignored [%s @%u].\n", sf->name, sf->line );
+	    return ERR_WARNING;
+	}
+    }
+    else if ( strcmp(name,"$GROUP") )
+    {
+	if ( !strcmp(name,"$PREV") )
+	    return GroupPrevGL(gl,si);
+	if (!strcmp(name,"$LINE"))
+	    return ScanLine(&gl->line,si,n_dim,LM_LINE);
+	if (!strcmp(name,"$BORDER"))
+	    return ScanLine(&gl->line,si,n_dim,LM_BORDER);
+	if (!strcmp(name,"$BEZIER"))
+	    return ScanLine(&gl->line,si,n_dim,LM_BEZIER);
+
+	if ( gl->ph )
+	{
+	    if ( !strcmp(name,"$DEF-CLASS") )
+		return DefaultClassGL(gl,si);
+
+	    if ( gl->used > 0 && gl->used <= KMP_MAX_GROUP )
+	    {
+		kmp_gopt2_t *go2 = gl->ph->gopt + gl->used - 1;
+		if ( !strcmp(name,"$SETTINGS") )
+		    return GroupSettingsGL(gl,si,go2);
+		if ( !strcmp(name,"$ONEWAY") )
+		    return GroupOnewayGL(gl,si,go2);
+		if ( !strcmp(name,"$CLASS") )
+		    return ClassGL(gl,si,go2);
+		if ( !strcmp(name,"$AC-PREV") )
+		    return ACClassGL(gl,si,go2,&go2->prev);
+		if ( !strcmp(name,"$AC-NEXT") )
+		    return ACClassGL(gl,si,go2,&go2->next);
+	    }
+	}
+
+	si->total_err++;
+	sf->line_err++;
+	CheckEolSI(si);
+	return ERROR0(ERR_WARNING,
+		"Line ignored [%s @%u]: %s ...\n",
+		sf->name, sf->line, name );
+    }
+
+    if ( gl->used >= KMP_MAX_GROUP )
+    {
+	si->total_err++;
+	sf->line_err++;
+	CheckEolSI(si);
+	return ERROR0(ERR_WARNING,
+		"To many groups, new group ignored: %s @%u\n",
+		sf->name, sf->line );
+    }
+
+
+    // before incrementing the group index
+    if (gl->ph)
+    {
+	noPRINT("NEW GROUP: %d, class %d\n",gl->used,gl->ph->default_class);
+	kmp_gopt2_t *go2 = gl->ph->gopt + gl->used;
+	go2->prev.rclass = go2->prev.lclass =
+	go2->next.rclass = go2->next.lclass = gl->ph->default_class;
+    }
+
+    // create new group by incrementing group index
+    kmp_group_t *grp = gl->group + gl->used++;
+    grp->first_index = grp->last_index = index;
+
+    if ( NextCharSI(si,false) == '-' )
+    {
+	sf->ptr++;
+	grp->no_rotate = true;
+    }
+
+    ScanNameSI(si,name+2,sizeof(name)-2,true,true,0);
+    memcpy(grp->name,name+2,sizeof(grp->name));
+    name[0] = var_prefix;
+    name[1] = '.';
+    DefineIntVar(&si->gvar,name,gl->used-1);
+
+    if (split_group)
+    {
+	kmp_group_t *prev = gl->group + gl->used - 2;
+	DASSERT( prev >= gl->group );
+	memcpy(grp->next,prev->next,sizeof(grp->next));
+	memset(prev->next,0,sizeof(prev->next));
+	memcpy(prev->next->name,name,sizeof(prev->next->name));
+
+	CheckEolSI(si);
+	return ERR_OK;
+    }
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,false);
+	noPRINT("--> %02x : %.6s\n",ch,sf->ptr);
+	if (!ch)
+	    break;
+	sf->ptr++;
+	if ( ch == ':' )
+	    break;
+    }
+
+    ScanGroupNames(gl,grp->next,si);
+    CheckEolSI(si);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static uint AddPointGL
+(
+    kmp_group_list_t	* gl,		// group list
+    uint		index		// index of first point
+)
+{
+    if (!gl->used)
+	gl->used++;
+
+    kmp_group_t *grp = gl->group + gl->used - 1;
+    grp->last_index = index;
+    return index - grp->first_index;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int SearchNearestDP
+(
+    kmp_group_list_t	* gl,		// group list
+    kmp_t		* kmp,		// KMP data structure
+    kmp_class_mode	cls,		// one of KCLS_*
+    const float		* base		// base position
+)
+{
+    DASSERT(gl);
+    DASSERT(kmp);
+    const kmp_ph_t *ph = gl->ph;
+    DASSERT(ph);
+    DASSERT( ph->sect_ph == KMP_ENPH || ph->sect_ph == KMP_ITPH );
+    DASSERT( ph->sect_pt == KMP_ENPT || ph->sect_pt == KMP_ITPT );
+
+    if ( cls == KCLS_OFF )
+	return -1;
+
+    int i, found = -1;
+    kmp_group_t *grp;
+    double found_distance = 0.0;
+
+    List_t *list = kmp->dlist + ph->sect_ph;
+    kmp_enph_entry_t *ph_list = (kmp_enph_entry_t*)(list->list);
+
+    for ( i = 0, grp = gl->group; i < gl->used; i++, grp++ )
+    {
+	const kmp_gopt2_t *go2 = ph->gopt + i;
+	if ( go2->rtype_active != KMP_RT_DISPATCH )
+	    continue;
+
+	kmp_class_mode dcls = go2->prev.rclass;
+	if ( dcls == KCLS_OFF || cls != dcls && cls != KCLS_ANY && dcls != KCLS_ANY )
+	    continue;
+
+	noPRINT("--- CANDIDATE %2u: rtype=%d>%d, class=%d,%d|%d,%d\n",
+			i,
+			go2->rtype_user, go2->rtype_active,
+			go2->prev.rclass, go2->prev.lclass,
+			go2->next.rclass, go2->next.lclass );
+
+	const kmp_enpt_entry_t *pt
+		= (kmp_enpt_entry_t*)kmp->dlist[ph->sect_pt].list
+		+ ph_list[i].pt_start;
+
+	const double dx =  pt->position[0] - base[0];
+	const double dy =  pt->position[1] - base[1];
+	const double dz =  pt->position[2] - base[2];
+	const double distance = dx*dx + dy*dy + dz*dz;
+
+	if ( found < 0 || distance < found_distance )
+	{
+	    found = i;
+	    found_distance = distance;
+	}
+    }
+
+    noPRINT("SearchNearestDP - return %d\n",found);
+    return found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void TermGL
+(
+    kmp_group_list_t	* gl,		// group list
+    ScanInfo_t		* si,		// not NULL: print error message
+    kmp_t		* kmp,		// KMP data structure
+    uint		sect_ph,	// PH section
+    int			rotate_links	// >0: rotate links um x positions
+)
+{
+    DASSERT(gl);
+    DASSERT(gl->ph);
+    DASSERT(kmp);
+    DASSERT( sect_ph == KMP_CKPH || sect_ph == KMP_ENPH || sect_ph == KMP_ITPH );
+
+    CheckLevelSI(si);
+    ResetRouteLinksKMP(kmp);
+    const bool auto_prev = gl->ph->ac_mode == KMP_AC_PREV;
+    memset(gl->ph->gname,0,sizeof(gl->ph->gname));
+
+    List_t *list = kmp->dlist + sect_ph;
+    list->used = 0;
+
+    uint i;
+    kmp_group_t *grp = gl->group;
+    for ( i = 0; i < gl->used; i++, grp++ )
+    {
+	kmp_enph_entry_t * entry = AppendList(list);
+	entry->pt_start = grp->first_index;
+	entry->pt_len = grp->last_index - grp->first_index + 1;
+
+	memset(entry->next,-1,sizeof(entry->next));
+	memset(entry->prev,-1,sizeof(entry->prev));
+	if ( i < KMP_MAX_GROUP )
+	    memcpy(gl->ph->gname+i,grp->name,sizeof(*gl->ph->gname));
+
+	kmp_rtype_mode rtype = gl->ph->gopt[i].rtype_user;
+	if ( rtype == KMP_RT_AUTO )
+	    rtype = IsDispatchPointKMP(entry) ? KMP_RT_DISPATCH : KMP_RT_ROUTE;
+	gl->ph->gopt[i].rtype_active = rtype;
+    }
+
+    rotate_links = rotate_links <= 0 ? 0 : rotate_links % KMP_MAX_PH_LINK;
+    PRINT_IF(rotate_links,"ROTATE-LINKS %d\n",rotate_links);
+
+    for ( i = 0, grp = gl->group; i < gl->used; i++, grp++ )
+    {
+	//--- NEXT links
+
+	uint l;
+	for ( l = 0; l < KMP_MAX_PH_LINK; l++ )
+	{
+	    const uint l2 = grp->no_rotate
+			? l
+			: ( l + rotate_links ) % KMP_MAX_PH_LINK;
+	    kmp_group_elem_t *elem =  grp->next+l2;
+	    ccp lname = elem->name;
+	    if (!*lname)
+		continue;
+
+	    noPRINT(">> '%s' links to '%s'\n",grp->name,lname);
+	    kmp_group_t *grp2 = gl->group;
+	    bool found = false;
+	    uint j;
+	    for ( j = 0; j < gl->used; j++, grp2++ )
+	    {
+		if (!strcmp(lname,grp2->name))
+		{
+		    found = true;
+
+		    kmp_enph_entry_t * entry;
+		    entry = (kmp_enph_entry_t*)(list->list) + i;
+		    InsertLinkPH(entry->next,j,si,lname,true);
+		    if (elem->oneway)
+			InsertOnewayPH(gl->ph,i,j);
+
+		    if ( auto_prev && !FindOnewayPH(gl->ph,i,j) )
+		    {
+			entry = (kmp_enph_entry_t*)(list->list) + j;
+			InsertLinkPH(entry->prev,i,si,lname,false);
+		    }
+		    break;
+		}
+	    }
+
+	    if ( !found && !si->no_warn )
+		ERROR0(ERR_WARNING,
+			"%s group %s: $GROUP name not found: %s",
+			kmp_section_name[gl->ph->sect_pt].name1, grp->name, lname);
+	}
+
+	//--- PREV links
+
+	if (!auto_prev)
+	{
+	    for ( l = 0; l < KMP_MAX_PH_LINK; l++ )
+	    {
+		kmp_group_elem_t *elem = grp->prev+l;
+		ccp lname = elem->name;
+		if (!*lname)
+		    continue;
+
+		noPRINT(">> '%s' links to '%s'\n",grp->name,lname);
+		kmp_group_t *grp2 = gl->group;
+		bool found = false;
+		uint j;
+		for ( j = 0; j < gl->used; j++, grp2++ )
+		{
+		    if (!strcmp(lname,grp2->name))
+		    {
+			found = true;
+
+			kmp_enph_entry_t * entry;
+			entry = (kmp_enph_entry_t*)(list->list) + i;
+			InsertLinkPH(entry->prev,j,si,lname,true);
+			if (elem->oneway)
+			    InsertOnewayPH(gl->ph,i,j);
+			break;
+		    }
+		}
+
+		if ( !found && !si->no_warn )
+		    ERROR0(ERR_WARNING,
+			    "%s group %s: $PREV name not found: %s",
+			    kmp_section_name[gl->ph->sect_pt].name1, grp->name, lname);
+	    }
+	}
+    }
+
+
+    //--- @AUTO-CONNECT == AC$DISPATCH
+
+    kmp_ph_t *ph = gl->ph;
+    DASSERT(ph);
+
+    if ( ph && ph->ac_mode == KMP_AC_DISPATCH
+		&& ( sect_ph == KMP_ENPH || sect_ph == KMP_ITPH ))
+    {
+
+	//--- standard routes
+
+	const kmp_linfo_t *li = SetupRouteLinksKMP(kmp,sect_ph,true);
+
+	for ( i = 0, grp = gl->group; i < gl->used; i++, grp++ )
+	{
+	    const kmp_gopt2_t *go2 = ph->gopt + i;
+	    if ( go2->rtype_active == KMP_RT_DISPATCH )
+		continue;
+
+	    PRINT(">>> STDROUTE %2u: %d %s, rtype=%d>%d, oneway=%d, class=%d,%d|%d,%d\n",
+			i, li->gmode[i] & LINFOG_DISPATCH,
+			PrintLinkInfoMode(li->summary[i],1,true),
+			go2->rtype_user, go2->rtype_active,
+			go2->ac_oneway,
+			go2->prev.rclass, go2->prev.lclass,
+			go2->next.rclass, go2->next.lclass );
+
+	    kmp_enph_entry_t *entry = (kmp_enph_entry_t*)(list->list) + i;
+	    const kmp_linfo_mode mode = li->summary[i];
+
+	    if ( !(mode & LINFO_G_PREV) && go2->prev.lclass != KCLS_OFF )
+	    {
+		noPRINT("-> SEARCH PREV, CLASS %d\n",go2->prev.lclass);
+		const kmp_enpt_entry_t *pt
+			= (kmp_enpt_entry_t*)kmp->dlist[li->sect_pt].list
+			+ entry->pt_start;
+		const int dp = SearchNearestDP(gl,kmp,go2->prev.lclass,pt->position);
+		if ( dp >= 0 )
+		{
+		    kmp_enph_entry_t *entry = (kmp_enph_entry_t*)(list->list) + i;
+		    InsertLinkPH(entry->prev,dp,0,0,false);
+		    if ( go2->ac_oneway & ONEWAY_PREV )
+			InsertOnewayPH(ph,i,dp);
+		}
+	    }
+
+	    if ( !(mode & LINFO_G_NEXT) && go2->next.lclass != KCLS_OFF )
+	    {
+		noPRINT("-> SEARCH NEXT, CLASS %d\n",go2->prev.lclass);
+		const kmp_enpt_entry_t *pt
+			= (kmp_enpt_entry_t*)kmp->dlist[li->sect_pt].list
+			+ entry->pt_start + entry->pt_len - 1;
+		const int dp = SearchNearestDP(gl,kmp,go2->prev.lclass,pt->position);
+		if ( dp >= 0 )
+		{
+		    kmp_enph_entry_t *entry = (kmp_enph_entry_t*)(list->list) + i;
+		    InsertLinkPH(entry->next,dp,0,0,false);
+		    if ( go2->ac_oneway & ONEWAY_NEXT )
+			InsertOnewayPH(ph,i,dp);
+		}
+	    }
+	}
+
+
+	//--- dispatch points
+
+	li = SetupRouteLinksKMP(kmp,sect_ph,true);
+
+	for ( i = 0, grp = gl->group; i < gl->used; i++, grp++ )
+	{
+	    const kmp_gopt2_t *go2 = ph->gopt + i;
+	    if ( go2->rtype_active != KMP_RT_DISPATCH || go2->next.lclass == KCLS_OFF )
+		continue;
+
+	    PRINT(">>> DISPATCH %2u: %d %s, rtype=%d>%d, oneway=%d, class=%d,%d|%d,%d\n",
+			i, li->gmode[i] & LINFOG_DISPATCH,
+			PrintLinkInfoMode(li->summary[i],1,true),
+			go2->rtype_user, go2->rtype_active,
+			go2->ac_oneway,
+			go2->prev.rclass, go2->prev.lclass,
+			go2->next.rclass, go2->next.lclass );
+
+	    const kmp_linfo_mode mode = li->summary[i];
+	    if ( mode & (LINFO_G_PREV|LINFO_G_NEXT) )
+		continue; // mode already set
+
+	    kmp_enph_entry_t *entry = (kmp_enph_entry_t*)(list->list) + i;
+	    const kmp_linfo_mode *l = li->list[i];
+
+	    uint j;
+	    for ( j = 0; j < li->used; j++, l++ )
+		if ( *l & (LINFO_G_BY_PREV|LINFO_G_BY_NEXT) && !FindOnewayPH(ph,j,i) )
+		    InsertLinkPH(entry->next,j,0,0,false);
+	}
+    }
+
+
+    //--- fix empty link lists
+
+    if ( ph->ac_flags & KMP_ACF_FIX )
+    {
+	const int fix_prev = ph->ac_flags & KMP_ACF_FIX_PREV;
+	const int fix_next = ph->ac_flags & KMP_ACF_FIX_NEXT;
+	kmp_enph_entry_t *entry = (kmp_enph_entry_t*)list->list;
+
+	for ( i = 0; i < gl->used; i++, entry++ )
+	{
+	    if ( fix_prev && entry->prev[0] == M1(entry->prev[0]) )
+		entry->prev[0] = i;
+	    if ( fix_next && entry->next[0] == M1(entry->next[0]) )
+		entry->next[0] = i;
+	}
+    }
+
+    ResetRouteLinksKMP(kmp); // invalidate link-info because modified
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			more kmp functions		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static int get_next
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    int			user_id,	// user defined id
+    int			* cur_idx	// not NULL: store current index here
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+    DASSERT(n_param>=1);
+    DASSERT( user_id == KMP_ENPT || user_id == KMP_ITPT );
+
+    // [[2do]] use GetNextPointKMP()
+
+    if (cur_idx)
+	*cur_idx = -1;
+
+    int idx = GetIntV(param);
+    res->i = 0;
+    res->mode = VAR_UNSET;
+
+    if ( si && si->kmp )
+    {
+	const kmp_t *kmp = si->kmp;
+
+	const List_t *ptlist, *phlist;
+	if ( user_id == KMP_ENPT )
+	{
+	    ptlist = kmp->dlist + KMP_ENPT;
+	    phlist = kmp->dlist + KMP_ENPH;
+	}
+	else
+	{
+	    ptlist = kmp->dlist + KMP_ITPT;
+	    phlist = kmp->dlist + KMP_ITPH;
+	}
+
+	if ( idx < 0 )
+	    idx += ptlist->used;
+
+	if ( idx >= 0 && idx < ptlist->used )
+	{
+	    if (cur_idx)
+		*cur_idx = idx;
+
+	    const kmp_enph_entry_t *ph = (kmp_enph_entry_t*)phlist->list;
+	    uint n = phlist->used;
+	    while ( idx >= ph->pt_start + ph->pt_len && n-- > 0 )
+		ph++;
+
+	    noPRINT(">> %u %zu[%u+%u]\n", idx,
+			ph-(kmp_enph_entry_t*)phlist->list,ph->pt_start,ph->pt_len);
+	    if ( idx == ph->pt_start + ph->pt_len - 1 )
+	    {
+		idx = -1; // invalidate
+		uint ph_idx = ~0;
+
+		if ( n_param > 1 )
+		{
+		    uint idx2 = GetIntV(param+1);
+		    if ( idx2 < KMP_MAX_PH_LINK )
+			ph_idx = ph->next[idx2];
+		}
+		else
+		{
+		    uint idx2;
+		    for ( idx2 = 0; idx2 < KMP_MAX_PH_LINK; idx2++ )
+		    {
+			if (!IS_M1(ph->next[idx2]))
+			{
+			    ph_idx = ph->next[idx2];
+			    break;
+			}
+		    }
+		}
+
+		if ( ph_idx < phlist->used )
+		{
+		    ph = (kmp_enph_entry_t*)phlist->list + ph_idx;
+		    idx = ph->pt_start;
+		}
+	    }
+	    else
+		idx++;
+
+	    if ( idx >= 0 && idx < ptlist->used )
+		return idx;
+	}
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError F_get_next
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    const FuncParam_t	* fpar		// pointer to user parameter
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+    DASSERT(n_param>=1);
+    DASSERT(fpar);
+    DASSERT( fpar->user_id == KMP_ENPT || fpar->user_id == KMP_ITPT );
+
+    int next = get_next(res,param,n_param,si,fpar->user_id,0);
+    if ( next >= 0 )
+    {
+	res->i = next;
+	res->mode = VAR_INT;
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError F_get_hdir
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    const FuncParam_t	* fpar		// pointer to user parameter
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+    DASSERT(n_param>=1);
+    DASSERT(fpar);
+    DASSERT( fpar->user_id == KMP_ENPT || fpar->user_id == KMP_ITPT );
+
+    int current;
+    int next = get_next(res,param,n_param,si,fpar->user_id,&current);
+    if ( next >= 0 )
+    {
+	DASSERT(si);
+	const kmp_t *kmp = si->kmp;
+	DASSERT(kmp);
+
+	const kmp_enpt_entry_t *pt = (kmp_enpt_entry_t*)kmp->dlist[fpar->user_id].list;
+	res->d = atan2( pt[next].position[0] - pt[current].position[0],
+			pt[next].position[2] - pt[current].position[2] ) * (180/M_PI);
+	res->mode = VAR_DOUBLE;
+    }
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError F_isKMP
+(
+    struct Var_t	* res,		// store result here
+    struct Var_t	* param,	// parameters, modified
+    uint		n_param,	// number of parameters
+    struct ScanInfo_t	* si,		// not NULL: use for error messages
+    const FuncParam_t	* fpar		// pointer to user parameter
+)
+{
+    DASSERT(res);
+    DASSERT(param);
+
+    uint result = 0;
+    if ( si && si->kmp )
+    {
+	result = 1;
+
+	if (si->kmp->fname)
+	{
+	    ccp fname = strrchr(si->kmp->fname,'/');
+	    if (fname)
+		fname++;
+	    else
+		fname = si->kmp->fname;
+
+	    if ( !strcasecmp(fname,"course.kmp")
+		|| !strcasecmp(fname,"course.txt")
+		|| !strcasecmp(fname,"course.txt.kmp") )
+	    {
+		result = 2;
+	    }
+	}
+    }
+
+    res->i    = result;
+    res->mode = VAR_INT;
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static const struct FuncTable_t kmp_func_tab[] =
+{
+    { 1, 2, "ENPT$NEXT", F_get_next, KMP_ENPT,
+	"int", "enpt$next(enpt_index[,next_index])",
+	"Returns the index of the next enemy point."
+	" The 'next_index' is only used, if multiple links are available." },
+
+    { 1, 2, "ITPT$NEXT", F_get_next, KMP_ITPT,
+	"int", "itpt$next(itpt_index[,next_index])",
+	"Returns the index of the next item point."
+	" The 'next_index' is only used, if multiple links are available." },
+
+    { 1, 2, "ENPT$HDIR", F_get_hdir, KMP_ENPT,
+	"float", "enpt$hDir(enpt_index[,next_index])",
+	"Calculate the horizontal direction in degree of an enemy point."
+	" The 'next_index' is only used, if multiple links are available." },
+
+    { 1, 2, "ITPT$HDIR", F_get_hdir, KMP_ITPT,
+	"float", "itpt$hDir(itpt_index[,next_index])",
+	"Calculate the horizontal direction in degree of an item point."
+	" The 'next_index' is only used, if multiple links are available." },
+
+    { 0, 0, "ISKMP", F_isKMP, 0,	// replace only function call
+	"int", "isKMP()", 0 },		// but not info
+
+    {0,0,0,0,0,0,0,0}
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			setup kmp parser		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+const VarMap_t * SetupVarsKMP()
+{
+    static VarMap_t vm = {0};
+    if (!vm.used)
+    {
+	//--- setup parser function get()
+
+	uint i;
+	const kmp_func_t *fp = kmp_func_list;
+	for ( i = 0; i < KMP_FUNC_LIST_N; i++, fp++ )
+	{
+	  char syntax[80];
+	  if ( fp->get_info)
+	  {
+	    DefineParserFunc(fp->name,fp->n_param,fp->n_param,FF_KMP,F_get,i);
+
+	    ccp retval = fp->get_mode == GTMD_DBL
+				? "float"
+				: fp->get_mode > GTMD_DBL
+					? "vector"
+					: "int";
+	    char *dest = syntax;
+	    ccp src = fp->name;
+	    while (*src)
+		*dest++ = tolower((int)*src++);
+	    *dest++ = '(';
+	    if ( fp->n_param > 0 )
+	    {
+		src = fp->sect == KMP_POTI ? "route" : kmp_section_name[fp->sect].name1;
+		while (*src)
+		    *dest++ = tolower((int)*src++);
+
+		switch(fp->n_param)
+		{
+		    case 1:
+			src = "_idx";
+			break;
+
+		    case 2:
+			src = fp->sect == KMP_POTI && fp->off >= POTI_PT_OFF
+				    ? "_idx,pt_idx"
+				    : "_idx,val_idx";
+			break;
+
+		    case 3:
+			src = "_idx,pt_idx,val_idx";
+			break;
+
+		};
+		while (*src)
+		    *dest++ = *src++;
+	    }
+	    *dest++ = ')';
+	    *dest = 0;
+	    DASSERT(dest < syntax + sizeof(syntax) );
+
+	    DefineParserFuncInfo(retval,syntax,fp->get_info);
+	  }
+
+    #ifdef TEST // [[2do]]
+	  if (fp->set_info)
+	  {
+	    char namebuf[40];
+	    StringCat2S(namebuf,sizeof(namebuf),"SET_",fp->name);
+	    DefineParserFunc(namebuf,fp->n_param+1,fp->n_param+1,FF_KMP,F_set,i);
+
+	    char *dest = syntax;
+	    ccp src = namebuf;
+	    while (*src)
+		*dest++ = tolower((int)*src++);
+	    *dest++ = '(';
+	    if ( fp->n_param > 0 )
+	    {
+		src = fp->sect == KMP_POTI ? "route" : kmp_section_name[fp->sect].name1;
+		while (*src)
+		    *dest++ = tolower((int)*src++);
+
+		switch(fp->n_param)
+		{
+		    case 1:
+			src = "_idx";
+			break;
+
+		    case 2:
+			src = fp->sect == KMP_POTI && fp->off >= POTI_PT_OFF
+				    ? "_idx,pt_idx"
+				    : "_idx,val_idx";
+			break;
+
+		    case 3:
+			src = "_idx,pt_idx,val_idx";
+			break;
+
+		};
+		while (*src)
+		    *dest++ = *src++;
+	    }
+	    DASSERT(dest < syntax + sizeof(syntax) );
+	    StringCopyE(dest,syntax+sizeof(syntax),",value)");
+	    DefineParserFuncInfo("int",syntax,fp->set_info);
+	  }
+    #endif
+	}
+
+
+	//--- setup additional functions
+
+	DefineParserFuncTab(kmp_func_tab,FF_KMP);
+	SetupReferenceKCL(&vm);
+
+
+	//--- setup object names
+
+	DefineObjectNameVars(&vm);
+
+
+	//--- setup KMP section names
+
+	char varname[50];
+	const KeywordTab_t *key;
+	for ( key = kmp_section_name; key->name2; key++ )
+	{
+	    snprintf(varname,sizeof(varname),"SECT$%s",key->name1);
+	    DefineIntVar(&vm,varname,key->id+1);
+	}
+
+
+	//--- setup integer variables
+
+	struct inttab_t { ccp name; int val; };
+	static const struct inttab_t inttab[] =
+	{
+	    { "MODE$SLOT",		0 },
+	    { "MODE$D",			0 },
+
+	    { "MODE$TEST",		0 },
+	    { "MODE$OCAM",		0 },
+	    { "MODE$LAPS",		3 },
+	    { "MODE$SHOWRT",		0 },
+	    { "MODE$SHOWCK",		0 },
+	    { "MODE$AUTOMODE",		0 },
+
+	    { "AC$OFF",			KMP_AC_OFF },
+	    { "AC$PREV",		KMP_AC_PREV },
+	    { "AC$DISPATCH",		KMP_AC_DISPATCH },
+	    { "ACF$FIX_PREV",		KMP_ACF_FIX_PREV },
+	    { "ACF$FIX_NEXT",		KMP_ACF_FIX_NEXT },
+	    { "ACF$FIX",		KMP_ACF_FIX },
+
+	    { "AM$OFF",			KMP_AM_OFF },
+	    { "AM$NORM",		KMP_AM_NORM },
+	    { "AM$RENUMBER",		KMP_AM_RENUMBER },
+	    { "AM$1LAP",		KMP_AM_1_LAP },
+	    { "AM$SHORT",		KMP_AM_SHORT },
+	    { "AM$UNLIMIT",		KMP_AM_UNLIMIT },
+
+	    { "SORT$OFF",		KMP_SORT_OFF },
+	    { "SORT$GROUPING",		KMP_SORT_GROUPING },
+	    { "SORT$ANGLE",		KMP_SORT_ANGLE },
+	    { "SORT$TINY",		KMP_SORT_TINY },
+
+	    { "DOB$OFF",		KMP_DOB_OFF },
+	    { "DOB$BEGIN",		KMP_DOB_BEGIN },
+	    { "DOB$END",		KMP_DOB_END },
+	    { "DOB$BEFORE",		KMP_DOB_BEFORE },
+	    { "DOB$BEHIND",		KMP_DOB_BEHIND },
+
+	    { "EN$BATTLE",		ENGM_BATTLE },
+	    { "EN$50",			ENGM_50 },
+	    { "EN$100",			ENGM_100 },
+	    { "EN$150",			ENGM_150 },
+	    { "EN$200",			ENGM_200 },
+	    { "EN$150M",		ENGM_150M },
+	    { "EN$200M",		ENGM_200M },
+	     { "EN$150X",		ENGM_150M | ENGM_150 },
+	     { "EN$200X",		ENGM_200M | ENGM_200 },
+	     { "EN$MIRROR",		ENGM_150M | ENGM_200M },
+	     { "EN$ALL",		ENGM__ALL },
+
+	    { "F$FALL",			KPFL_FALL },
+	    { "F$SNAP",			KPFL_SNAP },
+	    { "F$JGPT",			KPFL_JGPT },
+
+	    { "ITEM$RANDOM",		0x00 },
+	    { "ITEM$BANANA",		0x01 },
+	    { "ITEM$MUSHROOM",		0x02 },
+	    { "ITEM$3MUSHROOMS",	0x03 },
+	    { "ITEM$STAR",		0x04 },
+	    { "ITEM$3GREEN",		0x05 },
+	    { "ITEM$BANANA_MUSHROOM",	0x06 },
+	    { "ITEM$GREEN",		0x07 },
+	    { "ITEM$RED",		0x08 },
+	    { "ITEM$MEGA",		0x0a },
+	    { "ITEM$CLOUD",		0x0b },
+	    { "ITEM$STAR_MUSHROOM",	0x0c },
+	    { "ITEM$MUSHROOM_GREEN",	0x0d },
+	    { "ITEM$3BANANAS_GREEN",	0x24 },
+
+	    { "PF$OFFLINE1",		0x01 },
+	    { "PF$OFFLINE2",		0x02 },
+	    { "PF$OFFLINE3",		0x04 },
+	    { "PF$OFFLINE",		0x07 },
+	    { "PF$ONLINE1",		0x08 },
+	    { "PF$ONLINE2",		0x10 },
+	    { "PF$ONLINE3",		0x20 },
+	    { "PF$ONLINE",		0x38 },
+	    { "PF$ALL",			0x3f },
+
+	    {0,0}
+	};
+
+	const struct inttab_t * ip;
+	for ( ip = inttab; ip->name; ip++ )
+	    DefineIntVar(&vm,ip->name,ip->val);
+
+
+	//--- extended p-flags
+
+	char name[20];
+	const gobj_cond_ref_t *rc;
+	for ( rc = cond_ref_tab; rc->ref_id; rc++ )
+	{
+	    ccp prefix = rc->option & 4 ? "IFDEV$" : "IF$";
+	    StringCat2S(name,sizeof(name),prefix,rc->name);
+	    DefineIntVar(&vm,name,rc->ref_id);
+
+	    if (rc->alias[0])
+	    {
+		StringCat2S(name,sizeof(name),prefix,rc->alias);
+		DefineIntVar(&vm,name,rc->ref_id);
+	    }
+
+	    if ( rc->cond_mask && !(rc->option & 4) )
+	    {
+		StringCat2S(name,sizeof(name),"C$",rc->name);
+		DefineIntVar(&vm,name,rc->cond_mask);
+
+		if (rc->alias[0])
+		{
+		    StringCat2S(name,sizeof(name),"C$",rc->alias);
+		    DefineIntVar(&vm,name,rc->cond_mask);
+		}
+	    }
+	}
+
+
+	//--- setup basic parser variables
+
+	DefineParserVars(&vm);
+    }
+
+    return &vm;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			kcl fall helpers		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[kcl_fall_t]]
+
+typedef struct kcl_fall_t
+{
+    //--- input
+
+    kcl_t	*fall_kcl;		// KCL to use, never NULL if 'kf->valid'
+
+    int		width;			// input for "KCL-FALL-WIDTH"
+    Var_t	pre_add;		// input for "KCL-FALL-PRE-ADD"
+    Var_t	post_add;		// input for "KCL-FALL-POST-ADD"
+    u32		types;			// input for "KCL-FALL-TYPES"
+
+    //---- status
+
+    bool	valid;			// true: calculation can be done
+
+} kcl_fall_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define KCL_FALL_VARS(k,v) \
+	{ "KCL-FALL-ADD-ROAD",	SPM_BOOL, &k->enable_fall_kcl }, \
+	{ "KCL-FALL-WIDTH",	SPM_INT,  &v.width }, \
+	{ "KCL-FALL-PRE-ADD",	SPM_VAR,  &v.pre_add }, \
+	{ "KCL-FALL-POST-ADD",	SPM_VAR,  &v.post_add }, \
+	{ "KCL-FALL-TYPES",	SPM_U32,  &v.types },
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetKclFall ( kcl_fall_t *kf )
+{
+    DASSERT(kf);
+    memset(kf,0,sizeof(*kf));
+    kf->types = M1(kf->types);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool CheckKclFall ( kcl_fall_t *kf )
+{
+    DASSERT(kf);
+
+    kf->fall_kcl = 0;
+    kf->valid = kf->width > 0 && kf->types;
+    if (kf->valid)
+    {
+	ToVectorYV(&kf->pre_add);
+	ToVectorYV(&kf->post_add);
+
+	kf->fall_kcl = GetReferenceKCL();
+	if (!kf->fall_kcl)
+	    kf->valid = false;
+    }
+    return kf->valid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void CalcKclFall ( kcl_fall_t *kf, float *vector )
+{
+    DASSERT(kf);
+    if (kf->valid)
+    {
+	DASSERT(kcl_ref);
+	DASSERT(kf->fall_kcl);
+
+	double3 pt;
+	pt.x = vector[0] + kf->pre_add.x;
+	pt.y = vector[1] + kf->pre_add.y;
+	pt.z = vector[2] + kf->pre_add.z;
+	double temp = FallKCL(kf->fall_kcl,0,pt,kf->width,0,kf->types,0);
+	if ( temp >= 0.0 &&  temp < pt.y )
+	{
+	    vector[0] = kf->post_add.x + pt.x;
+	    vector[1] = kf->post_add.y + temp;
+	    vector[2] = kf->post_add.z + pt.z;
+	}
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			route object helpers		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[rtobj_info_t]]
+
+typedef struct rtobj_info_t
+{
+    //--- input
+
+    int			route_object;		// input for "ROUTE-OBJECT"
+    Var_t		route_shift;		// input for "ROUTE-OBJECT-SHIFT"
+    Var_t		route_scale;		// input for "ROUTE-OBJECT-SCALE"
+    Var_t		route_rotate;		// input for "ROUTE-OBJECT-ROTATE"
+    int			show_route;		// input for "SHOW-ROUTE"
+    int			route_itembox;		// input for "ROUTE-ITEMBOX"
+
+    //--- data
+
+    kmp_rtobj_t		*def_obj;		// default object
+    kmp_rtobj_t		rtobj;			// resulting data
+    bool		valid;			// true: rtobj is set
+
+} rtobj_info_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define ROUTE_OBJECT_VARS(v) \
+	{ "ROUTE-OBJECT",	SPM_INT, &v.route_object }, \
+	{ "ROUTE-OBJECT-SHIFT",	SPM_VAR, &v.route_shift }, \
+	{ "ROUTE-OBJECT-SCALE",	SPM_VAR, &v.route_scale }, \
+	{ "ROUTE-OBJECT-ROTATE",SPM_VAR, &v.route_rotate }, \
+	{ "SHOW-ROUTE",		SPM_INT, &v.show_route }, \
+	{ "ROUTE-ITEMBOX",	SPM_INT, &v.route_itembox },
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetRouteInfo ( rtobj_info_t *ri, kmp_rtobj_t *def_obj )
+{
+    DASSERT(ri);
+    DASSERT(def_obj);
+
+    memset(ri,0,sizeof(*ri));
+    ri->def_obj		= def_obj;
+    memcpy(&ri->rtobj,ri->def_obj,sizeof(ri->rtobj));
+    ri->route_object	= N_KMP_GOBJ;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool CheckRouteInfo ( rtobj_info_t *ri )
+{
+    DASSERT(ri);
+    DASSERT(ri->def_obj);
+    noPRINT_IF( ri->route_object != N_KMP_GOBJ,
+		">> CheckRouteInfo() obj=%d, shrt=%d\n",
+		ri->route_object, ri->show_route );
+
+    if (!ri->route_object)
+	ri->rtobj.obj = 0;
+    else if ( ri->route_object < 0 )
+    {
+	memcpy(&ri->rtobj,ri->def_obj,sizeof(ri->rtobj));
+	ri->show_route = 1;
+    }
+    else if ( ri->route_object < N_KMP_GOBJ )
+    {
+	ri->rtobj.obj = ri->route_object;
+	ri->show_route = 1;
+    }
+    ri->route_object = N_KMP_GOBJ;
+
+    if ( ri->route_shift.mode != VAR_UNSET )
+    {
+	ri->rtobj.shift = GetVectorFV(&ri->route_shift);
+	ri->route_shift.mode = VAR_UNSET;
+    }
+
+    if ( ri->route_scale.mode != VAR_UNSET )
+    {
+	ri->rtobj.scale = GetVectorFV(&ri->route_scale);
+	ri->route_scale.mode = VAR_UNSET;
+    }
+
+    if ( ri->route_rotate.mode != VAR_UNSET )
+    {
+	ri->rtobj.rotate = GetVectorFV(&ri->route_rotate);
+	ri->route_rotate.mode = VAR_UNSET;
+    }
+
+    if ( ri->show_route > 0 && !ri->rtobj.obj )
+	ri->rtobj.obj = ri->def_obj->obj;
+
+    if ( ri->route_itembox > 0 && !ri->valid )
+    {
+	ri->show_route = 1;
+	ri->rtobj.obj = GOBJ_ITEMBOX;
+    }
+
+    ri->valid = ri->show_route > 0 && ri->rtobj.obj;
+    return ri->valid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool AssignRouteInfo ( rtobj_info_t *ri, kmp_rtobj_t *dest )
+{
+    DASSERT(ri);
+    DASSERT(dest);
+    if (ri->valid)
+	memcpy(dest,&ri->rtobj,sizeof(*dest));
+    else
+	memset(dest,0,sizeof(*dest));
+
+    return ri->valid;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			transform pos helpers		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[tform_info_t]]
+
+typedef struct tform_info_t
+{
+    //--- input
+
+    int			reset;		// input for "TFORM-RESET"
+    Var_t		scale;		// input for "TFORM-SCALE"
+    Var_t		shift;		// input for "TFORM-SHIFT"
+    Var_t		rotate;		// input for "TFORM-ROTATE"
+    Var_t		translate;	// input for "TFORM-TRANSLATE"
+
+
+    //--- data
+
+    bool		active;		// transformation is active
+    MatrixD_t		matrix;		// transformation matrix;
+
+} tform_info_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define TFORM_VARS(v) \
+	{ "TFORM-RESET",	SPM_INC, &v.reset }, \
+	{ "TFORM-SCALE",	SPM_VAR, &v.scale }, \
+	{ "TFORM-SHIFT",	SPM_VAR, &v.shift }, \
+	{ "TFORM-ROTATE",	SPM_VAR, &v.rotate }, \
+	{ "TFORM-TRANSLATE",	SPM_VAR, &v.translate }, \
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ResetTformInfo ( tform_info_t *ti )
+{
+    DASSERT(ti);
+
+    memset(ti,0,sizeof(*ti));
+    InitializeMatrixD(&ti->matrix);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool CheckTformInfo ( tform_info_t *ti )
+{
+    DASSERT(ti);
+
+    if (ti->reset)
+    {
+	PRINT("#TFORM: RESET(%d)\n",ti->reset);
+	ti->reset = 0;
+	ti->active = false;
+	InitializeMatrixD(&ti->matrix);
+    }
+
+    if ( ti->scale.mode != VAR_UNSET )
+    {
+	double3 d = GetVectorV(&ti->scale);
+	PRINT("#TFORM: SCALE %g %g %g\n",d.x,d.y,d.z);
+	SetScaleMatrixD(&ti->matrix,&d,0);
+	ti->scale.mode = VAR_UNSET;
+	ti->active = true;
+    }
+
+    if ( ti->shift.mode != VAR_UNSET )
+    {
+	double3 d = GetVectorV(&ti->shift);
+	PRINT("#TFORM: SHIFT %g %g %g\n",d.x,d.y,d.z);
+	SetShiftMatrixD(&ti->matrix,&d);
+	ti->shift.mode = VAR_UNSET;
+	ti->active = true;
+    }
+
+    if ( ti->rotate.mode != VAR_UNSET )
+    {
+	double3 d = GetVectorV(&ti->rotate);
+	PRINT("#TFORM: ROTATE %g %g %g\n",d.x,d.y,d.z);
+	SetRotateMatrixD(&ti->matrix,0,d.x,0.0,0);
+	SetRotateMatrixD(&ti->matrix,1,d.y,0.0,0);
+	SetRotateMatrixD(&ti->matrix,2,d.z,0.0,0);
+	ti->rotate.mode = VAR_UNSET;
+	ti->active = true;
+    }
+
+    if ( ti->translate.mode != VAR_UNSET )
+    {
+	double3 d = GetVectorV(&ti->translate);
+	PRINT("#TFORM: TRANSLATE %g %g %g\n",d.x,d.y,d.z);
+	SetTranslateMatrixD(&ti->matrix,&d);
+	ti->translate.mode = VAR_UNSET;
+	ti->active = true;
+    }
+
+    return ti->active;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void TransformPos ( tform_info_t *ti, float32 *pos )
+{
+    DASSERT(ti);
+    DASSERT(pos);
+
+    if (ti->active)
+	*(float3*)pos = TransformF3MatrixD(&ti->matrix,(float3*)pos);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		   ScanTextKMP() sub functions		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static kmp_pt_flag_t ScanPtFlags ( ScanInfo_t *si )
+{
+    DASSERT(si);
+
+    if ( NextCharSI(si,false) == '(' )
+    {
+	si->cur_file->ptr++;
+	DEFINE_VAR(val);
+	CheckWarnSI(si,')',ScanExprSI(si,&val));
+	return GetIntV(&val);
+    }
+
+    char fbuf[20];
+    ScanNameSI(si,fbuf,sizeof(fbuf),true,true,0);
+
+    kmp_pt_flag_t flags = 0;
+    if ( strchr(fbuf,'F') ) flags |= KPFL_FALL;
+    if ( strchr(fbuf,'S') ) flags |= KPFL_SNAP;
+    if ( strchr(fbuf,'J') ) flags |= KPFL_JGPT;
+
+ #if 0
+    if ( si->cur_file->revision < xxxx && !( flags & KPFL_UPDATE_Rxxxx ) )
+	flags |= KPFL_UPDATE_Rxxxx;
+ #endif
+    return flags;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanText_PT_PH
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si,		// valid data
+    uint		sect_pt		// KMP PT section
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    DASSERT( sect_pt == KMP_ENPT || sect_pt == KMP_ITPT );
+
+    uint sect_ph;
+    kmp_ph_t *ph;
+    kmp_flag_t *kf;
+
+    if ( sect_pt == KMP_ENPT )
+    {
+	sect_ph		= KMP_ENPH;
+	ph		= &kmp->enph;
+	kf		= &kmp->enpt_flag;
+    }
+    else
+    {
+	sect_ph		= KMP_ITPH;
+	ph		= &kmp->itph;
+	kf		= &kmp->itpt_flag;
+    }
+
+    ph->default_class = KCLS_DEFAULT;
+
+    ccp pt_name = kmp_section_name[sect_pt].name1;
+    ccp ph_name = kmp_section_name[sect_ph].name1;
+    TRACE("ScanText_PT_PH(%s,%s)\n",pt_name,ph_name);
+
+    char pt_hd_name[20], ph_hd_name[20];
+    snprintf( pt_hd_name,   sizeof(pt_hd_name),   "%s-HEAD-VALUE",      pt_name );
+    snprintf( ph_hd_name,   sizeof(ph_hd_name),	  "%s-HEAD-VALUE",      ph_name );
+
+    rtobj_info_t rtinfo;
+    ResetRouteInfo(&rtinfo,&kmp->rtobj);
+
+    tform_info_t tform_pos;
+    ResetTformInfo(&tform_pos);
+
+    kcl_fall_t kfall;
+    ResetKclFall(&kfall);
+
+    int auto_group_name = 0, rotate_group_links = 0;
+    int show_options = 0, export_flags = 0;
+    double auto_fill = 0.0;
+    u8 auto_connect = ph->ac_mode | ph->ac_flags;
+    u16 mask1, mask2;
+    mask1 = mask2 = 0xffff;
+
+    ScanParam_t ptab[] =
+    {
+	{ pt_hd_name,		SPM_U16,    kmp->value+sect_pt },
+	{ ph_hd_name,		SPM_U16,    kmp->value+sect_ph },
+	{ "AUTO-GROUP-NAME",	SPM_INT,    &auto_group_name },
+	{ "ROTATE-GROUP-LINKS",	SPM_INT,    &rotate_group_links },
+	{ "EXPORT-FLAGS",	SPM_INT,    &export_flags },
+	{ "AUTO-FILL",		SPM_DOUBLE, &auto_fill },
+	{ "SHOW-OPTIONS",	SPM_INT,    &show_options },
+	{ "AUTO-CONNECT",	SPM_U8,	    &auto_connect },
+	{ "MASK-1",		SPM_U16,    &mask1 },
+	{ "MASK-2",		SPM_U16,    &mask2 },
+	ROUTE_OBJECT_VARS(rtinfo)
+	TFORM_VARS(tform_pos)
+	KCL_FALL_VARS(kmp,kfall)
+	{0}
+    };
+
+    kmp_group_list_t gl;
+    InitializeGL(&gl,*pt_name,kmp,ph);
+    List_t *ptlist = kmp->dlist + sect_pt;
+    ptlist->used = 0;
+
+    enumError err = ERR_OK;
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckRouteInfo(&rtinfo);
+	    CheckTformInfo(&tform_pos);
+	    CheckKclFall(&kfall);
+	    continue;
+	}
+
+	if ( ch == '$' )
+	{
+	    AddGroupGL(&gl,si,ph_name[0],ptlist->used,3);
+	    continue;
+	}
+
+	u16 idx;
+	if (ScanU16SI(si,&idx,1,0))
+	{
+	    err = ERR_WARNING;
+	    break;
+	}
+
+	kmp_enpt_entry_t temp;
+	ScanFloatV3SI(si,temp.position,1);
+	ScanFloatSI(si,&temp.scale,1);
+	if ( si->cur_file->szs_modifier > 0 )
+	    ScanBE32SI_swap(si,(u32*)temp.prop,1,1);
+	else
+	    ScanU16SI(si,temp.prop,2,0);
+	const u8 flags = NextCharSI(si,false) ? ScanPtFlags(si) : kf->mask;
+	CheckEolSI(si);
+
+	const kmp_enpt_entry_t * prev = GetListElem(ptlist,-1,&temp);
+	if (!ptlist->used) // no previous point available
+	    gl.line.n = 1;
+	else if (  auto_fill >= 1.0
+		&& gl.line.n == 1
+		&& gl.used
+		&& ptlist->used != gl.group[gl.used-1].first_index )
+	{
+	    double3 dist3;
+	    dist3.x = temp.position[0] - prev->position[0];
+	    dist3.y = temp.position[1] - prev->position[1];
+	    dist3.z = temp.position[2] - prev->position[2];
+	    const double dist = Length3(dist3);
+	    if ( dist > auto_fill )
+	    {
+		gl.line.n = (int)trunc(dist/auto_fill) + 1;
+		PRINT("DIST=%8.2f, FILL=%8.2f => N=%2u\n",dist,auto_fill,gl.line.n);
+	    }
+	}
+
+	uint p;
+	for ( p = 1; p <= gl.line.n; p++ )
+	{
+	    AddPointGL(&gl,ptlist->used);
+	    if ( ptlist->used < KMP_MAX_POINT )
+		kf->flags[ptlist->used] = flags;
+
+	    kmp_enpt_entry_t * entry = AppendList(ptlist);
+	    memcpy(entry,&temp,sizeof(*entry));
+	    CalcLine(&gl.line,entry->position,prev->position,temp.position,4,p);
+	    TransformPos(&tform_pos,entry->position);
+	    if ( flags & KPFL_FALL )
+		CalcKclFall(&kfall,entry->position);
+	}
+	InitializeLine(&gl.line);
+    }
+
+    TermGL(&gl,si,kmp,sect_ph,rotate_group_links);
+
+    if (gl.have_options)
+	show_options = true;
+
+    #if HAVE_PRINT0
+    {
+	uint i;
+	for ( i = 0; i < gl.used; i++ )
+	    PRINT("GROUP %3u -> %s\n",i,ph->gname[i]);
+    }
+    #endif
+
+    if (opt_export_flags)
+	export_flags = opt_export_flags > 0;
+
+    kf->export		= export_flags;
+    ph->ac_mode		= auto_connect & KMP_AC_MASK;
+    ph->ac_flags	= auto_connect & KMP_ACF_MASK;
+    ph->mask[0]		= mask1;
+    ph->mask[1]		= mask2;
+    if ( opt_route_options == OFFON_AUTO )
+	ph->show_options = show_options;
+
+    if (auto_group_name)
+	RenameGroupKMP( kmp, sect_ph, ph->gname, ph->ac_mode == KMP_AC_DISPATCH);
+
+    if ( sect_pt == KMP_ENPT )
+	AssignRouteInfo(&rtinfo,&kmp->rtobj_enpt);
+    else
+	AssignRouteInfo(&rtinfo,&kmp->rtobj_itpt);
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextKTPT
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextKTPT()\n");
+
+    tform_info_t tform_pos;
+    ResetTformInfo(&tform_pos);
+
+    kcl_fall_t kfall;
+    ResetKclFall(&kfall);
+
+    ScanParam_t ptab[] =
+    {
+	{ "KTPT-HEAD-VALUE",	SPM_U16,    kmp->value+KMP_KTPT },
+	TFORM_VARS(tform_pos)
+	KCL_FALL_VARS(kmp,kfall)
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + KMP_KTPT;
+    dlist->used = 0;
+
+    #if HAVE_PRINT0
+	si->debug++;
+    #endif
+
+    for(;;)
+    {
+     #if HAVE_PRINT0
+	{
+	    ccp eol = FindNextLineFeedSI(si,false);
+	    PRINT("##LINE %4u: %.*s\n",si->line,(int)(eol-si->ptr),si->ptr);
+	}
+     #endif
+
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+     #if HAVE_PRINT0
+	{
+	    ccp eol = FindNextLineFeedSI(si,false);
+	    PRINT("##LINE %4u: %.*s\n",si->line,(int)(eol-si->ptr),si->ptr);
+	}
+     #endif
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckTformInfo(&tform_pos);
+	    CheckKclFall(&kfall);
+	    continue;
+	}
+
+	u16 idx;
+	if (ScanU16SI(si,&idx,1,0))
+	    break;
+
+	kmp_ktpt_entry_t * entry = AppendList(dlist);
+	ScanFloatV3SI(si,entry->position,2);
+	ScanU16SI(si,(u16*)&entry->player_index,1,0);
+	ScanU16SI(si,(u16*)&entry->unknown,1,si->cur_file->szs_modifier);
+
+	TransformPos(&tform_pos,entry->position);
+	CalcKclFall(&kfall,entry->position);
+	CheckEolSI(si);
+    }
+    CheckLevelSI(si);
+
+ #if HAVE_PRINT0
+    si->debug--;
+ #endif
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextCKPT
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextCKPT()\n");
+
+    int auto_mode = 0, auto_next = 0, auto_respawn = 0;
+    int auto_group_name = 0, rotate_group_links = 0;
+    memset(kmp->ckpt_auto_respawn,0,sizeof(kmp->ckpt_auto_respawn));
+
+    ScanParam_t ptab[] =
+    {
+	{ "AUTO-MODE",			SPM_INT,    &auto_mode },
+	{ "AUTO-NEXT",			SPM_INT,    &auto_next },
+	{ "AUTO-GROUP-NAME",		SPM_INT,    &auto_group_name },
+	{ "AUTO-RESPAWN",		SPM_INT,    &auto_respawn },
+	{ "ROTATE-GROUP-LINKS",		SPM_INT,    &rotate_group_links },
+	{ "ROUTE-OBJECT-MODE",		SPM_INT,    &kmp->ckpt_object_mode },
+	{ "ROUTE-OBJECT1",		SPM_INT,    &kmp->ckpt_object1 },
+	{ "ROUTE-OBJECT2",		SPM_INT,    &kmp->ckpt_object2 },
+	{ "ROUTE-OBJECT1-SCALE",	SPM_VAR,    &kmp->ckpt_object1_scale },
+	{ "ROUTE-OBJECT2-SCALE",	SPM_VAR,    &kmp->ckpt_object2_scale },
+	{ "ROUTE-OBJECT1-BASE",		SPM_FLOAT,  &kmp->ckpt_object1_base },
+	{ "ROUTE-OBJECT2-BASE",		SPM_FLOAT,  &kmp->ckpt_object2_base },
+	{ "CKPT-HEAD-VALUE",		SPM_U16,    kmp->value+KMP_CKPT },
+	{ "CKPH-HEAD-VALUE",		SPM_U16,    kmp->value+KMP_CKPH },
+	{0}
+    };
+
+    kmp_group_list_t gl;
+    InitializeGL(&gl,0,kmp,&kmp->ckph);
+    List_t *ptlist = kmp->dlist + KMP_CKPT;
+    ptlist->used = 0;
+    uint last_mode = 0;
+    float max_x = 0.0, max_y = 0.0;
+
+    const uint max_n = 0x100;
+    float ftemp[max_n+1][4]; // x,y,unused,width/2
+
+    enumError err = ERR_OK;
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    continue;
+	}
+
+	if ( ch == '$' )
+	{
+	    AddGroupGL(&gl,si,'C',ptlist->used,2);
+	    continue;
+	}
+
+	u16 idx;
+	if (ScanU16SI(si,&idx,1,0))
+	{
+	    err = ERR_WARNING;
+	    break;
+	}
+
+	kmp_ckpt_entry_t temp;
+	ScanFloatV2SI(si,temp.left,2);
+
+	if ( auto_respawn > 0 )
+	{
+	    si->no_warn++;
+	    ScanU8SI(si,&temp.respawn,1,0);
+	    si->no_warn--;
+	}
+	else
+	    ScanU8SI(si,&temp.respawn,1,0);
+
+	if ( si->cur_file->szs_modifier > 0 )
+	{
+	    ScanU8SI(si,&temp.mode,1,1);
+	    ScanU8SI(si,&temp.prev,2,0);
+	}
+	else
+	    ScanU8SI(si,&temp.mode,3,0);
+	CheckEolSI(si);
+
+	kmp_ckpt_entry_t * prev = GetListElem(ptlist,-1,&temp);
+	if (!ptlist->used) // no previous point available
+	    gl.line.n = 1;
+	else if ( gl.line.n > max_n )
+	    gl.line.n = max_n;
+
+	float *p1 = 0, *p2 = 0;
+	if ( gl.line.n > 1 )
+	{
+	    if ( gl.line.line_mode == LM_BORDER )
+	    {
+		p1 = ftemp[0];
+		memcpy(p1,prev->left,4*sizeof(float));
+		p2 = ftemp[gl.line.n];
+		memcpy(p2,temp.left,4*sizeof(float));
+	    }
+	    else
+	    {
+		p1 = ftemp[0];
+		p1[0] = ( prev->left[0] + prev->right[0] ) / 2;
+		p1[1] = ( prev->left[1] + prev->right[1] ) / 2;
+		p1[2] = 0.0;
+		double dx = prev->left[0] - prev->right[0];
+		double dy = prev->left[1] - prev->right[1];
+		p1[3] = sqrt ( dx*dx + dy*dy ) / 2;
+
+		p2 = ftemp[gl.line.n];
+		p2[0] = ( temp.left[0] + temp.right[0] ) / 2;
+		p2[1] = ( temp.left[1] + temp.right[1] ) / 2;
+		p2[2] = 0.0;
+		dx = temp.left[0] - temp.right[0];
+		dy = temp.left[1] - temp.right[1];
+		p2[3] = sqrt ( dx*dx + dy*dy ) / 2;
+
+		if ( gl.line.line_mode == LM_BEZIER && !gl.line.n_pt )
+		{
+		    double angle1 = CalcDirection2F(prev->left,prev->right);
+		    double angle2 = CalcDirection2F(temp.left,temp.right);
+		    PRINT("BINGO 2: %7.2f %7.2f -> %7.2f %7.2f\n",
+				angle1, angle2,
+				fmod(angle1+M_PI,M_PI), fmod(angle2+M_PI,M_PI) );
+
+		    double dx = p1[0] - p2[0];
+		    double dy = p1[1] - p2[1];
+		    double range = sqrt( dx*dx + dy*dy ) * 0.707; // sin(pi/4)
+
+		    gl.line.pt[0][0] = p1[0] + cos(angle1) * range;
+		    gl.line.pt[0][1] = p1[1] - sin(angle1) * range;
+		    gl.line.pt[1][0] = p2[0] - cos(angle2) * range;
+		    gl.line.pt[1][1] = p2[1] + sin(angle2) * range;
+		    gl.line.n_pt = 2;
+		    PRINT("\n-> %11.3f %11.3f\n"
+			    "   %11.3f %11.3f\n"
+			    "   %11.3f %11.3f\n"
+			    "   %11.3f %11.3f\n",
+			  p1[0], p1[1],
+			  gl.line.pt[0][0], gl.line.pt[0][1],
+			  gl.line.pt[1][0], gl.line.pt[1][1],
+			  p2[0], p2[1] );
+		}
+	    }
+	}
+
+	uint p;
+	for ( p = 1; p <= gl.line.n; p++ )
+	{
+	    const uint grp_idx = AddPointGL(&gl,ptlist->used);
+	    kmp_ckpt_entry_t * entry = AppendList(ptlist);
+	    memcpy(entry,&temp,sizeof(*entry));
+	    if ( p < gl.line.n )
+		CalcLine(&gl.line,ftemp[p],p1,p2,4,p);
+
+	    switch (auto_mode)
+	    {
+		//case KMP_AM_NORM:	// normalize modes
+		//    --> delayed
+		//    break;
+
+		case KMP_AM_RENUMBER:	// renumber  modes
+		    if (!entry->mode)
+			last_mode = 0;
+		    else if (!IS_M1(entry->mode))
+			entry->mode = ++last_mode;
+		    break;
+
+		case KMP_AM_1_LAP:	// define modes as 1 lap race
+		    entry->mode = ptlist->used < 7 ? ptlist->used % 2 - 1 : -1;
+		    break;
+
+		case KMP_AM_SHORT:	// define modes to get a very short race
+		    entry->mode = ptlist->used % 2 - 1;
+		    break;
+
+		case KMP_AM_UNLIMIT:	// remove lap counter for unlimited race
+		    {
+			static const u8 tab[] = { 0, 3,0,1,2 };
+			entry->mode = ptlist->used < sizeof(tab)/sizeof(*tab)
+					? tab[ptlist->used] : -1;
+
+			if ( max_x < entry->left[0] )
+			     max_x = entry->left[0];
+			if ( max_x < entry->right[0] )
+			     max_x = entry->right[0];
+
+			if ( max_y < entry->left[1] )
+			     max_y = entry->left[1];
+			if ( max_y < entry->right[1] )
+			     max_y = entry->right[1];
+		    }
+		    break;
+
+		default:
+		    if ( !IS_M1(entry->mode) )
+			last_mode = entry->mode;
+		    break;
+	    }
+
+	    if (auto_next)
+	    {
+		entry->next = ~0;
+		entry->prev = grp_idx ? ptlist->used - 2 : ~0;
+		if ( grp_idx > 0 && IS_M1(entry[-1].next) )
+		    entry[-1].next = ptlist->used - 1;
+	    }
+
+	    if ( auto_respawn > 0 )
+	    {
+		const uint idx = ptlist->used - 1;
+		if ( idx < KMP_MAX_POINT )
+		    kmp->ckpt_auto_respawn[idx] = 1;
+	    }
+	}
+
+	if ( gl.line.line_mode == LM_BORDER )
+	{
+	    // now copy the calculated values
+	    for ( p = 1; p < gl.line.n; p++ )
+	    {
+		kmp_ckpt_entry_t * entry = prev + p;
+		memcpy(entry,ftemp[p],4*sizeof(float));
+	    }
+	}
+	else
+	{
+	    // now calculate angle and real positions
+	    for ( p = 1; p < gl.line.n; p++ )
+	    {
+		kmp_ckpt_entry_t * entry = prev + p;
+		float (*f)[4] = ftemp + p-1;
+		double angle1 = CalcDirection2F(f[0],f[1]);
+		double angle2 = CalcDirection2F(f[1],f[2]);
+		noPRINT("%2u: %6.0f %6.0f %6.0f | %6.0f %6.0f %6.0f"
+			" | %6.0f %6.0f %6.0f | %7.2f %7.2f\n",
+		    p,
+		    f[0][0],f[0][1],f[0][3], f[1][0],f[1][1],f[1][3], f[2][0],f[2][1],f[2][3],
+		    angle1 * 180.0 / M_PI, angle2  * 180.0 / M_PI );
+
+		angle1 = ( angle1 + angle2 ) / 2;
+		double d = cos(angle1) * f[1][3];
+		entry->left [0] = f[1][0] + d;
+		entry->right[0] = f[1][0] - d;
+		d = sin(angle1) * f[1][3];
+		entry->left [1] = f[1][1] - d;
+		entry->right[1] = f[1][1] + d;
+	    }
+	}
+	InitializeLine(&gl.line);
+    }
+
+    if ( auto_mode == KMP_AM_NORM )
+    {
+	uint min_search = 1, next_val = 1;
+	kmp_ckpt_entry_t *pt_end = (kmp_ckpt_entry_t*)ptlist->list + ptlist->used;
+	for(;;)
+	{
+	    uint min_found = 0xff;
+	    kmp_ckpt_entry_t *pt;
+	    for ( pt = (kmp_ckpt_entry_t*)ptlist->list; pt < pt_end; pt++ )
+		if ( pt->mode >= min_search && pt->mode < min_found )
+		    min_found = pt->mode;
+
+	    if ( min_found == 0xff )
+		break;
+
+	    for ( pt = (kmp_ckpt_entry_t*)ptlist->list; pt < pt_end; pt++ )
+		if ( pt->mode == min_found )
+		    pt->mode = next_val;
+
+	    next_val++;
+	    min_search = min_found + 1;
+	}
+    }
+    else if ( auto_mode == KMP_AM_UNLIMIT && ptlist->used > 3 )
+    {
+	kmp_ckpt_entry_t *pt = ((kmp_ckpt_entry_t*)ptlist->list) + 3;
+	pt->left[0]  = max_x + 20000.0;
+	pt->left[1]  = max_y + 20000.0;
+	pt->right[0] = max_x + 22000.0;
+	pt->right[1] = max_y + 22000.0;
+    }
+    else if ( auto_mode == KMP_AM_SHORT || auto_mode == KMP_AM_1_LAP )
+	kmp->multi_ckpt_mode_0_ok = true;
+
+    TermGL(&gl,si,kmp,KMP_CKPH,rotate_group_links);
+    if (auto_group_name)
+	RenameGroupKMP(kmp,KMP_CKPH,kmp->ckph.gname,false);
+
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int get_defobj_id ( ScanInfo_t * si, u16 min_id, ccp cmd )
+{
+    u16 obj_id;
+    const enumError err = ScanU16SI(si,&obj_id,1,0);
+    if (err)
+	return -1;
+
+    ScanFile_t *sf = si->cur_file;
+    if (min_id)
+    {
+	if ( obj_id >= min_id && obj_id <= min_id+0xfff )
+	    return obj_id;
+    }
+    else if (IsDefinitionObjectId(obj_id))
+	return obj_id;
+
+    sf->ptr = sf->prev_ptr;
+    WarnIgnoreSI(si,"Invalid id for %s (value %#x). ",cmd,obj_id);
+    GotoEolSI(si);
+    return -1;
+}
+
+//-----------------------------------------------------------------------------
+
+static u16 negate_ref_id ( u16 ref_id )
+{
+    if (IsConditionRefEngineId(ref_id))
+	return ref_id ^ GOBJ_MASK_COND_ENGINE;
+
+    if (IsConditionRefRandomId(ref_id))
+	return ref_id ^ GOBJ_MASK_COND_RND;
+
+//    if (IsConditionRefTestId(ref_id))
+//	return ref_id ^ GOBJ_MASK_COND_RND;
+
+    return ref_id ^ 1;
+}
+
+//-----------------------------------------------------------------------------
+
+static void set_ref_id ( List_t *dlist, u16 ref_id, int mode )
+{
+    // mode: <0: do nothing, =0:disable GOBJ_M_LECODE, >0:enable GOBJ_M_LECODE
+
+    kmp_gobj_entry_t *entry = GetListElem(dlist,-1,0);
+    if (entry)
+    {
+	if ( !mode || IsDefinitionObjectId(entry->obj_id) )
+	    entry->obj_id &= ~GOBJ_M_LECODE;
+	else if ( mode > 0 )
+	    entry->obj_id |= GOBJ_M_LECODE;
+
+	entry->ref_id = ref_id;
+	entry->pflags = entry->pflags & ~GOBJ_M_PF_MODE | 1 << GOBJ_S_PF_MODE;
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+static void disable_enable ( ScanInfo_t *si, List_t *dlist, bool enable )
+{
+    DEFINE_VAR(var);
+    if (!ScanExprSI(si,&var))
+    {
+	int ref_id = GetIntV(&var);
+	if ( ref_id < 0 )
+	{
+	    ref_id = -ref_id;
+	    enable = !enable;
+	}
+
+	if ( IsConditionRefId(ref_id) || IsConditionRefTestId(ref_id) )
+	{
+	    if (!enable)
+		ref_id = negate_ref_id(ref_id);
+	    set_ref_id(dlist,ref_id,enable);
+	}
+	else if ( si->no_warn <= 0 )
+	{
+	    ccp eol = FindNextLineFeedSI(si,true);
+	    ScanFile_t *sf = si->cur_file;
+	    ERROR0(ERR_WARNING,
+		"Invalid ID %#x for predefinied condition [%s @%u]:\n%.*s\n",
+		ref_id, sf->name, sf->line, (int)(eol-sf->prev_ptr), sf->prev_ptr );
+	}
+    }
+    FreeV(&var);
+    CheckEolSI(si);
+}
+
+//-----------------------------------------------------------------------------
+
+static void disable_enable_by
+	( ScanInfo_t *si, List_t *dlist, bool enable, bool not )
+{
+    DEFINE_VAR(var);
+    if (!ScanExprSI(si,&var))
+    {
+	int ref_id = GetIntV(&var);
+	if ( ref_id < 0 )
+	{
+	    ref_id = -ref_id;
+	    enable = !enable;
+	}
+
+	if (IsDefinitionObjectId(ref_id))
+	{
+	    if (not)
+		ref_id |= GOBJ_DEF_F_NOT;
+	    else
+		ref_id &= ~GOBJ_DEF_F_NOT;
+	    set_ref_id(dlist,ref_id,enable);
+	}
+	else if ( si->no_warn <= 0 )
+	{
+	    ccp eol = FindNextLineFeedSI(si,true);
+	    ScanFile_t *sf = si->cur_file;
+	    ERROR0(ERR_WARNING,
+		"Invalid ID %#x for a reference to a definition-object [%s @%u]:\n%.*s\n",
+		ref_id, sf->name, sf->line, (int)(eol-sf->prev_ptr), sf->prev_ptr );
+	}
+    }
+    FreeV(&var);
+    CheckEolSI(si);
+}
+
+//-----------------------------------------------------------------------------
+
+static enumError ScanTextGOBJ
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextGOBJ()\n");
+
+    tform_info_t tform_pos;
+    ResetTformInfo(&tform_pos);
+
+    kcl_fall_t kfall;
+    ResetKclFall(&kfall);
+
+    int auto_object_name = 0, sort_objects = 0;
+    int fix_objdef = 0, sort_objdef = 0;
+    int fix_reference = 0, sort_reference = 0;
+    uint auto_enemy_item = 0, auto_enemy_index = 32;
+    ScanParam_t ptab[] =
+    {
+	{ "GOBJ-HEAD-VALUE",	SPM_U16,  kmp->value+KMP_GOBJ },
+	{ "AUTO-ENEMY-ITEM",	SPM_UINT, &auto_enemy_item },
+	{ "AUTO-OBJECT-NAME",	SPM_INT,  &auto_object_name },
+	{ "SORT-OBJECTS",	SPM_INT,  &sort_objects },
+
+	{ "FIX-OBJDEF",		SPM_INT,  &fix_objdef },
+	{ "SORT-OBJDEF",	SPM_INT,  &sort_objdef },
+	{ "FIX-REFERENCE",	SPM_INT,  &fix_reference },
+	{ "SORT-REFERENCE",	SPM_INT,  &sort_reference },
+
+	TFORM_VARS(tform_pos)
+	KCL_FALL_VARS(kmp,kfall)
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + KMP_GOBJ;
+    dlist->used = 0;
+
+    bool ignore_itembox
+	=  kmp->rtobj_enpt.obj == GOBJ_ITEMBOX
+	|| kmp->rtobj_itpt.obj == GOBJ_ITEMBOX
+	|| kmp->rtobj_jgpt.obj == GOBJ_ITEMBOX
+	|| kmp->rtobj_cnpt.obj == GOBJ_ITEMBOX
+	|| kmp->rtobj_mspt.obj == GOBJ_ITEMBOX;
+    if (!ignore_itembox)
+    {
+	uint pi;
+	for ( pi = 0; pi < kmp->n_rtobj_poti; pi++ )
+	    if ( kmp->rtobj_poti[pi].rtobj.obj == GOBJ_ITEMBOX )
+	    {
+		ignore_itembox = true;
+		break;
+	    }
+    }
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckTformInfo(&tform_pos);
+	    CheckKclFall(&kfall);
+	    continue;
+	}
+
+	if ( ch == '$' )
+	{
+	    ScanFile_t *sf = si->cur_file;
+	    DASSERT(sf);
+
+	    char name[KMP_MAX_NAME_LEN+1];
+	    ScanNameSI(si,name,sizeof(name),true,true,0);
+	    int start_index = -1;
+	    u16 min_id = 0x2000;
+
+	    if (!strcmp(name,"$DEFOBJ-RACE"))
+		start_index = KMP_GMODE_VERSUS;
+	    else if (!strcmp(name,"$DEFOBJ-BATTLE"))
+		start_index = KMP_GMODE_BALLOON;
+	    else if (!strcmp(name,"$DEFOBJ-OR"))
+	    {
+		start_index = KMP_GMODE_BALLOON;
+		min_id = 0x4000;
+	    }
+	    else if (!strcmp(name,"$DEFOBJ-AND"))
+	    {
+		start_index = KMP_GMODE_BALLOON;
+		min_id = 0x6000;
+	    }
+	    else if (!strcmp(name,"$DISABLE"))
+	    {
+		disable_enable(si,dlist,false);
+		continue;
+	    }
+	    else if (!strcmp(name,"$ENABLE"))
+	    {
+		disable_enable(si,dlist,true);
+		continue;
+	    }
+	    else if (!strcmp(name,"$DISABLE-BY"))
+	    {
+		disable_enable_by(si,dlist,false,true);
+		continue;
+	    }
+	    else if (!strcmp(name,"$ENABLE-BY"))
+	    {
+		disable_enable_by(si,dlist,true,false);
+		continue;
+	    }
+	    else if (!strcmp(name,"$DISABLE-BY-NOT"))
+	    {
+		disable_enable_by(si,dlist,false,false);
+		continue;
+	    }
+	    else if (!strcmp(name,"$ENABLE-BY-NOT"))
+	    {
+		disable_enable_by(si,dlist,true,true);
+		continue;
+	    }
+	    else if (!strcmp(name,"$REFERENCE"))
+	    {
+		int ref_id = get_defobj_id(si,0,name);
+		if ( ref_id >= 0 )
+		    set_ref_id(dlist,ref_id,0);
+		continue;
+	    }
+	    else
+	    {
+		sf->ptr = sf->prev_ptr;
+		WarnIgnoreSI(si,"Unknown keyword »%s«.",name);
+		GotoEolSI(si);
+		continue;
+	    }
+
+	    //-- $DEFOBJ-RACE | $DEFOBJ-BATTLE | $DEFOBJ-OR | $DEFOBJ-AND
+
+	    int obj_id = get_defobj_id(si,min_id,name);
+	    if ( obj_id < 0 )
+		continue;
+
+	    kmp_gobj_entry_t * entry = AppendList(dlist);
+	    entry->obj_id = obj_id;
+	    entry->route_id = ~0;
+	    entry->pflags = GOBJ_PF_MODE1;
+
+	    u16 val = 0;
+	    int index = 0;
+	    DEFINE_VAR(var);
+	    while ( start_index < 8 )
+	    {
+		if (!ScanExprSI(si,&var))
+		    val = GetIntV(&var);
+		while ( index <= start_index )
+		    entry->setting[index++] = val;
+		start_index++;
+
+		if (!SkipCharSI(si,','))
+		    break;
+	    }
+
+	    if ( min_id == 0x2000 )
+		while ( index < 8 )
+		    entry->setting[index++] = val;
+
+	    CheckEolSI(si);
+	    FreeV(&var);
+	    continue;
+	}
+
+	enumError err;
+	ScanIndexSI(si,&err,dlist->used,kmp->index+KMP_GOBJ,0);
+	if (err)
+	    break;
+
+	kmp_gobj_entry_t * entry = AppendList(dlist);
+
+	if ( si->cur_file->szs_modifier > 0 )
+	{
+	    ScanU16SI(si,&entry->obj_id,1,1);
+	    ScanU16SI(si,&entry->ref_id,1,0);
+	    ScanFloatV3SI(si,entry->position,3);
+	    ScanBE32SI_swap(si,(u32*)&entry->route_id,5,1);
+	}
+	else
+	{
+	    ScanU16SI(si,&entry->obj_id,1,0);
+	     ScanFloatV3SI(si,entry->position,1);
+	     ScanU16SI(si,entry->setting,4,0);
+	     ScanU16SI(si,&entry->route_id,1,0);
+	    ScanU16SI(si,&entry->ref_id,1,0);
+	     ScanFloatV3SI(si,entry->rotation,1);
+	     ScanU16SI(si,entry->setting+4,4,0);
+	     ScanU16SI(si,&entry->pflags,1,0);
+	    ScanFloatV3SI(si,entry->scale,1);
+	}
+
+	TransformPos(&tform_pos,entry->position);
+	CalcKclFall(&kfall,entry->position);
+	CheckEolSI(si);
+
+	if ( ignore_itembox
+		&& entry->obj_id < N_KMP_GOBJ
+		&& ObjectInfo[entry->obj_id].flags & OBF_ITEMBOX )
+	{
+	    dlist->used--;
+	}
+	else if ( auto_enemy_item
+		&& entry->obj_id == GOBJ_ITEMBOX
+		&& !entry->setting[2] )
+	{
+	    for(;;)
+	    {
+		if ( auto_enemy_index > 32 )
+		     auto_enemy_index = 0;
+		if ( auto_enemy_item & ( 1 << auto_enemy_index++ ) )
+		    break;
+	    }
+	    entry->setting[2] = auto_enemy_index - 1;
+	}
+    }
+    CheckLevelSI(si);
+
+    FixDefObj(kmp,fix_objdef);
+    FixReference(kmp,fix_reference);
+
+    if (SortGOBJ(kmp,sort_objects))
+	auto_object_name = 1;
+
+    if (SortDefObj(kmp,sort_objdef))
+	auto_object_name = 1;
+
+    if (SortReference(kmp,sort_reference))
+	auto_object_name = 1;
+
+    if ( auto_object_name > 0 )
+    {
+	ResetIL(kmp->index+KMP_GOBJ);
+	FillIL(kmp->index+KMP_GOBJ,dlist->used);
+    }
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextAREA
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextAREA()\n");
+
+    ScanParam_t ptab[] =
+    {
+	{ "AREA-HEAD-VALUE", SPM_U16, kmp->value+KMP_AREA },
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + KMP_AREA;
+    dlist->used = 0;
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    continue;
+	}
+
+	enumError err;
+	ScanIndexSI(si,&err,dlist->used,kmp->index+KMP_AREA,2);
+	if (err)
+	    break;
+
+	kmp_area_entry_t * entry = AppendList(dlist);
+
+	if ( si->cur_file->szs_modifier > 0 )
+	{
+	    ScanBE32SI(si,(u32*)&entry->mode,1,1);
+	    ScanFloatV3SI(si,entry->position,3);
+	    ScanBE32SI_swap(si,(u32*)entry->setting,2,1);
+	}
+	else if ( si->cur_file->revision < 2956 )
+	{
+	    // 2011-08-26, v0.17a, r2956 -> new table layout
+
+	    ScanBE16SI(si,(u16*)&entry->mode,2,0);
+	     ScanFloatV3SI(si,entry->position,1);
+	     ScanU16SI(si,entry->setting,4,0);
+	    ScanFloatV3SI(si,entry->rotation,1);
+	    ScanFloatV3SI(si,entry->scale,1);
+	}
+	else
+	{
+	    ScanU8SI(si,&entry->mode,2,0);
+	     ScanFloatV3SI(si,entry->position,1);
+	     ScanU16SI(si,entry->setting,4,0);
+	    ScanU8SI(si,&entry->dest_id,2,0);
+	     ScanFloatV3SI(si,entry->rotation,1);
+	    ScanFloatV3SI(si,entry->scale,1);
+	}
+	CheckEolSI(si);
+    }
+    CheckLevelSI(si);
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextCAME
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextCAME()\n");
+
+    u8 *value = (u8*)(kmp->value + KMP_CAME);
+    ScanParam_t ptab[] =
+    {
+	{ "CAME-HEAD-VALUE", SPM_U16, (u16*)value },
+     #ifdef LITTLE_ENDIAN
+	{ "OPENING-INDEX",   SPM_U8, value+1 },
+	{ "SELECTION-INDEX", SPM_U8, value+0 },
+     #else
+	{ "OPENING-INDEX",   SPM_U8, value+0 },
+	{ "SELECTION-INDEX", SPM_U8, value+1 },
+     #endif
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + KMP_CAME;
+    dlist->used = 0;
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    continue;
+	}
+
+	enumError err;
+	ScanIndexSI(si,&err,dlist->used,kmp->index+KMP_CAME,2);
+	if (err)
+	    break;
+
+	kmp_came_entry_t * entry = AppendList(dlist);
+
+	uint zoom_speed = 0, viewpt_speed = 0;
+
+	if ( si->cur_file->szs_modifier > 0 )
+	{
+	    ScanBE32SI(si,(u32*)&entry->type,1,1);
+	    ScanBE32SI_swap(si,(u32*)&entry->came_speed,2,1);
+	    ScanFloatV3SI(si,entry->position,2);
+	    ScanFloatSI(si,&entry->zoom_begin,2);
+	    ScanFloatV3SI(si,entry->viewpt_begin,2);
+	    ScanFloatSI(si,&entry->time,1);
+	    zoom_speed = entry->zoom_speed;
+	    viewpt_speed = entry->viewpt_speed;
+	}
+	else if ( si->cur_file->revision < 2955 )
+	{
+	    // 2011-08-26, v0.17a, r2956 -> new table layout
+
+	    ScanU8SI(si,&entry->type,4,0);
+	     ScanU16SI(si,&entry->came_speed,1,0);
+	     ScanFloatV3SI(si,entry->position,1);
+	     ScanFloatSI(si,&entry->time,1);
+	    ScanU32SI(si,&zoom_speed,1,0);
+	     ScanFloatV3SI(si,entry->rotation,1);
+	    ScanU32SI(si,&viewpt_speed,1,0);
+	     ScanFloatSI(si,&entry->zoom_begin,2);
+	    ScanU16SI(si,&entry->unknown_0x0a,1,0);
+	     ScanFloatV3SI(si,entry->viewpt_begin,2);
+	}
+	else
+	{
+	    ScanU8SI(si,&entry->type,1,0);
+	     ScanU16SI(si,&entry->came_speed,1,0);
+	     ScanFloatV3SI(si,entry->position,1);
+	     ScanFloatSI(si,&entry->zoom_begin,1);
+	    ScanU8SI(si,&entry->next,1,0);
+	     ScanU32SI(si,&zoom_speed,1,0);
+	     ScanFloatV3SI(si,entry->rotation,1);
+	     ScanFloatSI(si,&entry->zoom_end,1);
+	    ScanU8SI(si,&entry->unknown_0x02,1,0);
+	     ScanU32SI(si,&viewpt_speed,1,0);
+	     ScanFloatV3SI(si,entry->viewpt_begin,1);
+	    ScanU8SI(si,&entry->route,1,0);
+	     ScanU16SI(si,&entry->unknown_0x0a,1,0);
+	     ScanFloatV3SI(si,entry->viewpt_end,1);
+	     ScanFloatSI(si,&entry->time,1);
+	}
+	CheckEolSI(si);
+
+	const double zoom_len = fabs(entry->zoom_begin-entry->zoom_end);
+	entry->zoom_speed = zoom_speed;
+	if ( zoom_speed == ~(u32)0 )
+	    entry->zoom_speed = entry->time >= 0.001
+			? (uint)floor( 100.0 * zoom_len / entry->time )
+			: 1;
+
+	const double viewpt_len = LengthF(entry->viewpt_begin,entry->viewpt_end);
+	entry->viewpt_speed = viewpt_speed;
+	if ( viewpt_speed == ~(u32)0 )
+	    entry->viewpt_speed = entry->time >= 0.001
+			? (uint)floor( 100.0 * viewpt_len / entry->time )
+			: 1;
+
+	DefineIndexDouble(si,"CAME.TIME",entry->time);
+	DefineIndexDouble(si,"ZOOM.LEN",zoom_len);
+	DefineIndexDouble(si,"VIEWPT.LEN",viewpt_len);
+    }
+    CheckLevelSI(si);
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextPT2
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si,		// valid data
+    uint		sect		// KMP section index
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    DASSERT(sect<KMP_N_SECT);
+    TRACE("ScanTextPT2(%s)\n",kmp_section_name[sect].name1);
+
+    Var_t *snap2_to_enpt, *snap_to_enpt, *hsnap_to_enpt;
+    kmp_rtobj_t *rtobj = 0;
+
+    Var_t var_dummy, *auto_adjust = &var_dummy;
+    int   int_dummy, *auto_define = &int_dummy, *auto_remove = &int_dummy;
+    float float_dummy, *auto_distance = &float_dummy;
+    kmp_flag_t *kf = 0;
+    int export_flags = 0;
+
+    switch (sect)
+    {
+	case KMP_JGPT:
+	    snap2_to_enpt	= &kmp->jgpt_snap2;
+	    snap_to_enpt	= &kmp->jgpt_snap;
+	    hsnap_to_enpt	= &kmp->jgpt_hsnap;
+	    rtobj		= &kmp->rtobj_jgpt;
+	    auto_define		= &kmp->jgpt_auto_define;
+	    auto_distance	= &kmp->jgpt_auto_distance;
+	    auto_adjust		= &kmp->jgpt_auto_adjust;
+	    auto_remove		= &kmp->jgpt_auto_remove;
+	    kf			= &kmp->jgpt_flag;
+	    break;
+
+	case KMP_CNPT:
+	    snap2_to_enpt	= &kmp->cnpt_snap2;
+	    snap_to_enpt	= &kmp->cnpt_snap;
+	    hsnap_to_enpt	= &kmp->cnpt_hsnap;
+	    rtobj		= &kmp->rtobj_cnpt;
+	    break;
+
+	case KMP_MSPT:
+	    snap2_to_enpt	= &kmp->mspt_snap2;
+	    snap_to_enpt	= &kmp->mspt_snap;
+	    hsnap_to_enpt	= &kmp->mspt_hsnap;
+	    rtobj		= &kmp->rtobj_mspt;
+	    break;
+
+	default:
+	    var_dummy.mode	= VAR_UNSET;
+	    snap2_to_enpt	= &var_dummy;
+	    snap_to_enpt	= &var_dummy;
+	    hsnap_to_enpt	= &var_dummy;
+	    break;
+    }
+
+    rtobj_info_t rtinfo;
+    ResetRouteInfo(&rtinfo,&kmp->rtobj);
+
+    tform_info_t tform_pos;
+    ResetTformInfo(&tform_pos);
+
+    kcl_fall_t kfall;
+    ResetKclFall(&kfall);
+
+    int auto_id = 0;
+    char hd_name[20];
+    snprintf( hd_name, sizeof(hd_name),
+			"%s-HEAD-VALUE", kmp_section_name[sect].name1 );
+    ScanParam_t ptab[] =
+    {
+	{ hd_name,		SPM_U16,    kmp->value+sect },
+	{ "AUTO-ID",		SPM_INT,    &auto_id },
+	{ "SNAP2-TO-ENPT",	SPM_VAR,    snap2_to_enpt },
+	{ "SNAP-TO-ENPT",	SPM_VAR,    snap_to_enpt },
+	{ "HSNAP-TO-ENPT",	SPM_VAR,    hsnap_to_enpt },
+	{ "AUTO-DEFINE",	SPM_INT,    auto_define },
+	{ "AUTO-DISTANCE",	SPM_FLOAT,  auto_distance },
+	{ "AUTO-ADJUST",	SPM_VAR,    auto_adjust },
+	{ "AUTO-REMOVE",	SPM_INT,    auto_remove },
+	{ "EXPORT-FLAGS",	SPM_INT,    &export_flags },
+	ROUTE_OBJECT_VARS(rtinfo)
+	TFORM_VARS(tform_pos)
+	KCL_FALL_VARS(kmp,kfall)
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + sect;
+    dlist->used = 0;
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckRouteInfo(&rtinfo);
+	    CheckTformInfo(&tform_pos);
+	    CheckKclFall(&kfall);
+	    continue;
+	}
+
+	enumError err;
+	ScanIndexSI(si,&err,dlist->used,kmp->index+sect,2);
+	if (err)
+	    break;
+
+	kmp_jgpt_entry_t * entry = AppendList(dlist);
+	ScanFloatV3SI(si,entry->position,2);
+	ScanU16SI(si,(u16*)&entry->id,1,0);
+	ScanU16SI(si,(u16*)&entry->effect,1,si->cur_file->szs_modifier);
+
+	const u8 flags = !kf ? KPFL_M_ALL
+			: NextCharSI(si,false) ? ScanPtFlags(si) : kf->mask;
+	if ( kf && (uint)(dlist->used-1) < KMP_MAX_POINT )
+		kf->flags[dlist->used-1] = flags;
+
+	TransformPos(&tform_pos,entry->position);
+	if ( flags & KPFL_FALL )
+	    CalcKclFall(&kfall,entry->position);
+	CheckEolSI(si);
+
+	if (auto_id)
+	    entry->id = dlist->used - 1;
+    }
+    CheckLevelSI(si);
+
+    PRINT_IF( snap2_to_enpt && snap2_to_enpt->mode,
+		"SNAP-TO-ENPT: %d -> jgpt=%d, cnpt=%d, mspt=%d\n",
+		snap2_to_enpt->mode, kmp->jgpt_snap2.mode,
+		kmp->cnpt_snap2.mode, kmp->mspt_snap2.mode );
+    PRINT_IF( snap_to_enpt && snap_to_enpt->mode,
+		"SNAP-TO-ENPT: %d -> jgpt=%d, cnpt=%d, mspt=%d\n",
+		snap_to_enpt->mode, kmp->jgpt_snap.mode,
+		kmp->cnpt_snap.mode, kmp->mspt_snap.mode );
+
+    if (kf)
+	kf->export = opt_export_flags ? opt_export_flags>0 : export_flags;
+
+    if (rtobj)
+	AssignRouteInfo(&rtinfo,rtobj);
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextSTGI
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextSTGI()\n");
+
+    ScanParam_t ptab[] =
+    {
+	{ "STGI-HEAD-VALUE", SPM_U16, kmp->value+KMP_STGI },
+	{0}
+    };
+
+    List_t *dlist = kmp->dlist + KMP_STGI;
+    dlist->used = 0;
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    continue;
+	}
+
+	enumError err;
+	ScanIndexSI(si,&err,dlist->used,kmp->index+KMP_STGI,2);
+	if (err)
+	    break;
+
+	kmp_stgi_entry_t * entry = AppendList(dlist);
+	if ( si->cur_file->revision < 3379 )
+	{
+	    // 2012-01-28, v0.26a, r3379
+	    ScanBE16SI(si,(u16*)&entry->lap_count,6,0);
+	    entry->flare_color = be32(&entry->flare_color);
+	}
+	else
+	{
+	    ScanU8SI(si,&entry->lap_count,4,0);
+	    ScanU32SI(si,&entry->flare_color,1,0);
+	    ScanU8SI(si,&entry->flare_alpha,2,0);
+
+	    DEFINE_VAR(var);
+	    ScanExprSI(si,&var);
+	    if ( var.mode == VAR_DOUBLE || var.mode == VAR_VECTOR )
+		entry->speed_mod = SpeedMod2u16(GetDoubleV(&var));
+	    else
+	    {
+		u8 v2;
+		ScanU8SI(si,&v2,1,0);
+		entry->speed_mod = GetIntV(&var) << 8 | v2;
+	    }
+	}
+	CheckEolSI(si);
+    }
+    CheckLevelSI(si);
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextSETUP
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextSETUP()\n");
+
+    rtobj_info_t rtinfo;
+    ResetRouteInfo(&rtinfo,&kmp->rtobj);
+
+    ScanParam_t ptab[] =
+    {
+	ROUTE_OBJECT_VARS(rtinfo)
+	{0}
+    };
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckRouteInfo(&rtinfo);
+	    continue;
+	}
+
+	char name[50];
+	if ( !ScanNameSI(si,name,sizeof(name),true,true,0)
+		|| NextCharSI(si,true) != '=' )
+	{
+	    CheckEolSI(si);
+	    continue;
+	}
+	DASSERT(si->cur_file);
+	si->cur_file->ptr++;
+	noPRINT("### %s = %.4s...\n",name,si->cur_file->ptr);
+
+	if (!strcmp(name,"REVISION"))
+	{
+	    ScanU32SI(si,(u32*)&kmp->revision,1,0);
+	    si->init_revision = si->cur_file->revision = kmp->revision;
+	    DefineIntVar(&si->gvar,"REVISION$SETUP",kmp->revision);
+	    DefineIntVar(&si->gvar,"REVISION$ACTIVE",kmp->revision);
+	}
+	else if (!strcmp(name,"KCL-FALL-ADD-ROAD"))
+	{
+	    DEFINE_VAR(val);
+	    if ( ScanExprSI(si,&val) <= ERR_WARNING )
+		kmp->enable_fall_kcl = GetBoolV(&val);
+	}
+	else if (!strcmp(name,"KMP-WIM0"))
+	{
+	    DEFINE_VAR(val);
+	    if ( ScanExprSI(si,&val) <= ERR_WARNING )
+		kmp->wim0_export = GetBoolV(&val) || opt_wim0 > 0;
+	}
+	// "UNKNOWN-0X0C" replaced by "KMP-VERSION" in 2020-01
+	else if ( !strcmp(name,"KMP-VERSION") || !strcmp(name,"UNKNOWN-0X0C") )
+	    ScanU32SI(si,&kmp->kmp_version,1,0);
+	else if (!strcmp(name,"INFO"))
+	    ConcatStringsSI(si,&kmp->info,0);
+	else
+	    GotoEolSI(si);
+	CheckEolSI(si);
+    }
+    CheckLevelSI(si);
+    if (rtinfo.valid)
+	AssignRouteInfo(&rtinfo,&kmp->rtobj);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		   ScanTextKMP() route functions	///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+typedef struct route_info_t
+{
+    int		index;			// index of route
+
+    int		f_xss;
+    int		f_yss;
+    int		f_zss;
+    int		f_scale;
+    int		f_shift;
+    int		f_hrotate;		// [[[hrot]] [[2do]]
+
+    rtobj_info_t rtinfo;
+    kcl_fall_t	kfall;
+
+    double	xss[4];
+    double	yss[4];
+    double	zss[4];
+    Var_t	scale[2];
+    Var_t	shift;
+    Var_t	hrotate[2];		// [[[hrot]] [[2do]]
+    int		reverse_order;
+
+    double	route_time;		// >0.0: recalc setting 1
+
+    int		show_route;		// >0: enable itemboxes for this route
+
+} route_info_t;
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void CloseRoute
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si,		// valid data
+    const kmp_poti_group_t
+			* grp,		// group to close
+    route_info_t	* ri		// route info data
+)
+{
+    DASSERT(kmp);
+    DASSERT(grp);
+    DASSERT(ri);
+
+    const uint np = grp->n_point;
+    DASSERT( np <= kmp->poti_point.used );
+
+    kmp_poti_point_t *pp0 = (kmp_poti_point_t*)kmp->poti_point.list
+			  + kmp->poti_point.used - np;
+
+    //--- xss/yss/zss
+
+    if ( ri->f_xss && fabs(ri->xss[0]-ri->xss[2]) < 1e-6 )
+	ri->f_xss = 0;
+
+    if ( ri->f_yss && fabs(ri->yss[0]-ri->yss[2]) < 1e-6 )
+	ri->f_yss = 0;
+
+    if ( ri->f_zss && fabs(ri->zss[0]-ri->zss[2]) < 1e-6 )
+	ri->f_zss = 0;
+
+    if ( ri->f_xss || ri->f_yss || ri->f_zss )
+    {
+	ri->f_shift = 1;
+	ri->f_scale = 1;
+	AssignVectorV3(&ri->shift,0.0,0.0,0.0);
+	AssignVectorV3(ri->scale,1.0,1.0,1.0);
+
+	if (ri->f_xss)
+	{
+	    double *d = ri->xss;
+	    PRINT("XSS[%d]:     %11.3f %11.3f | %11.3f %11.3f\n",
+		ri->f_xss, d[0], d[1], d[2], d[3] );
+	    const double scale = ( d[3] - d[1] ) / ( d[2] - d[0] );
+	    ri->scale[0].x = scale;
+	    ri->shift.x = d[1] - d[0] * scale;
+	}
+
+	if (ri->f_yss)
+	{
+	    double *d = ri->yss;
+	    PRINT("YSS[%d]:     %11.3f %11.3f | %11.3f %11.3f\n",
+		ri->f_yss, d[0], d[1], d[2], d[3] );
+	    const double scale = ( d[3] - d[1] ) / ( d[2] - d[0] );
+	    ri->scale[0].y = scale;
+	    ri->shift.y = d[1] - d[0] * scale;
+	}
+
+	if (ri->f_zss)
+	{
+	    double *d = ri->zss;
+	    PRINT("ZSS[%d]:     %11.3f %11.3f | %11.3f %11.3f\n",
+		ri->f_zss, d[0], d[1], d[2], d[3] );
+	    const double scale = ( d[3] - d[1] ) / ( d[2] - d[0] );
+	    ri->scale[0].z = scale;
+	    ri->shift.z = d[1] - d[0] * scale;
+	}
+    }
+
+
+    //--- scale
+
+    if ( ri->f_scale > 1 )
+    {
+	Var_t *d = ri->scale;
+	ToVectorV(d+0);
+	ToVectorV(d+1);
+	PRINT("SCALE[%d]:   %11.3f %11.3f %11.3f | %11.3f %11.3f %11.3f\n",
+		ri->f_scale, d[0].x, d[0].y, d[0].z,  d[1].x, d[1].y, d[1].z );
+
+	kmp_poti_point_t *pp = pp0;
+	uint i;
+	for ( i = 0; i < np; i++, pp++ )
+	{
+	    pp->position[0] = ( pp->position[0] - d[1].x ) * d[0].x + d[1].x;
+	    pp->position[1] = ( pp->position[1] - d[1].y ) * d[0].y + d[1].y;
+	    pp->position[2] = ( pp->position[2] - d[1].z ) * d[0].z + d[1].z;
+	}
+    }
+    else if ( ri->f_scale > 0 )
+    {
+	Var_t *d = ri->scale;
+	ToVectorV(d+0);
+	PRINT("SCALE[%d]:   %11.3f %11.3f %11.3f\n",
+		ri->f_scale, d->x, d->y, d->z );
+
+	kmp_poti_point_t *pp = pp0;
+	uint i;
+	for ( i = 0; i < np; i++, pp++ )
+	{
+	    pp->position[0] *= d->x;
+	    pp->position[1] *= d->y;
+	    pp->position[2] *= d->z;
+	}
+    }
+
+
+    //--- shift
+
+    if ( ri->f_shift )
+    {
+	Var_t *d = &ri->shift;
+	ToVectorV(d);
+	PRINT("SHIFT[%d]:   %11.3f %11.3f %11.3f\n",
+		ri->f_shift, d->x, d->y, d->z );
+
+	kmp_poti_point_t *pp = pp0;
+	uint i;
+	for ( i = 0; i < np; i++, pp++ )
+	{
+	    pp->position[0] += d->x;
+	    pp->position[1] += d->y;
+	    pp->position[2] += d->z;
+	}
+     }
+
+
+    //--- hrotate	// [[[hrot]] [[2do]]
+
+    if ( ri->f_hrotate )
+    {
+	Var_t *d = ri->hrotate;
+	ToVectorV(d+1);
+	double rot = GetDoubleV(d++) * (M_PI/180.0);
+	PRINT("HROTATE[%d]: %11.3f %11.3f %11.3f -> %6.3f\n",
+		ri->f_hrotate, d->x, d->y, d->z,  rot );
+
+	kmp_poti_point_t *pp = pp0;
+	uint i;
+	for ( i = 0; i < np; i++, pp++ )
+	{
+	    const double dx = pp->position[0] - d->x;
+	    const double dz = pp->position[2] - d->z;
+	    const double width = sqrt ( dx*dx + dz*dz );
+	    if ( width >= 1e-6 )
+	    {
+		const double new_rot = atan2(dx,dz) + rot;
+		pp->position[0] = d->x + sin(new_rot) * width;
+		pp->position[2] = d->y + cos(new_rot) * width;
+	    }
+	}
+    }
+
+
+    //--- reverse order
+
+    if (ri->reverse_order)
+    {
+	kmp_poti_point_t *pp1 = pp0;
+	kmp_poti_point_t *pp2 = pp0 + np - 1;
+	while ( pp1 < pp2 )
+	{
+	    noPRINT("P: %p %p / %zd %zd\n",pp1,pp2,pp1-pp0,pp2-pp0);
+	    kmp_poti_point_t temp;
+	    memcpy(&temp,pp1,  sizeof(temp));
+	    memcpy(pp1++,pp2,  sizeof(*pp1));
+	    memcpy(pp2--,&temp,sizeof(*pp2));
+	}
+    }
+
+
+    //--- define variables
+
+    uint i;
+    double total_len = 0.0, total_tim = 0.0;
+    kmp_poti_point_t *pp = pp0;
+    for ( i = 0; i < np-1; i++, pp++ )
+    {
+	const double len = LengthF(pp->position,pp[1].position);
+	total_len += len;
+	if ( pp->speed > 0 )
+	    total_tim += len / pp->speed;
+    }
+
+    DefineIndexDouble(si,"LEN",total_len);
+    DefineIndexDouble(si,"TIME",total_tim);
+    DefineIndexDouble(si,"TIME.SET",total_tim);
+
+
+    //--- set route time
+
+    if ( ri->route_time > 0.0 && total_tim > 0.0 )
+    {
+	PRINT("SET ROUTE TIME %s, N=%d+%u, time=%4.2f, len=%5.3f, set=%4.2f\n",
+		last_index_name, kmp->poti_point.used - np, np,
+		total_tim, total_len, ri->route_time );
+
+
+	const double factor = ri->route_time / total_tim;
+	double sum_src = 0.0, sum_dest = 0.0;
+	pp = pp0;
+	for ( i = 0; i < np-1; i++, pp++ )
+	{
+	    if ( pp->speed > 0 )
+	    {
+		const double len = LengthF(pp->position,pp[1].position);
+		const double tim = len / pp->speed;
+		sum_src += tim;
+		const double wanted = sum_src * factor - sum_dest;
+		DASSERT(wanted>=0.0);
+		pp->speed = wanted > 0.0 ? floor( len / wanted + 0.5 ) : 0.0;
+		if (!pp->speed)
+		    pp->speed = 1;
+		sum_dest += len / pp->speed;
+		noPRINT("%6.2f/%4.2f - %6.2f/%4.2f - %6.2f -> %5u\n",
+			sum_src/60.0, total_tim,
+			sum_dest/60.0, total_tim*factor,
+			wanted, pp->speed );
+	    }
+	}
+	DefineIndexDouble(si,"TIME.SET",sum_dest);
+    }
+
+
+    //--- enable ruote itemboxes
+
+    kmp_rtobj_t rtobj;
+    if (AssignRouteInfo(&ri->rtinfo,&rtobj))
+    {
+	const uint max = sizeof(kmp->rtobj_poti)/sizeof(*kmp->rtobj_poti);
+	uint i;
+	for ( i = 0; i <= kmp->n_rtobj_poti; i++ )
+	{
+	    if ( i >= max )
+	    {
+		ERROR0(ERR_WARNING,
+		    "Route list full -> @ROUTE-OBJECT ignored for route #%u",ri->index);
+		break;
+	    }
+
+	    kmp_rtobj_list_t *rptr = kmp->rtobj_poti + i;
+	    if ( i == kmp->n_rtobj_poti )
+	    {
+		rptr->index = ri->index;
+		kmp->n_rtobj_poti++;
+
+	    }
+
+	    if ( rptr->index == ri->index )
+	    {
+		AssignRouteInfo(&ri->rtinfo,&rptr->rtobj);
+		PRINT("@ROUTE-OBJECT[%u] = 0x%x -> %u\n",
+			i, ri->index, rptr->rtobj.obj );
+		break;
+	    }
+	}
+    }
+
+    memset(ri,0,sizeof(*ri));
+    ResetRouteInfo(&ri->rtinfo,&kmp->rtobj);
+    ResetKclFall(&ri->kfall);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static enumError ScanTextPOTI
+(
+    kmp_t		* kmp,		// KMP data structure
+    ScanInfo_t		* si		// valid data
+)
+{
+    DASSERT(kmp);
+    DASSERT(si);
+    TRACE("ScanTextPOTI()\n");
+
+    List_t *glist = kmp->dlist + KMP_POTI;
+    List_t *plist = &kmp->poti_point;
+    glist->used = plist->used = 0;
+
+    Line_t line;
+    InitializeLine(&line);
+    kmp_poti_group_t *grp = 0;
+    u8 g_smooth = 0, g_back = 0;
+
+    int auto_route_name = 0;
+    route_info_t ri = {0};
+    ResetRouteInfo(&ri.rtinfo,&kmp->rtobj);
+    ResetKclFall(&ri.kfall);
+
+    ScanParam_t ptab[] =
+    {
+	{ "AUTO-ROUTE-NAME",    SPM_INT,    &auto_route_name },
+	{ "XSS",		SPM_DOUBLE, ri.xss,     4,4, &ri.f_xss },
+	{ "YSS",		SPM_DOUBLE, ri.yss,     4,4, &ri.f_yss },
+	{ "ZSS",		SPM_DOUBLE, ri.zss,     4,4, &ri.f_zss },
+	{ "SCALE",		SPM_VAR,    ri.scale,   1,2, &ri.f_scale },
+	{ "SHIFT",		SPM_VAR,    &ri.shift,  1,1, &ri.f_shift },
+// [[[hrot]] [[2do]]
+	{ "HROTATE",		SPM_VAR,    ri.hrotate, 1,2, &ri.f_hrotate },
+	{ "REVERSE-ORDER",	SPM_INT,    &ri.reverse_order },
+	{ "SET-ROUTE-TIME",	SPM_DOUBLE, &ri.route_time },
+	ROUTE_OBJECT_VARS(ri.rtinfo)
+	KCL_FALL_VARS(kmp,ri.kfall)
+	{0}
+    };
+
+    for(;;)
+    {
+	char ch = NextCharSI(si,true);
+	if ( !ch || ch == '[' )
+	    break;
+
+	if ( ch == '@' )
+	{
+	    ScanParamSI(si,ptab);
+	    CheckRouteInfo(&ri.rtinfo);
+	    CheckKclFall(&ri.kfall);
+	    continue;
+	}
+
+	if ( ch == '$' )
+	{
+	    char name[KMP_MAX_NAME_LEN+1];
+	    ScanNameSI(si,name,sizeof(name),true,true,0);
+
+	    const int is_bezier = !strcmp(name,"$BEZIER");
+	    if ( is_bezier || !strcmp(name,"$LINE") )
+	    {
+		enumError err = ScanLine(&line,si,3,is_bezier);
+		if (err)
+		    return err;
+		continue;
+	    }
+
+	    if ( !strcmp(name,"$COPY") )
+	    {
+		uint r_idx;
+		if (ScanU32SI(si,&r_idx,1,0))
+		    continue;
+
+		if ( r_idx >= glist->used )
+		{
+		    ScanFile_t *sf = si->cur_file;
+		    DASSERT(sf);
+		    si->total_err++;
+		    sf->line_err++;
+		    ERROR0(ERR_WARNING,
+				"Can't copy unknown route #%u [%s @%u]\n",
+				r_idx, sf->name, sf->line );
+		    GotoEolSI(si);
+		}
+
+		uint r_beg = 0, r_end = UINT_MAX;
+		if (NextCharSI(si,false))
+		{
+		    if (ScanU32SI(si,&r_beg,1,0))
+			continue;
+
+		    if (NextCharSI(si,false))
+		    {
+			if (ScanU32SI(si,&r_end,1,0))
+			    continue;
+			r_end++;
+		    }
+		}
+
+		const kmp_poti_group_t *srcgrp = GetListElem(glist,r_idx,0);
+		DASSERT(srcgrp);
+		if ( r_end > srcgrp->n_point )
+		     r_end = srcgrp->n_point;
+		PRINT("COPY ROUTE: %u,%u..%u\n",r_idx,r_beg,r_end);
+		if ( r_beg >= r_end )
+		    continue;
+
+		const kmp_poti_point_t * psrc = GetListElem(plist,0,0);
+		psrc += r_beg;
+		while ( r_idx > 0 )
+		{
+		    r_idx--;
+		    const kmp_poti_group_t *g = GetListElem(glist,r_idx,0);
+		    DASSERT(g);
+		    psrc += g->n_point;
+		}
+		DASSERT( psrc < (kmp_poti_point_t*)GetListElem(plist,0,0) + plist->used );
+
+		if (!grp)
+		{
+		    grp = AppendList(glist);
+		    grp->smooth = g_smooth;
+		    grp->back   = g_back;
+		}
+		DASSERT(grp);
+		grp->n_point += r_end - r_beg;
+
+		for ( ; r_beg < r_end; r_beg++, psrc++ )
+		{
+		    kmp_poti_point_t * pdest = AppendList(plist);
+		    memcpy(pdest,psrc,sizeof(*pdest));
+		}
+		kmp->value[KMP_POTI] = plist->used;
+		continue;
+	    }
+
+	    const bool cmd_close = !strcmp(name,"$CLOSE");
+	    if ( !cmd_close && strcmp(name,"$ROUTE") && strcmp(name,"$GROUP") )
+	    {
+		ScanFile_t *sf = si->cur_file;
+		DASSERT(sf);
+		si->total_err++;
+		sf->line_err++;
+		CheckEolSI(si);
+		ERROR0(ERR_WARNING,
+			"Line ignored [%s @%u]: %s ...\n",
+			sf->name, sf->line, name );
+		continue;
+	    }
+
+
+	    //--- close group
+
+	    if (grp)
+		CloseRoute(kmp,si,grp,&ri);
+	    grp = 0;
+
+	    if (cmd_close)
+		continue;
+
+	    ScanIndexSI(si,0,glist->used,kmp->index+KMP_POTI,2);
+
+	    for(;;)
+	    {
+		char ch = NextCharSI(si,false);
+		noPRINT("--> %02x : %.6s\n",ch,si->cur_file->ptr);
+		if (!ch)
+		    break;
+		si->cur_file->ptr++;
+		if ( ch == ':' )
+		    break;
+	    }
+	    u16 g_temp;
+	    ScanU16SI(si,&g_temp,1,0);
+	    if (NextCharSI(si,false))
+	    {
+		g_smooth = g_temp;
+		ScanU8SI(si,&g_back,1,0);
+	    }
+	    else
+	    {
+		g_smooth = g_temp >> 8;
+		g_back   = (u8)g_temp;
+	    }
+	    noPRINT("ROUTE: smooth=%u, back=%u\n",g_smooth,g_back);
+	    CheckEolSI(si);
+	    continue;
+	}
+
+	if ( !grp || !grp->n_point ) // no previous point available
+	    line.n = 1;
+	enumError err;
+	ScanIndexSI(si,&err, grp ? grp->n_point + line.n -1 : 0, 0,2);
+	if (err)
+	    break;
+
+	if (!grp)
+	{
+	    ri.index = glist->used;
+	    grp = AppendList(glist);
+	    grp->smooth = g_smooth;
+	    grp->back   = g_back;
+	}
+	DASSERT(grp);
+	grp->n_point += line.n;
+
+	kmp_poti_point_t temp;
+	ScanFloatV3SI(si,temp.position,1);
+	if ( si->cur_file->szs_modifier > 0 )
+	    ScanBE32SI_swap(si,(u32*)&temp.speed,1,1);
+	else
+	    ScanU16SI(si,&temp.speed,2,0);
+	CheckEolSI(si);
+
+	const kmp_poti_point_t * prev = GetListElem(plist,-1,&temp);
+
+	uint p;
+	for ( p = 1; p <= line.n; p++ )
+	{
+	    kmp_poti_point_t * ppos = AppendList(plist);
+	    memcpy(ppos,&temp,sizeof(*ppos));
+	    CalcLine(&line,ppos->position,prev->position,temp.position,3,p);
+	    CalcKclFall(&ri.kfall,ppos->position);
+	}
+	kmp->value[KMP_POTI] = plist->used;
+	InitializeLine(&line);
+    }
+    if (grp)
+	CloseRoute(kmp,si,grp,&ri);
+    CheckLevelSI(si);
+
+    if ( auto_route_name > 0 )
+    {
+	ResetIL(kmp->index+KMP_POTI);
+	FillIL(kmp->index+KMP_POTI,glist->used);
+    }
+
+    return ERR_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static kmp_gobj_entry_t * AddObject
+(
+    kmp_t		* kmp,		// KMP data structure
+    const float		* pos,		// 3D vector with position
+    const float		* rot,		// NULL or a rotation 3D vector
+    kmp_rtobj_t		* rtobj		// object to insert
+)
+{
+    DASSERT(kmp);
+    DASSERT(pos);
+    DASSERT(rtobj);
+    DASSERT( rtobj->obj > 0 && rtobj->obj < N_KMP_GOBJ );
+
+    List_t *glist  = kmp->dlist + KMP_GOBJ;
+    kmp_gobj_entry_t *gobj = AppendList(glist);
+    gobj->obj_id = rtobj->obj;
+    gobj->position[0] = pos[0] + rtobj->shift.x;
+    gobj->position[1] = pos[1] + rtobj->shift.y;
+    gobj->position[2] = pos[2] + rtobj->shift.z;
+    memcpy(gobj->scale,rtobj->scale.v,sizeof(gobj->scale));
+    memcpy(gobj->rotation,rtobj->rotate.v,sizeof(gobj->rotation));
+    gobj->route_id = (typeof(gobj->route_id))~0;
+    gobj->pflags = 0x3f;
+    if (rot)
+    {
+	gobj->rotation[0] = NormDegreeF( gobj->rotation[0] + rot[0] );
+	gobj->rotation[1] = NormDegreeF( gobj->rotation[1] + rot[1] );
+	gobj->rotation[2] = NormDegreeF( gobj->rotation[2] + rot[2] );
+    }
+    return gobj;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void AddEnemyRouteObjects
+(
+    kmp_t		* kmp,		// KMP data structure
+    uint		sect,		// KMP section index
+    kmp_rtobj_t		*rtobj		// object to insert
+)
+{
+    DASSERT(kmp);
+    DASSERT(rtobj);
+    DASSERT( sect == KMP_ENPT || sect == KMP_ITPT );
+
+    if (rtobj->obj)
+    {
+	PRINT("AddEnemyRouteObjects(%s)\n",kmp_section_name[sect].name1);
+	const uint n = kmp->dlist[sect].used;
+	const kmp_enpt_entry_t * pt = (kmp_enpt_entry_t*)kmp->dlist[sect].list;
+
+	uint i;
+	for ( i = 0; i < n; i++ )
+	{
+	    int last = -1, link;
+	    for ( link = 0; link < KMP_MAX_PH_LINK; link++ )
+	    {
+		int next = GetNextPointKMP(kmp,sect,i,link,false,-1,0,0,0,0);
+		if ( next >= 0 && next != last )
+		{
+		    last = next;
+		    float3 rot = CalcDirection3F(pt[i].position,pt[next].position);
+		    AddObject(kmp,pt[i].position,rot.v,rtobj);
+		}
+	    }
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void AddJugemRouteObjects
+(
+    kmp_t		* kmp,		// KMP data structure
+    uint		sect,		// KMP section index
+    kmp_rtobj_t		*rtobj		// object to insert
+)
+{
+    DASSERT(kmp);
+    DASSERT(rtobj);
+    DASSERT( sect == KMP_JGPT || sect == KMP_CNPT || sect == KMP_MSPT );
+
+    if (rtobj->obj)
+    {
+	PRINT("AddJugemRouteObjects(%s)\n",kmp_section_name[sect].name1);
+	const uint n = kmp->dlist[sect].used;
+	const kmp_jgpt_entry_t * pt = (kmp_jgpt_entry_t*)kmp->dlist[sect].list;
+
+	uint i;
+	for ( i = 0; i < n; i++, pt++ )
+	    AddObject(kmp,pt->position,pt->rotation,rtobj);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void AddRouteObjects
+(
+    kmp_t		* kmp		// KMP data structure
+)
+{
+    DASSERT(kmp);
+    PRINT("AddRouteObjects()\n");
+
+    const uint ng = kmp->dlist[KMP_POTI].used;
+    uint ilist;
+    kmp_rtobj_list_t *rptr = kmp->rtobj_poti;
+    for ( ilist = 0; ilist < kmp->n_rtobj_poti; ilist++, rptr++ )
+    {
+	int route_idx = rptr->index;
+	if ( route_idx < 0 || route_idx >= ng || !rptr->rtobj.obj )
+	    continue;
+
+	PRINT("ROUTE-ITEMBOX %u/%u -> %d/%u\n",
+		ilist, kmp->n_rtobj_poti, route_idx, ng );
+	const kmp_poti_group_t *grp = (kmp_poti_group_t*)kmp->dlist[KMP_POTI].list;
+	kmp_poti_point_t *pt = (kmp_poti_point_t*)kmp->poti_point.list;
+	while ( route_idx-- > 0 )
+	{
+	    pt += grp->n_point;
+	    grp++;
+	}
+
+	uint i;
+	for ( i = 0; i < grp->n_point; i++ )
+	{
+	    float3 rot = CalcDirection3F( pt[i].position,
+					  pt[ (i+1) % grp->n_point ].position );
+	    AddObject( kmp, pt[i].position, rot.v, &rptr->rtobj );
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void setup_scale ( Var_t *dest, const Var_t *src )
+{
+    DASSERT(dest);
+    DASSERT(src);
+
+    if ( src->mode == VAR_VECTOR )
+	AssignVar(dest,src);
+    else
+	AssignVectorV3(dest,0.0,GetYDoubleV(src),0.0);
+    DASSERT( dest->mode == VAR_VECTOR );
+
+    if ( dest->x <= 0.0 )
+	dest->x = RTOBJ_SCALE_X;
+    else if ( dest->x < RTOBJ_SCALE_MIN )
+	dest->y = RTOBJ_SCALE_MIN;
+
+    if ( dest->y <= 0.0 )
+	dest->y = RTOBJ_SCALE_Y;
+    else if ( dest->y < RTOBJ_SCALE_MIN )
+	dest->y = RTOBJ_SCALE_MIN;
+
+    if ( dest->z <= 0.0 )
+	dest->z = RTOBJ_SCALE_Z;
+    else if ( dest->z < RTOBJ_SCALE_MIN )
+	dest->y = RTOBJ_SCALE_MIN;
+}
+
+//-----------------------------------------------------------------------------
+
+static void AddCheckpointObject
+(
+    kmp_t		* kmp		// KMP data structure
+)
+{
+    DASSERT(kmp);
+    PRINT("AddCheckpointObject()\n");
+
+    struct obj_t
+    {
+	int	object;
+	Var_t	scale;
+	float	base;
+
+    } obj1, obj2;
+
+    obj1.object = kmp->ckpt_object1 > 0 && kmp->ckpt_object1 < N_KMP_GOBJ
+			? kmp->ckpt_object1 : 0;
+    setup_scale(&obj1.scale,&kmp->ckpt_object1_scale);
+    obj1.base = kmp->ckpt_object1_base;
+
+    obj2.object = kmp->ckpt_object2 > 0 && kmp->ckpt_object2 < N_KMP_GOBJ
+			? kmp->ckpt_object2 : 0;
+    setup_scale(&obj2.scale,&kmp->ckpt_object2_scale);
+    obj2.base = kmp->ckpt_object2_base;
+
+    const struct obj_t *obj_lap_lt = 0, *obj_lap_rt = 0;
+    const struct obj_t *obj_man_lt = 0, *obj_man_rt = 0;
+    const struct obj_t *obj_std_lt = 0, *obj_std_rt = 0;
+
+    switch (kmp->ckpt_object_mode)
+    {
+	case 1:
+	    obj_lap_lt = &obj2;
+	    obj_lap_rt = &obj2;
+	    obj_man_lt = &obj1;
+	    obj_man_rt = &obj1;
+	    break;
+
+	case 2:
+	    obj_lap_lt = &obj2;
+	    obj_lap_rt = &obj2;
+	    obj_man_lt = &obj2;
+	    obj_man_rt = &obj2;
+	    obj_std_lt = &obj1;
+	    obj_std_rt = &obj1;
+	    break;
+
+	case 3:
+	    obj_lap_lt = &obj1;
+	    obj_lap_rt = &obj2;
+	    obj_man_lt = &obj1;
+	    obj_man_rt = &obj2;
+	    obj_std_lt = &obj1;
+	    obj_std_rt = &obj2;
+	    break;
+
+	default:
+	    return;
+    }
+
+    opt_auto_add = true;
+
+    List_t *glist = kmp->dlist + KMP_GOBJ;
+    const kmp_ckpt_entry_t *pt = (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list;
+    uint i, n = kmp->dlist[KMP_CKPT].used;
+    for ( i = 0; i < n; i++, pt++ )
+    {
+	double direction, factor = IS_M1(pt->mode) ? 1.0 : 3.0;
+	WidthAndDirection(0,&direction,true,pt->left,pt->right);
+
+	const struct obj_t *obj;
+	obj = IS_M1(pt->mode) ? obj_std_lt : pt->mode ? obj_man_lt : obj_lap_lt;
+	if (obj)
+	{
+	    kmp_gobj_entry_t *go = AppendList(glist);
+	    go->obj_id		= obj->object;
+	    go->position[0]	= pt->left[0];
+	    go->position[1]	= obj->base;
+	    go->position[2]	= pt->left[1];
+	    go->rotation[1]	= direction;
+	    go->scale[0]	= obj->scale.x * factor;
+	    go->scale[1]	= obj->scale.y;
+	    go->scale[2]	= obj->scale.z * factor;
+	    go->route_id	= (typeof(go->route_id))~0;
+	    go->pflags		= 0x3f;
+	}
+
+	obj = IS_M1(pt->mode) ? obj_std_rt : pt->mode ? obj_man_rt : obj_lap_rt;
+	if (obj)
+	{
+	    kmp_gobj_entry_t *go = AppendList(glist);
+	    go->obj_id		= obj->object;
+	    go->position[0]	= pt->right[0];
+	    go->position[1]	= obj->base;
+	    go->position[2]	= pt->right[1];
+	    go->rotation[1]	= direction;
+	    go->scale[0]	= obj->scale.x * factor;
+	    go->scale[1]	= obj->scale.y;
+	    go->scale[2]	= obj->scale.z * factor;
+	    go->route_id	= (typeof(go->route_id))~0;
+	    go->pflags		= 0x3f;
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void SnapToENPT
+(
+    kmp_t		* kmp,		// KMP data structure
+    uint		sect		// KMP section index
+)
+{
+    const Var_t * add2;  // not NULL: enter 2D-full mode && value to add
+    const Var_t	* add1;	 // not NULL: enter 1D-full mode && value to add
+    const Var_t	* hadd;  // not NULL: enter horiz-mode && value to add
+    const kmp_flag_t *kf = 0;
+
+    switch(sect)
+    {
+	case KMP_JGPT:
+	    add2	= &kmp->jgpt_snap2;
+	    add1	= &kmp->jgpt_snap;
+	    hadd	= &kmp->jgpt_hsnap;
+	    kf		= &kmp->jgpt_flag;
+	    break;
+
+	case KMP_CNPT:
+	    add2	= &kmp->cnpt_snap2;
+	    add1	= &kmp->cnpt_snap;
+	    hadd	= &kmp->cnpt_hsnap;
+	    break;
+
+	case KMP_MSPT:
+	    add2	= &kmp->mspt_snap2;
+	    add1	= &kmp->mspt_snap;
+	    hadd	= &kmp->mspt_hsnap;
+	    break;
+
+	default:
+	    ASSERT(0);
+	    return;
+    }
+
+    const Var_t *add;
+    enum { MODE2, MODE1, HMODE } mode;
+
+    if ( add2 && add2->mode != VAR_UNSET )
+    {
+	mode = MODE2;
+	add = add2;
+    }
+    else if ( add1 && add1->mode != VAR_UNSET )
+    {
+	mode = MODE1;
+	add = add1;
+    }
+    else if ( hadd && hadd->mode != VAR_UNSET )
+    {
+	mode = HMODE;
+	add = hadd;
+    }
+    else
+	return;
+
+    PRINT("SnapToENPT(%s) mode=%d\n",kmp_section_name[sect].name1,mode);
+
+    const uint n_enpt = kmp->dlist[KMP_ENPT].used;
+    if (!n_enpt)
+	return;
+    const kmp_enpt_entry_t *enpt1 = (kmp_enpt_entry_t*)kmp->dlist[KMP_ENPT].list;
+
+    kmp_jgpt_entry_t *pt = (kmp_jgpt_entry_t*)kmp->dlist[sect].list;
+    kmp_jgpt_entry_t *pt_end = pt + kmp->dlist[sect].used;
+
+    uint j;
+    for ( j = 0; pt < pt_end; j++, pt++ )
+    {
+	if ( kf && j < KMP_MAX_POINT && !( kf->flags[j] & KPFL_SNAP ) )
+	    continue;
+
+	int i, enpt_idx = -1;
+	double min_dist = 0.0;
+	const kmp_enpt_entry_t *enpt;
+	for ( i = 0, enpt = enpt1; i < n_enpt; i++, enpt++ )
+	{
+	    if ( i < KMP_MAX_POINT && !( kmp->enpt_flag.flags[i] & KPFL_SNAP ))
+		continue;
+
+	    const double dx = pt->position[0] - enpt->position[0];
+	    const double dy = pt->position[1] - enpt->position[1];
+	    const double dz = pt->position[2] - enpt->position[2];
+	    const double dist = dx*dx + dy*dy + dz*dz;
+	    if ( enpt_idx < 0 || min_dist > dist )
+	    {
+		min_dist = dist;
+		enpt_idx = i;
+	    }
+	}
+	if ( enpt_idx < 0 )
+	    break; // no usable ENPT found -> abort
+
+	uint next_idx = GetNextPointKMP(kmp,KMP_ENPT,enpt_idx,-1,false,0,0,0,0,0);
+	DASSERT( next_idx < n_enpt );
+
+	enpt = enpt1 + enpt_idx;
+
+	DEFINE_VAR(var);
+	var.mode = VAR_VECTOR;
+	var.x = enpt->position[0];
+	var.y = mode == HMODE ? pt->position[1] : enpt->position[1];
+	var.z = enpt->position[2];
+	DASSERT(add);
+	CalcExpr(&var,add,OPI_ADD,0);
+	pt->position[0] = var.x;
+	pt->position[1] = var.y;
+	pt->position[2] = var.z;
+
+	const kmp_enpt_entry_t *next = enpt1 + next_idx;
+	if ( mode == MODE2 )
+	{
+	    double3 p1, p2;
+	    p1.x = enpt->position[0];
+	    p1.y = enpt->position[1];
+	    p1.z = enpt->position[2];
+	    p2.x = next->position[0];
+	    p2.y = next->position[1];
+	    p2.z = next->position[2];
+	    double3 dir = CalcDirection3D(&p1,&p2);
+	    pt->rotation[0] = dir.x;
+	    pt->rotation[1] = dir.y;
+	    pt->rotation[2] = dir.z;
+	}
+	else
+	{
+	    pt->rotation[0] = pt->rotation[2] = 0.0;
+	    pt->rotation[1] = atan2( next->position[0] - enpt->position[0],
+				 next->position[2] - enpt->position[2] ) * (180/M_PI);
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int FindNearestJGPT2
+(
+    kmp_t	*kmp,		// valid KMP
+    double	x,		// x-coordinate
+    double	z,		// z-coordinate
+    double	*res_dist2	// not NULL: store distance^2 here
+)
+{
+    DASSERT(kmp);
+
+    int found = -1;
+    double max_dist2 = 1e30;
+
+    const uint n_jgpt = kmp->dlist[KMP_JGPT].used;
+    kmp_jgpt_entry_t *jgpt = (kmp_jgpt_entry_t*)kmp->dlist[KMP_JGPT].list;
+
+    uint i;
+    for ( i = 0; i < n_jgpt; i++, jgpt++ )
+    {
+	const double dx = x - jgpt->position[0];
+	const double dz = z - jgpt->position[2];
+	const double dist2 = dx*dx + dz*dz;
+	if ( max_dist2 > dist2 )
+	{
+	    max_dist2 = dist2;
+	    found = i;
+	}
+    }
+
+    if ( res_dist2 )
+	*res_dist2 = max_dist2;
+    return found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static int FindNearestJGPT3
+(
+    kmp_t		*kmp,		// valid KMP
+    const float32	*pos,		// 3d coordinates
+    double		*res_dist2	// not NULL: store distance^2 here
+)
+{
+    DASSERT(kmp);
+    DASSERT(pos);
+
+    int found = -1;
+    double max_dist2 = 1e30;
+
+    const uint n_jgpt = kmp->dlist[KMP_JGPT].used;
+    kmp_jgpt_entry_t *jgpt = (kmp_jgpt_entry_t*)kmp->dlist[KMP_JGPT].list;
+
+    uint i;
+    for ( i = 0; i < n_jgpt; i++, jgpt++ )
+    {
+	double3 d;
+	d.x = pos[0] - jgpt->position[0];
+	d.y = pos[1] - jgpt->position[1];
+	d.z = pos[2] - jgpt->position[2];
+	const double dist2 = LengthSqare3(d);
+	if ( max_dist2 > dist2 )
+	{
+	    max_dist2 = dist2;
+	    found = i;
+	}
+    }
+
+    if ( res_dist2 )
+	*res_dist2 = max_dist2;
+    return found;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void AutoRespawn ( kmp_t * kmp )
+{
+    DASSERT(kmp);
+
+
+    //--- auto add respawn points
+
+    const uint min_rm = kmp->jgpt_auto_remove > 1 ? 0 : kmp->dlist[KMP_JGPT].used;
+    const int sect = kmp->jgpt_auto_define - 1;
+    if ( sect == KMP_ENPT || sect == KMP_ITPT )
+    {
+	const uint n = kmp->dlist[sect].used;
+	const kmp_enpt_entry_t *pt0 = (kmp_enpt_entry_t*)kmp->dlist[sect].list;
+	const kmp_enpt_entry_t *pt = pt0;
+	const kmp_flag_t *kf = sect == KMP_ENPT ? &kmp->enpt_flag : &kmp->itpt_flag;
+
+	uint i;
+	for ( i = 0; i < n && kmp->dlist[KMP_JGPT].used < KMP_MAX_POINT; i++, pt++ )
+	{
+	    if ( i < KMP_MAX_POINT && !( kf->flags[i] & KPFL_JGPT ) )
+		continue;
+
+	    double dist2;
+	    FindNearestJGPT3(kmp,pt->position,&dist2);
+	    if ( dist2 > kmp->jgpt_auto_distance )
+	    {
+		kmp_jgpt_entry_t * entry = AppendList(kmp->dlist+KMP_JGPT);
+		entry->position[0] = pt->position[0] + kmp->jgpt_auto_adjust.x;
+		entry->position[1] = pt->position[1] + kmp->jgpt_auto_adjust.y;
+		entry->position[2] = pt->position[2] + kmp->jgpt_auto_adjust.z;
+		entry->id = kmp->dlist[KMP_JGPT].used - 1;
+		entry->effect = M1(entry->effect);
+
+		uint next_idx = GetNextPointKMP(kmp,KMP_ENPT,i,-1,false,0,0,0,0,0);
+		DASSERT( next_idx < n );
+		const kmp_enpt_entry_t *next = pt0 + next_idx;
+
+		double3 p1, p2;
+		p1.x = pt->position[0];
+		p1.y = pt->position[1];
+		p1.z = pt->position[2];
+		p2.x = next->position[0];
+		p2.y = next->position[1];
+		p2.z = next->position[2];
+		double3 dir = CalcDirection3D(&p1,&p2);
+		entry->rotation[0] = dir.x;
+		entry->rotation[1] = dir.y;
+		entry->rotation[2] = dir.z;
+	    }
+	}
+    }
+
+
+    //--- auto connect check points to respawn points
+
+    u8 jgpt_used[KMP_MAX_POINT];
+    memset(jgpt_used,0,sizeof(jgpt_used));
+
+    const uint n_ckpt	= kmp->dlist[KMP_CKPT].used < KMP_MAX_POINT
+			? kmp->dlist[KMP_CKPT].used : KMP_MAX_POINT;
+    kmp_ckpt_entry_t *ckpt = (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list;
+    uint i;
+    for ( i = 0; i < n_ckpt; i++, ckpt++ )
+    {
+	if ( kmp->ckpt_auto_respawn[i] )
+	{
+	    const double x = ( ckpt->left[0] + ckpt->right[0] ) / 2;
+	    const double z = ( ckpt->left[1] + ckpt->right[1] ) / 2;
+	    ckpt->respawn = FindNearestJGPT2(kmp,x,z,0);
+	}
+	if ( (uint)ckpt->respawn < KMP_MAX_POINT )
+	    jgpt_used[ckpt->respawn] = 1;
+    }
+
+
+    //--- remove unused respawn points
+
+    const uint n_jgpt = kmp->dlist[KMP_JGPT].used;
+    if ( kmp->jgpt_auto_remove > 0 && n_jgpt > min_rm )
+    {
+	PRINT("--> JGPT: auto remove: %u..%u\n",min_rm,n_jgpt-1);
+
+	u8 map[KMP_MAX_POINT];
+	memset(map,0,sizeof(map));
+
+	kmp_jgpt_entry_t *base = (kmp_jgpt_entry_t*)kmp->dlist[KMP_JGPT].list;
+	kmp_jgpt_entry_t *src = base, *dest = base;
+
+	uint i, new_idx = 0;
+	for ( i = 0; i < n_jgpt; i++, src++ )
+	{
+	    if (jgpt_used[i])
+	    {
+		new_idx = dest - base;
+		memcpy(dest,src,sizeof(*dest));
+		dest++;
+	    }
+	    map[i] = new_idx;
+	}
+	kmp->dlist[KMP_JGPT].used = dest - base;
+	//HEXDUMP16(0,0,map,sizeof(map));
+
+	kmp_ckpt_entry_t *ckpt = (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list;
+	for ( i = 0; i < n_ckpt; i++, ckpt++ )
+	    ckpt->respawn = map[ckpt->respawn];
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		   ScanTextKMP(): reference KCL		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static void DefineReferenceKCLbyKMP ( kmp_t *kmp )
+{
+    kcl_ref_prio = 0;
+
+    if ( kmp && kmp->enable_fall_kcl )
+    {
+	if (kmp->fall_kcl)
+	{
+	    ResetKCL(kmp->fall_kcl);
+	    FREE(kmp->fall_kcl);
+	    kmp->fall_kcl = 0;
+	}
+
+	DrawKCL_t dk;
+	memset(&dk,0,sizeof(dk));
+
+	const draw_mode_t pflags = ( KMP_DRAW & DMD_M_PFLAGS ) >> DMD_SHIFT_PFLAGS;
+
+	uint n = kmp->dlist[KMP_GOBJ].used;
+	PRINT("\e[36;1m### DefineReferenceKCLbyKMP(), N(GOBJ) = %u\e[0m\n",n);
+	const kmp_gobj_entry_t *op = (kmp_gobj_entry_t*)kmp->dlist[KMP_GOBJ].list;
+	for ( ; n > 0; n--, op++ )
+	{
+	    if ( op->obj_id < N_KMP_GOBJ
+		&& ObjectInfo[op->obj_id].flags & OBF_ROAD
+		&& ( !pflags || pflags & op->pflags )
+	       )
+	    {
+		if (!kmp->fall_kcl)
+		{
+		    kcl_t *ref = LoadReferenceKCL();
+		    PRINT("\e[36;1m### CREATE KMP, kcl_ref=%d\e[0m\n",ref!=0);
+		    if (!ref)
+			break;
+
+		    kmp->fall_kcl = MALLOC(sizeof(kcl_t));
+		    CopyKCL(kmp->fall_kcl,true,ref);
+		    kmp->fall_kcl->silent_octree = true;
+		    kmp->fall_kcl->fast = true;
+		    dk.kcl = dk.draw = kcl_ref_prio = kmp->fall_kcl;
+		    dk.kmp = kmp;
+		    dk.detailed = dk.as_road = true;
+		}
+		AddObject2KCL(&dk,op);
+	    }
+	}
+    }
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			  ScanTextKMP()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanTextKMP
+(
+    kmp_t		* kmp,		// KMP data structure
+    bool		init_kmp,	// true: initialize 'kmp' first
+    const void		* data,		// data to scan
+    uint		data_size	// size of 'data'
+)
+{
+    PRINT("ScanTextKMP(init=%d)\n",init_kmp);
+    KMP_ACTION_LOG(false,"ScanTextKMP() %s\n",kmp->fname);
+
+    DASSERT(kmp);
+    if (init_kmp)
+	InitializeKMP(kmp);
+    else if (kmp->fname)
+	DefineAutoLoadReferenceKCL(kmp->fname,".kmp.txt");
+
+    ScanInfo_t si;
+    InitializeSI(&si,data,data_size,kmp->fname,kmp->revision);
+    si.predef = SetupVarsKMP();
+
+    enumError max_err = ERR_OK;
+    kmp->is_pass2 = false;
+
+    for(;;)
+    {
+	PRINT("----- SCAN KMP SECTIONS, PASS%u ...\n",kmp->is_pass2+1);
+
+	max_err = ERR_OK;
+	si.kmp = kmp;
+	si.no_warn = !kmp->is_pass2;
+	si.total_err = 0;
+	DefineIntVar(&si.gvar, "$PASS", kmp->is_pass2+1 );
+
+	for(;;)
+	{
+	    char ch = NextCharSI(&si,true);
+	    if (!ch)
+		break;
+
+	    if ( ch != '[' )
+	    {
+		NextLineSI(&si,true,false);
+		continue;
+	    }
+	    ResetLocalVarsSI(&si,kmp->revision);
+
+	    si.cur_file->ptr++;
+	    char name[20];
+	    ScanNameSI(&si,name,sizeof(name),true,true,0);
+	    noPRINT("--> pass=%u: #%04u: %s\n",kmp->is_pass2+1,si.cur_file->line,name);
+
+	    int abbrev_count;
+	    const KeywordTab_t *cmd = ScanKeyword(&abbrev_count,name,kmp_section_name);
+	    if ( !cmd || abbrev_count )
+		continue;
+	    NextLineSI(&si,false,false);
+	    noPRINT("--> %-6s #%-4u |%.3s|\n",cmd->name1,si.cur_file->line,si.cur_file->ptr);
+
+	    enumError err = ERR_OK;
+	    switch (cmd->id)
+	    {
+		case KMP_KTPT:
+		    err = ScanTextKTPT(kmp,&si);
+		    break;
+
+		case KMP_ENPT:
+		    err = ScanText_PT_PH( kmp, &si, KMP_ENPT );
+		    break;
+
+		case KMP_ITPT:
+		    err = ScanText_PT_PH( kmp, &si, KMP_ITPT );
+		    break;
+
+		case KMP_CKPT:
+		    err = ScanTextCKPT(kmp,&si);
+		    break;
+
+		case KMP_GOBJ:
+		    err = ScanTextGOBJ(kmp,&si);
+		    break;
+
+		case KMP_POTI:
+		    err = ScanTextPOTI(kmp,&si);
+		    break;
+
+		case KMP_AREA:
+		    err = ScanTextAREA(kmp,&si);
+		    break;
+
+		case KMP_CAME:
+		    err = ScanTextCAME(kmp,&si);
+		    break;
+
+		case KMP_JGPT:
+		    err = ScanTextPT2(kmp,&si,KMP_JGPT);
+		    break;
+
+		case KMP_CNPT:
+		    err = ScanTextPT2(kmp,&si,KMP_CNPT);
+		    break;
+
+		case KMP_MSPT:
+		    err = ScanTextPT2(kmp,&si,KMP_MSPT);
+		    break;
+
+		case KMP_STGI:
+		    err = ScanTextSTGI(kmp,&si);
+		    break;
+
+		case KMP_N_SECT: // alias for [SETUP]
+		    err = ScanTextSETUP(kmp,&si);
+		    break;
+
+		default:
+		    // ignore all other section without any warnings
+		    break;
+	    }
+
+	    if ( max_err < err )
+		 max_err = err;
+	}
+
+	if (kmp->is_pass2)
+	    break;
+
+	kmp->is_pass2 = true;
+
+	DefineReferenceKCLbyKMP(kmp);
+	RestartSI(&si);
+	ClearSectionsKMP(kmp);
+    }
+
+ #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(ScanTextKMP) = %u (errcount=%u)\n", max_err, si.total_err );
+    ResetSI(&si);
+
+    SnapToENPT(kmp,KMP_JGPT);
+    SnapToENPT(kmp,KMP_CNPT);
+    SnapToENPT(kmp,KMP_MSPT);
+
+    AutoRespawn(kmp);
+
+    AddEnemyRouteObjects(kmp,KMP_ENPT,&kmp->rtobj_enpt);
+    AddEnemyRouteObjects(kmp,KMP_ITPT,&kmp->rtobj_itpt);
+    AddJugemRouteObjects(kmp,KMP_JGPT,&kmp->rtobj_jgpt);
+    AddJugemRouteObjects(kmp,KMP_CNPT,&kmp->rtobj_cnpt);
+    AddJugemRouteObjects(kmp,KMP_MSPT,&kmp->rtobj_mspt);
+    AddRouteObjects(kmp);
+    AddCheckpointObject(kmp);
+
+    if (opt_generic)
+    {
+	uint sect;
+	for ( sect = 0; sect < KMP_N_SECT; sect++ )
+	{
+	    ResetIL(kmp->index+sect);
+	    FillIL(kmp->index+sect,kmp->dlist[sect].used);
+	}
+    }
+
+    kmp->battle_mode = CheckBattleModeKMP(kmp);
+    DefineReferenceKCLbyKMP(0);
+    return max_err;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			SaveTextKMP() helpers		///////////////
+///////////////////////////////////////////////////////////////////////////////
+// [[print_kmp_group_t]]
+
+typedef struct print_kmp_group_t
+{
+    int				index;		// current group index
+    int				max;		// max group index
+    const kmp_enph_entry_t	*ph;		// pointer to next ph element
+    const kmp_group_name_t	*gname;		// list with names
+
+} print_kmp_group_t;
+
+//-----------------------------------------------------------------------------
+
+static void init_print_kmp_group
+(
+    print_kmp_group_t		* grp,		// group element, will be initialized
+    const kmp_t			* kmp,		// KMP data structure
+    uint			sect_ph,	// related ph section index, may be invalid
+    const kmp_group_name_t	* gname		// list with names
+)
+{
+    DASSERT(grp);
+    DASSERT(kmp);
+
+    memset(grp,0,sizeof(*grp));
+
+    if ( sect_ph < KMP_N_SECT )
+    {
+	grp->max   = kmp->dlist[sect_ph].used;
+	grp->ph    = (kmp_enph_entry_t*)kmp->dlist[sect_ph].list;
+	grp->gname = gname;
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+static ccp print_kmp_group
+(
+    File_t		* F,		// output file
+    const kmp_t		* kmp,		// KMP data structure
+    const kmp_ph_t	* ph,		// related PH info
+    print_kmp_group_t	* grp,		// group element, will be initialized
+    uint		index,		// index of next element
+    ccp			eol_text,	// text, printed to close previous line
+    bool		check_eline	// true: print cross ref of GOBJ/ELINE_CONTROL
+)
+{
+    DASSERT(F);
+    DASSERT(kmp);
+    DASSERT(ph);
+    DASSERT(grp);
+
+    if ( grp->index < grp->max && index == grp->ph->pt_start )
+    {
+	if (eol_text)
+	{
+	    fputs(eol_text,F->f);
+	    eol_text = 0;
+	}
+
+	const uint idx = grp->index++;
+	const u8 *ptr, *end;
+
+	fprintf(F->f,"\r\n # zero based index: %u,  prev:", idx );
+	for ( ptr = grp->ph->prev, end = ptr + KMP_MAX_PH_LINK; ptr < end; ptr++ )
+	    if ( *ptr != 0xff )
+		fprintf(F->f," %u",*ptr);
+
+	fprintf(F->f,",  next:");
+	for ( ptr = grp->ph->next, end = ptr + KMP_MAX_PH_LINK; ptr < end; ptr++ )
+	    if ( *ptr != 0xff )
+		fprintf(F->f," %u",*ptr);
+
+
+	//--- $GROUP
+
+	fprintf(F->f,"\r\n $GROUP %s,  next:", grp->gname[idx] );
+
+	for ( ptr = grp->ph->next, end = ptr + KMP_MAX_PH_LINK; ptr < end; )
+	{
+	    const u8 *start = ptr;
+	    const u8 code = *ptr++;
+	    while ( ptr < end && *ptr == code )
+		ptr++;
+	    if ( code != 0xff )
+	    {
+		const uint n = ptr - start;
+		if ( n > 1 )
+		    fprintf(F->f," %s*%u",grp->gname[code],n);
+		else
+		    fprintf(F->f," %s",grp->gname[code]);
+	    }
+	}
+
+
+	//--- $PREV
+
+	bool print_prev = ph->ac_mode != KMP_AC_PREV;
+	if ( !print_prev && idx < KMP_MAX_LINFO )
+	{
+	    SetupRouteLinksKMP(kmp,ph->sect_ph,false);
+	    DASSERT(kmp->linfo);
+	    DASSERT(kmp->linfo_sect==ph->sect_ph);
+
+	    uint i;
+	    kmp_linfo_mode *ptr;
+	    for ( i = 0, ptr = kmp->linfo->list[idx]; i < kmp->linfo->used; i++ )
+	    {
+		const kmp_linfo_mode md = *ptr++;
+		if ( !!(md & LINFO_PREV) == !(md & LINFO_BY_NEXT) )
+		{
+		    print_prev = true;
+		    break;
+		}
+	    }
+	}
+
+	if (print_prev)
+	{
+	    fprintf(F->f,"\r\n $PREV:");
+
+	    for ( ptr = grp->ph->prev, end = ptr + KMP_MAX_PH_LINK; ptr < end; )
+	    {
+		const u8 *start = ptr;
+		const u8 code = *ptr++;
+		while ( ptr < end && *ptr == code )
+		    ptr++;
+		if ( code != 0xff )
+		{
+		    const uint n = ptr - start;
+		    if ( n > 1 )
+			fprintf(F->f," %s*%u",grp->gname[code],n);
+		    else
+			fprintf(F->f," %s",grp->gname[code]);
+		}
+	    }
+	}
+
+
+
+	//--- $SETTINGS
+
+	if ( idx < KMP_MAX_GROUP && grp->ph )
+	{
+	    const kmp_gopt2_t *go2 = ph->gopt + idx;
+	    if ( ph->show_options || go2->setting[0] || go2->setting[1]
+			|| go2->rtype_user || go2->rtype_active == KMP_RT_DISPATCH )
+	    {
+		const KeywordTab_t *key = GetKewordById(kmp_rtype_name,go2->rtype_user);
+		fprintf(F->f, "\r\n $SETTINGS: %u 0x%02x %s",
+				go2->setting[0], go2->setting[1],
+				key ? key->name1 : "AUTO" );
+		if ( go2->rtype_user != go2->rtype_active )
+		{
+		    const KeywordTab_t *key = GetKewordById(kmp_rtype_name,go2->rtype_active);
+		    if (key)
+			fprintf(F->f, "  # >%s",key->name1);
+		}
+	    }
+
+	    if ( ph->show_options )
+	    {
+#if 0 // [[ac]]
+		fprintf(F->f,
+		    "\r\n $CONNECT-PREV: %3d %3d %3d  # class prio min"
+		    "\r\n $CONNECT-NEXT: %3d %3d %3d",
+		    go2->prev.cls, go2->prev.prio, go2->prev.min,
+		    go2->next.cls, go2->next.prio, go2->next.min );
+#endif
+	    }
+	}
+
+
+	//--- ELINE_CONTROL
+
+	if (check_eline)
+	{
+	    uint gidx;
+	    for ( gidx = 0; gidx < kmp->dlist[KMP_GOBJ].used; gidx++ )
+	    {
+		const kmp_gobj_entry_t *op = (kmp_gobj_entry_t*)kmp->dlist[KMP_GOBJ].list + gidx;
+		if ( op->obj_id == GOBJ_ELINE_CONTROL && op->setting[7] == idx )
+		    fprintf(F->f,
+			"\r\n  # GOBJ/ELINE_CONTROL #%u links to this group:"
+			" enter=%d, sec=%d, id=%d, next=%d",
+			gidx, op->setting[0], op->setting[1], op->setting[2], op->setting[3] );
+	    }
+	}
+
+	fputs("\r\n\r\n",F->f);
+	grp->ph++;
+    }
+
+    return eol_text;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp print_kmp_flags ( kmp_pt_flag_t flags, kmp_pt_flag_t pmask )
+{
+    if (!opt_kmp_flags)
+	return EmptyString;
+
+    static char buf[4];
+
+    char *d = buf;
+    if ( pmask & KPFL_FALL )	*d++ =  flags & KPFL_FALL	? 'F' : '-';
+    if ( pmask & KPFL_SNAP )	*d++ =  flags & KPFL_SNAP	? 'S' : '-';
+    if ( pmask & KPFL_JGPT )	*d++ =  flags & KPFL_JGPT	? 'J' : '-';
+
+    DASSERT( d < buf + sizeof(buf) );
+    *d = 0;
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_kmp_pt
+(
+    File_t			* F,		// output file
+    const kmp_t			* kmp,		// KMP data structure
+    uint			sect_pt		// KMP PT section index
+)
+{
+    DASSERT(F);
+    DASSERT(kmp);
+    DASSERT( sect_pt == KMP_ENPT || sect_pt == KMP_ITPT );
+
+    //--- section setup
+
+    char buf[30];
+    uint sect_ph;
+    const kmp_ph_t *ph;
+    const kmp_flag_t *kf;
+    kmp_pt_flag_t flag_mask;
+    uint show_route;
+
+    if ( sect_pt == KMP_ENPT )
+    {
+	sect_ph		= KMP_ENPH;
+	ph		= &kmp->enph;
+	kf		= &kmp->enpt_flag;
+	flag_mask	= KPFL_M_ENPT;
+	show_route	= 1 << SHRT_ENPT;
+    }
+    else
+    {
+	sect_ph		= KMP_ITPH;
+	ph		= &kmp->itph;
+	kf		= &kmp->itpt_flag;
+	flag_mask	= KPFL_M_ITPT;
+	show_route	= 1 << SHRT_ITPT;
+    }
+
+    ccp pt_name = kmp_section_name[sect_pt].name1;
+    ccp ph_name = kmp_section_name[sect_ph].name1;
+
+
+    //--- print data
+
+    fprintf(F->f,text_kmp_pt_info_cr,
+		REVISION_NUM,
+		pt_name, kmp->value[sect_pt],	// @%s-HEAD-VALUE = %#x
+		ph_name, kmp->value[sect_ph],	// @%s-HEAD-VALUE = %#x
+		show_route,
+		opt_export_flags ? opt_export_flags>0 : kf->export );
+
+    if ( opt_route_options > OFFON_OFF )
+    {
+	ccp ac_mode, ac_fix;
+
+	switch ( ph->ac_flags & KMP_ACF_FIX )
+	{
+	    case KMP_ACF_FIX_PREV:	ac_fix = " | ACF$FIX_PREV"; break;
+	    case KMP_ACF_FIX_NEXT:	ac_fix = " | ACF$FIX_NEXT"; break;
+	    case KMP_ACF_FIX:		ac_fix = " | ACF$FIX"; break;
+	    default:			ac_fix = ""; break;
+	}
+
+	switch( ph->ac_mode )
+	{
+	    case KMP_AC_OFF:		ac_mode = "AC$OFF"; break;
+	    case KMP_AC_PREV:		ac_mode = "AC$PREV"; break;
+	    case KMP_AC_DISPATCH:	ac_mode = "AC$DISPATCH"; break;
+
+	    default: // should never happen
+		snprintf(buf,sizeof(buf),"0x%0x",ph->ac_mode|ph->ac_flags);
+		ac_mode = buf;
+		ac_fix  = "";
+	}
+
+	if ( sect_pt == KMP_ENPT )
+	    fprintf(F->f,text_kmp_enpt_ropt_cr, ph->show_options, ac_mode, ac_fix );
+	else
+	    fprintf(F->f,text_kmp_itpt_ropt_cr, ph->show_options, ac_mode, ac_fix );
+    }
+
+    if ( ph->mask[0] != 0xffff || ph->mask[1] != 0xffff )
+	fprintf(F->f,text_kmp_pt_mask_cr, ph->mask[0], ph->mask[1] );
+
+    fprintf(F->f, text_kmp_pt_head_cr, pt_name );
+
+    const uint n = kmp->dlist[sect_pt].used;
+    const kmp_enpt_entry_t * pt = (kmp_enpt_entry_t*)kmp->dlist[sect_pt].list;
+
+    print_kmp_group_t grp;
+    init_print_kmp_group(&grp,kmp,sect_ph,ph->gname);
+    ccp eol = "";
+
+    uint i, gi = 0;
+    for ( i = 0; i < n; i++, gi++, pt++ )
+    {
+	eol = print_kmp_group(F,kmp,ph,&grp,i,eol,sect_pt==KMP_ENPT);
+	if (!eol)
+	{
+	    gi = 0;
+	    eol = "";
+	}
+	else if ( gi > 1 )
+	{
+	    fprintf(F->f," %7.2f",
+		AngleVector(pt[-2].position,pt[-1].position,pt->position,true) );
+	}
+
+	fprintf(F->f,"%s%4u  %11.3f %11.3f %11.3f  %7.3f  %#6x %#6x",
+		eol, i,
+		pt->position[0], pt->position[1], pt->position[2],
+		pt->scale,
+		pt->prop[0], pt->prop[1] );
+	eol = "\r\n";
+
+	const kmp_pt_flag_t flags = i < KMP_MAX_POINT ? kf->flags[i] : kf->mask;
+	fprintf(F->f,"  %-3s",print_kmp_flags(flags,flag_mask));
+
+	if ( gi > 0 )
+	    fprintf(F->f," # %9.3f", LengthF(pt[-1].position,pt->position) );
+    }
+    fputs(eol,F->f);
+
+
+    //----- list class names -----
+
+    if ( KMP_MODE & KMPMD_DUMP_CLASS && ph->class_name.used > KCLS_USER )
+    {
+	fprintf(F->f,"\r\n#----- List of %u classes -----\r\n#\r\n",
+			ph->class_name.used);
+
+	ParamFieldItem_t *ptr = ph->class_name.field, *end;
+	for ( end = ptr + ph->class_name.used; ptr < end; ptr++ )
+	    fprintf(F->f,"#%4d  %s\r\n",ptr->num,ptr->key);
+    }
+
+
+    //----- list oneway links -----
+
+    if ( KMP_MODE & KMPMD_DUMP_ONEWAY && ph->oneway_used )
+    {
+	fprintf(F->f,"\r\n#----- List of %u oneway link%s -----\r\n#",
+			ph->oneway_used, ph->oneway_used==1 ? "" : "s" );
+
+	SortOnewayPH(ph);
+
+	uint max_fw = 1;
+	u16 *ptr, *end = ph->oneway_list + ph->oneway_used;
+	for ( ptr = ph->oneway_list; ptr < end; ptr++ )
+	{
+	    const uint fw = strlen(grp.gname[*ptr>>8]);
+	    if ( max_fw < fw )
+		max_fw = fw;
+	}
+
+	uint prev = ~0;
+	for ( ptr = ph->oneway_list; ptr < end; ptr++ )
+	{
+	    uint from =  *ptr>>8;
+	    if ( prev != from )
+	    {
+		prev = from;
+		fprintf(F->f,"\r\n#  %*s :",max_fw,grp.gname[from]);
+	    }
+	    fprintf(F->f," %s",grp.gname[*ptr&0xff]);
+	}
+	fputs("\r\n",F->f);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_kmp_ph
+(
+    File_t			* F,		// output file
+    const kmp_t			* kmp,		// KMP data structure
+    uint			sect_ph		// KMP section index
+)
+{
+    DASSERT(F);
+    DASSERT(kmp);
+    DASSERT( sect_ph == KMP_CKPH || sect_ph == KMP_ENPH || sect_ph == KMP_ITPH );
+
+    //--- section setup
+
+    uint sect_pt;
+    const kmp_ph_t *ph;
+
+    if ( sect_ph == KMP_CKPH )
+    {
+	sect_pt	= KMP_CKPT;
+	ph	= &kmp->ckph;
+    }
+    else if ( sect_ph == KMP_ENPH )
+    {
+	sect_pt	= KMP_ENPT;
+	ph	= &kmp->enph;
+    }
+    else
+    {
+	sect_pt	= KMP_ITPT;
+	ph	= &kmp->itph;
+    }
+
+    ccp pt_name = kmp_section_name[sect_pt].name1;
+    ccp ph_name = kmp_section_name[sect_ph].name1;
+
+    //--- print data
+
+    fprintf(F->f,text_kmp_ph_cr,
+		pt_name,
+		REVISION_NUM,
+		ph_name, kmp->value[sect_ph],
+		ph_name );
+
+    const uint n = kmp->dlist[sect_ph].used;
+    const kmp_enph_entry_t * p = (kmp_enph_entry_t*)kmp->dlist[sect_ph].list;
+    uint i;
+    for ( i = 0; i < n; i++, p++ )
+    {
+	fprintf(F->f,"%4u  %3u %3u %3u ",
+			i, p->pt_start, p->pt_start+p->pt_len-1, p->pt_len );
+	DASSERT( p->prev + KMP_MAX_PH_LINK == p->next ); // assume 'prev' before 'next'
+	const u8 * d = p->prev;
+	uint j;
+	for ( j = 0; j < 12; j++, d++ )
+	{
+	    if ( *d == 0xff )
+		fprintf(F->f,"%s   -", j==6 ? " " : "" );
+	    else
+		fprintf(F->f,"%s%4u", j==6 ? " " : "", *d );
+	}
+
+	if ( i < KMP_MAX_GROUP )
+	{
+	    const kmp_gopt2_t *go2 = ph->gopt + i;
+	 #ifdef TEST
+	    fprintf(F->f," %3u 0x%02x  # %-6s %s\r\n",
+		go2->setting[0], go2->setting[1], ph->gname[i],
+		i < kmp->index[sect_ph].used ? kmp->index[sect_ph].list[i] : "-" );
+	 #else
+	    fprintf(F->f," %3u 0x%02x  # %s\r\n",
+		go2->setting[0], go2->setting[1], ph->gname[i] );
+	 #endif
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static void print_kmp_pt2
+(
+    File_t		* F,		// output file
+    const kmp_t		* kmp,		// KMP data structure
+    uint		sect,		// KMP section index
+    uint		* ref_count	// NULL or reference counter array (len=0x100)
+)
+{
+    DASSERT(F);
+    DASSERT(kmp);
+    DASSERT( sect < KMP_N_SECT );
+
+    uint i;
+    const uint n = kmp->dlist[sect].used;
+    const kmp_jgpt_entry_t * pt = (kmp_jgpt_entry_t*)kmp->dlist[sect].list;
+    IndexList_t *il = (IndexList_t*)kmp->index + sect; // cast because remove const
+    FillIL(il,n);
+
+    bool auto_id = true;
+    for ( i = 0; i < n; i++, pt++ )
+	if ( pt->id != i )
+	{
+	    auto_id = false;
+	    break;
+	}
+
+    ccp pt_name = kmp_section_name[sect].name1;
+    uint show_route = sect == KMP_JGPT
+				? (1<<SHRT_JGPT)
+				: sect == KMP_CNPT
+					? (1<<SHRT_CNPT)
+					: (1<<SHRT_MSPT);
+    const u8 *pt_flags = sect == KMP_JGPT ? kmp->jgpt_flag.flags : 0;
+
+    fprintf( F->f, text_kmp_pt2_cr,
+		REVISION_NUM,
+		pt_name, kmp->value[sect],
+		auto_id,
+		show_route );
+
+    if ( sect == KMP_JGPT )
+	fprintf( F->f, text_kmp_jgpt_auto_cr, kmp->jgpt_flag.export );
+    else
+	fprintf( F->f, text_kmp_pt2_head_cr, pt_name );
+
+    pt = (kmp_jgpt_entry_t*)kmp->dlist[sect].list;
+    for ( i = 0; i < n; i++, pt++ )
+    {
+	PrintNameIL(F->f,il,i,5,5,0);
+	fprintf(F->f," %11.3f %11.3f %11.3f %7.2f %7.2f %7.2f %6d %6s",
+		pt->position[0], pt->position[1], pt->position[2],
+		pt->rotation[0], pt->rotation[1], pt->rotation[2],
+		pt->id, PrintU16M1(pt->effect) );
+
+	if (pt_flags)
+	{
+	    const kmp_pt_flag_t flags
+		= i < KMP_MAX_POINT ? pt_flags[i] : kmp->jgpt_flag.mask;
+	    fprintf(F->f,"  %s",print_kmp_flags(flags,KPFL_M_JGPT));
+	}
+
+	fprintf(F->f,"%s\r\n", ref_count && !ref_count[i] ? "  # unused" : "" );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static ccp GetObjectName ( uint obj_id )
+{
+    const uint bufsize = OBJ_FW_NAME + 3;
+    char *buf = GetCircBuf(bufsize);
+
+    if ( obj_id < N_KMP_GOBJ && ObjectInfo[obj_id].name )
+	snprintf(buf,bufsize,"o$%s",ObjectInfo[obj_id].name);
+    else
+	snprintf(buf,bufsize,"0x%x",obj_id);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+static uint PrintDefObjInfoHelper ( FILE *f, ccp prefix, int mode, u16 mask )
+{
+    DASSERT(f);
+
+    gobj_condition_set_t gcs;
+    const uint n = GetGobjConditions(&gcs,mode,mask);
+
+    uint i;
+    for ( i = 0; i < n; i++ )
+    {
+	const gobj_condition_t *c = gcs.cond+i;
+	fprintf(f,"#    %s/0x%04x: %s\n",prefix,c->mask,c->info );
+    }
+
+    return n;
+}
+
+static void PrintDefObjInfo ( FILE *f, const kmp_gobj_entry_t * gobj )
+{
+    DASSERT(f);
+    DASSERT(gobj);
+
+    const u16 balloon	= gobj->setting[KMP_GMODE_BALLOON];
+    const u16 coin	= gobj->setting[KMP_GMODE_COIN];
+    const u16 versus	= gobj->setting[KMP_GMODE_VERSUS];
+    const u16 itemrain	= gobj->setting[KMP_GMODE_ITEMRAIN];
+
+    uint count = 0;
+    if ( balloon != versus || coin != versus )
+    {
+	if ( balloon == coin )
+	    count += PrintDefObjInfoHelper(f,"Battle",KMP_GMODE_BALLOON,balloon);
+	else
+	{
+	    count += PrintDefObjInfoHelper(f,"Balloon",KMP_GMODE_BALLOON,balloon);
+	    count += PrintDefObjInfoHelper(f,"Coin",KMP_GMODE_COIN,coin);
+	}
+	count += PrintDefObjInfoHelper(f,"Versus",KMP_GMODE_VERSUS,versus);
+    }
+    else
+	count += PrintDefObjInfoHelper(f,"*",-1,versus);
+
+    if ( versus != itemrain )
+	count += PrintDefObjInfoHelper(f,"Itemrain",KMP_GMODE_ITEMRAIN,itemrain);
+
+    if (!count)
+	fputs("#    Always disabled!\n",f);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			  SaveTextKMP()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError SaveTextKMP
+(
+    const kmp_t		* kmp,		// pointer to valid KMP
+    ccp			fname,		// filename of destination
+    bool		set_time	// true: set time stamps
+)
+{
+    // use DOS/Windows line format -> unix can handle it ;)
+
+    DASSERT(kmp);
+    DASSERT(fname);
+    PRINT("SaveTextKMP(%s,%d)\n",fname,set_time);
+    KMP_ACTION_LOG(false,"SaveTextKMP() %s\n",fname);
+
+    char temp_buf[100];
+
+
+    //--- open file
+
+    File_t F;
+    enumError err = CreateFileOpt(&F,true,fname,testmode,kmp->fname);
+    if ( err > ERR_WARNING || !F.f )
+	return err;
+    SetFileAttrib(&F.fatt,&kmp->fatt,0);
+
+
+    //--- print header + syntax info
+
+    if ( print_header && !brief_count && !export_count )
+	fprintf(F.f,text_kmp_head_cr);
+    else
+	fprintf(F.f,
+		"%s\r\n"
+		"# KMP syntax & semantics: https://szs.wiimm.de/info/kmp-syntax.html\r\n"
+		,KMP_TEXT_MAGIC);
+
+
+    //--- var defs
+
+    uint i, n, gi, ng, np;
+    char buf1[0x100], buf2[0x20];
+
+
+    //--- print info section & section counter alphabetically
+
+    if ( brief_count || export_count )
+    {
+	fprintf(F.f,
+		"%s[SETUP]\r\n\r\n"
+		"TOOL     = %s\r\n"
+		"SYSTEM   = %s\r\n"
+		"VERSION  = %s\r\n"
+		"REVISION = %u\r\n"
+		"DATE     = %s\r\n"
+		"INFO     = \"%s\"\r\n"
+		"\r\n"
+		"UNKNOWN-0x0c      = %#x\r\n"
+		"KCL-FALL-ADD-ROAD = 0\r\n"
+		"BATTLE-MODE       = %d\r\n"
+		"KMP-WIM0          = %d\r\n"
+		"\r\n",
+		section_sep,
+		tool_name, SYSTEM, VERSION, REVISION_NUM, DATE,
+		kmp->info ? kmp->info : "",
+		kmp->kmp_version, kmp->battle_mode, kmp->wim0_export );
+    }
+    else
+    {
+	fprintf(F.f, text_kmp_setup_cr,
+		tool_name, SYSTEM, VERSION, REVISION_NUM, DATE,
+		kmp->info ? kmp->info : "",
+		kmp->kmp_version, kmp->battle_mode, kmp->wim0_export );
+
+	ccp last_name = "";
+	for(;;)
+	{
+	    ccp found_name = 0;
+	    uint sect, found_sect = 0;
+	    for ( sect = 0; sect < KMP_N_SECT; sect++ )
+	    {
+		ccp name = kmp_section_name[sect].name1;
+		if ( strcmp(name,last_name) > 0
+		    && ( !found_name || strcmp(name,found_name) < 0 ) )
+		{
+		    found_name = name;
+		    found_sect = sect;
+		}
+	    }
+
+	    if (!found_name)
+		break;
+
+	    if ( found_sect == KMP_POTI )
+		fprintf(F.f, " # N-%s = %5u,%5u\r\n",
+			    found_name,
+			    kmp->dlist[found_sect].used, kmp->poti_point.used );
+	    else
+		fprintf(F.f, " # N-%s = %5u\r\n",
+			    found_name,
+			    kmp->dlist[found_sect].used );
+	    last_name = found_name;
+	}
+    }
+
+
+    //--- print default settings
+
+    fprintf(F.f, text_kmp_defaults_cr,
+	GetObjectName(kmp->rtobj.obj),
+	kmp->rtobj.shift.x, kmp->rtobj.shift.y, kmp->rtobj.shift.z,
+	kmp->rtobj.scale.x, kmp->rtobj.scale.y, kmp->rtobj.scale.z );
+
+
+    //--- print parameter support
+
+    if (print_param)
+    {
+	if ( !brief_count && !export_count )
+	    fwrite(text_kmp_param1_cr,1,sizeof(text_kmp_param1_cr)-1,F.f);
+	else
+	    fprintf(F.f,"#%.78s\r\n# Parameter support\r\n",Minus300);
+
+	fwrite(text_kmp_param2_cr,1,sizeof(text_kmp_param2_cr)-1,F.f);
+
+	if ( !brief_count && !export_count )
+	    fwrite(text_kmp_param3_cr,1,sizeof(text_kmp_param3_cr)-1,F.f);
+    }
+
+
+    //--- fill index lists
+
+    IndexList_t *ill = (IndexList_t*)kmp->index; // cast because remove const
+    for ( i = 0; i < KMP_N_SECT; i++ )
+	FillIL(ill+i,kmp->dlist[i].used);
+
+
+    //--- print macros
+
+    fwrite(text_kmp_macros_cr,1,sizeof(text_kmp_macros_cr)-1,F.f);
+
+
+    //--- print AREA entries
+
+    fprintf(F.f,text_kmp_area_cr,REVISION_NUM,kmp->value[KMP_AREA]);
+
+    n = kmp->dlist[KMP_AREA].used;
+    const kmp_area_entry_t * area = (kmp_area_entry_t*)kmp->dlist[KMP_AREA].list;
+    for ( i = 0; i < n; i++, area++ )
+    {
+	*buf1 = 0;
+	PrintNameIL(F.f,ill+KMP_AREA,i,6,8,0);
+	fprintf(F.f,
+		"%#4x %#4x  %12.3f %11.3f %11.3f  %#6x %#6x %#6x %#6x\r\n >",
+		area->mode, area->type,
+		 area->position[0], area->position[1], area->position[2],
+		 area->setting[0], area->setting[1], area->setting[2], area->setting[3] );
+
+	if ( area->type == 0x00 )
+	    PrintNameIL(F.f,ill+KMP_CAME,area->dest_id,10,10,2);
+	else
+	    fprintf(F.f,"%#10x",area->dest_id);
+
+	fprintf(F.f,
+		" %#4x  %12.3f %11.3f %11.3f\r\n"
+		    " > %28.3f %11.3f %11.3f\r\n"
+		"#%.84s\r\n",
+		area->unknown,
+		 area->rotation[0], area->rotation[1], area->rotation[2],
+		area->scale[0], area->scale[1], area->scale[2],
+		Minus300 );
+    }
+
+
+    //--- print CAME entries
+
+    uint ocam = kmp->value[KMP_CAME] >> 8;
+    uint scam = kmp->value[KMP_CAME] & 0xff;
+
+    fprintf(F.f,text_kmp_came_cr,REVISION_NUM,
+		GetNameIL(ill+KMP_CAME,ocam),
+		GetNameIL(ill+KMP_CAME,scam) );
+
+    // find opening cameras
+
+    n = kmp->dlist[KMP_CAME].used;
+    const kmp_came_entry_t * came = (kmp_came_entry_t*)kmp->dlist[KMP_CAME].list;
+
+    uint ocount = 0, oidx = ocam;
+    memset(buf1,0,sizeof(buf1));
+    if (print_param)
+	while ( oidx < n && ocount < 0xff && oidx < sizeof(buf1) && !buf1[oidx] )
+	{
+	    buf1[oidx] = ++ocount;
+	    oidx = came[oidx].next;
+	}
+
+    for ( i = 0; i < n; i++, came++ )
+    {
+	//--- AREA reference
+
+	const kmp_area_entry_t * area = (kmp_area_entry_t*)kmp->dlist[KMP_AREA].list;
+	uint count, idx, nn = kmp->dlist[KMP_AREA].used;
+	for ( count = idx = 0; idx < nn; idx++, area++ )
+	    if ( area->type == 0x00 && area->dest_id == i )
+		fprintf(F.f,"%s %s",
+		    count++ ? "" : "\t# AREA reference:",
+		    GetNameIL(ill+KMP_AREA,idx) );
+	if (count)
+	    fputs("\r\n",F.f);
+
+
+	//--- CAME reference
+
+	count = 0;
+	if ( i == ocam )
+	    fprintf(F.f,"%s @OPENING-INDEX",
+		count++ ? "" : "\t# CAME reference:" );
+	if ( i == scam )
+	    fprintf(F.f,"%s @SELECTION-INDEX",
+		count++ ? "" : "\t# CAME reference:" );
+
+	const kmp_came_entry_t * cref = (kmp_came_entry_t*)kmp->dlist[KMP_CAME].list;
+	nn = kmp->dlist[KMP_CAME].used;
+	for ( idx = 0; idx < nn; idx++, cref++ )
+	    if ( cref->next == i )
+		fprintf(F.f,"%s %s",
+			count++ ? "" : "\t# CAME reference:",
+			GetNameIL(ill+KMP_CAME,idx) );
+	if (count)
+	    fputs("\r\n",F.f);
+
+
+	//--- CAME object
+
+	PrintNameIL(F.f,ill+KMP_CAME,i,6,8,0);
+	fprintf(F.f," %3u %7u  %11.3f %11.3f %11.3f %10.3f",
+		came->type, came->came_speed,
+		 came->position[0], came->position[1], came->position[2],
+		 came->zoom_begin );
+	const double came_time = came->time/60.0;
+	if ( came_time >= 0.01 )
+	    fprintf(F.f,"  # came time:%8.2fs",came_time);
+	fputs("\r\n >",F.f);
+
+	if (buf1[i])
+	{
+	    uint idx = (uchar)buf1[i];
+	    ccp term = "\r\n >            ";
+	    if ( idx == ocount )
+		fprintf(F.f,
+		    " ( mode$ocam == %u ? %s : mode$test ? %s : %s )%s",
+		    idx, GetNameIL(ill+KMP_CAME,i),
+		    GetNameIL(ill+KMP_CAME,kmp->value[KMP_CAME]>>8),
+		    GetNameIL(ill+KMP_CAME,came->next), term );
+	    else
+		fprintf(F.f,
+		    " ( mode$ocam == %u ? %s : %s )%s",
+		    idx, GetNameIL(ill+KMP_CAME,i),
+		    GetNameIL(ill+KMP_CAME,came->next), term );
+	}
+	else
+	    PrintNameIL(F.f,ill+KMP_CAME,came->next,10,12,2);
+
+	fprintf(F.f," %5u  %11.3f %11.3f %11.3f %10.3f",
+		came->zoom_speed,
+		 came->rotation[0], came->rotation[1], came->rotation[2],
+		 came->zoom_end );
+	const double zoom_length = fabs(came->zoom_begin-came->zoom_end);
+	if ( zoom_length >= 0.01 && came->zoom_speed )
+	    fprintf(F.f,"  # zoom time:%8.2fs",
+			zoom_length / came->zoom_speed * (10.0/6.0) );
+
+	fprintf(F.f,"\r\n > %#9x %7u  %11.3f %11.3f %11.3f",
+		came->unknown_0x02, came->viewpt_speed,
+		 came->viewpt_begin[0], came->viewpt_begin[1], came->viewpt_begin[2] );
+	const double viewpt_len = LengthF(came->viewpt_begin,came->viewpt_end);
+	if ( viewpt_len >= 0.01 && came->viewpt_speed )
+	    fprintf(F.f,"             # v.pt time:%8.2fs",
+			viewpt_len / came->viewpt_speed * (10.0/6.0) );
+	fputs("\r\n >",F.f);
+
+	PrintNameIL(F.f,ill+KMP_POTI,came->route,10,11,2);
+	fprintf(F.f,
+		" %#6x  %11.3f %11.3f %11.3f %10.3f",
+		came->unknown_0x0a,
+		 came->viewpt_end[0], came->viewpt_end[1], came->viewpt_end[2],
+		 came->time );
+	if ( viewpt_len >= 0.01 )
+	    fprintf(F.f,"  # v.pt len:%9.2f",viewpt_len);
+	fprintf(F.f,"\r\n#%.91s\r\n",Minus300);
+    }
+
+
+    //--- print CKPH entries
+
+    if ( brief_count < 2 && !export_count )
+    {
+	fwrite(text_kmp_ckph_cr,1,sizeof(text_kmp_ckph_cr)-1,F.f);
+	print_kmp_ph(&F,kmp,KMP_CKPH);
+    }
+
+
+    //--- print CKPT entries
+
+    bool auto_next = true;
+    n  = kmp->dlist[KMP_CKPT].used;
+    ng = kmp->dlist[KMP_CKPH].used;
+    const kmp_ckph_entry_t * ckph = (kmp_ckph_entry_t*)kmp->dlist[KMP_CKPH].list;
+    for ( gi = 0; gi < ng && auto_next; gi++, ckph++ )
+    {
+	uint start = ckph->pt_start;
+	uint end = start + ckph->pt_len - 1;
+	if ( !ckph->pt_len || end >= n )
+	{
+	    auto_next = false;
+	    break;
+	}
+
+	const kmp_ckpt_entry_t * ckpt
+		= (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list + start;
+	uint j;
+	for ( j = start; j <= end; j++, ckpt++ )
+	{
+	    if (   ckpt->prev != ( j == start ? -1 : j-1 )
+		|| ckpt->next != ( j == end   ? -1 : j+1 ) )
+	    {
+		auto_next = false;
+		break;
+	    }
+	}
+    }
+
+    fprintf(F.f,text_kmp_ckpt_cr,
+		REVISION_NUM,
+		kmp->value[KMP_CKPT], kmp->value[KMP_CKPH],
+		auto_next,
+		ObjectInfo[RTOBJ_1].name, ObjectInfo[RTOBJ_2].name,
+		RTOBJ_SCALE_X, RTOBJ_SCALE_Y, RTOBJ_SCALE_Z,
+		RTOBJ_SCALE_X, RTOBJ_SCALE_Y, RTOBJ_SCALE_Z,
+		RTOBJ_BASE, RTOBJ_BASE );
+
+    const kmp_ckpt_entry_t * ckpt = (kmp_ckpt_entry_t*)kmp->dlist[KMP_CKPT].list;
+
+    print_kmp_group_t grp;
+    init_print_kmp_group(&grp,kmp,KMP_CKPH,kmp->ckph.gname);
+    uint jgpt_count[0x100];
+    memset(jgpt_count,0,sizeof(jgpt_count));
+
+    u8 prev_mode = M1(prev_mode);
+    for ( i = 0; i < n; i++, ckpt++ )
+    {
+	if ( print_kmp_group(&F,kmp,&kmp->ckph,&grp,i,"",false)
+		&& IS_M1(ckpt->mode) && !IS_M1(prev_mode) )
+	{
+	    fputs("\r\n",F.f);
+	}
+	prev_mode = ckpt->mode;
+	jgpt_count[(uint)ckpt->respawn]++;
+
+	double width, direction;
+	WidthAndDirection(&width,&direction,true,ckpt->left,ckpt->right);
+
+	const uint indent
+	    = fprintf(F.f,"%4u %11.3f %11.3f %11.3f %11.3f ",
+		i,
+		ckpt->left[0], ckpt->left[1],
+		ckpt->right[0], ckpt->right[1] );
+	PrintNameIL(F.f,ill+KMP_JGPT,ckpt->respawn,5,5,indent);
+	fprintf(F.f," %3d %3d %3d # %9.3f %7.2f\r\n",
+		IS_M1(ckpt->mode) ? -1 : (uint)ckpt->mode,
+		IS_M1(ckpt->prev) ? -1 : (uint)ckpt->prev,
+		IS_M1(ckpt->next) ? -1 : (uint)ckpt->next,
+		width, direction );
+    }
+
+
+    //--- print CNPT entries
+
+    fwrite(text_kmp_cnpt_cr,1,sizeof(text_kmp_cnpt_cr)-1,F.f);
+    print_kmp_pt2(&F,kmp,KMP_CNPT,0);
+
+
+    //--- print ENPH entries
+
+    if ( brief_count < 2 && !export_count )
+    {
+	fwrite(text_kmp_enph_cr,1,sizeof(text_kmp_enph_cr)-1,F.f);
+	print_kmp_ph(&F,kmp,KMP_ENPH);
+    }
+
+
+    //--- print ENPT entries
+
+    fwrite(text_kmp_enpt_cr,1,sizeof(text_kmp_enpt_cr)-1,F.f);
+    print_kmp_pt(&F,kmp,KMP_ENPT);
+
+
+    //--- print GOBJ statistics
+
+    n = kmp->dlist[KMP_GOBJ].used;
+    fprintf(F.f,text_kmp_gobj_cr,REVISION_NUM,kmp->value[KMP_GOBJ]);
+
+    uint min_id = 0, n_types = 0, n_defobj = 0;
+    for(;;)
+    {
+	uint current_id = UINT_MAX, count = 0;
+
+	const kmp_gobj_entry_t * gobj = (kmp_gobj_entry_t*)kmp->dlist[KMP_GOBJ].list;
+	for ( i = 0; i < n; i++, gobj++ )
+	{
+	    if ( gobj->obj_id >= min_id )
+	    {
+		if ( gobj->obj_id == current_id )
+		    count++;
+		else if ( gobj->obj_id < current_id )
+		{
+		    count = 1;
+		    current_id = gobj->obj_id;
+		}
+	    }
+	}
+
+	if (!count)
+	    break;
+
+	if (IsDefinitionObjectId(current_id))
+	    n_defobj += count;
+	else
+	{
+	    const u16 relevant_id = current_id & GOBJ_M_OBJECT;
+	    if ( relevant_id < N_KMP_GOBJ && ObjectInfo[relevant_id].name )
+	    {
+		const ObjectInfo_t *oi = ObjectInfo + relevant_id;
+		fprintf(F.f,
+			"##%4u %#6x  %c%-*s %s\r\n",
+			count, current_id, current_id==relevant_id ? ' ' : '|',
+			OBJ_FW_NAME, oi->name, oi->charact );
+	    }
+	    else
+		fprintf(F.f,"##%4u %#6x\r\n", count, current_id );
+	    n_types++;
+	}
+	min_id = current_id + 1;
+    }
+
+    const int nstd = n - n_defobj;
+    fprintf(F.f,"##%.83s\r\n## GOBJ total: %u object%s, %u type%s",
+		Minus300,
+		nstd, nstd == 1 ? "" : "s",
+		n_types, n_types == 1 ? "" : "s" );
+    if (n_defobj)
+	fprintf(F.f," + %u definition object%s",
+		n_defobj, n_defobj == 1 ? "" : "s" );
+    fprintf(F.f,"\r\n##%.83s\r\n\r\n",Minus300);
+
+
+    //--- print GOBJ entries
+
+    fwrite(text_kmp_gobj_tabhead_cr,1,sizeof(text_kmp_gobj_tabhead_cr)-1,F.f);
+
+    u8 done[N_KMP_GOBJ];
+    memset(done,0,sizeof(done));
+
+    const kmp_gobj_entry_t * gobj = (kmp_gobj_entry_t*)kmp->dlist[KMP_GOBJ].list;
+    for ( i = 0; i < n; i++, gobj++ )
+    {
+	ccp form1, form2;
+	form1 = form2 = settings_format_xxxx.std;
+
+	const u16 relevant_id = gobj->obj_id & (GOBJ_M_OBJECT|GOBJ_M_DEFINITION);
+	const ObjectInfo_t *oi = GetObjectInfo(relevant_id);
+	DASSERT(oi);
+
+	if (oi->name)
+	{
+	    form1 = form2 = settings_format_uuuu.std;
+	    ccp char_sep = *oi->charact ? ", " : "";
+
+	    if (!done[relevant_id] )
+	    {
+		done[relevant_id] = 1;
+
+		fprintf(F.f,
+		    "## o$%s = %#x = %u%s%s\r\n",
+		    oi->name, relevant_id, relevant_id,
+		    char_sep, oi->charact );
+
+		if (oi->info)
+		{
+		    fputs("## Description: ",F.f);
+		    PutLines(F.f,0,80,13,"## ",oi->info,"\r\n");
+		}
+
+		if (oi->fname)
+		    fprintf(F.f,"## File names:  %s\r\n",oi->fname);
+
+		uint p;
+		for ( p = 0; p < 8; p++ )
+		    if ( oi->param[p] )
+		    {
+			fprintf(F.f,"## Setting #%u:  ",p+1);
+			PutLines(F.f,13,80,13,"## ",oi->param[p],"\r\n");
+		    }
+		fprintf(F.f,"#%.84s\r\n",Minus300);
+	    }
+
+	    if ( relevant_id == gobj->obj_id )
+		fprintf(F.f,"# o$%s, S",oi->name);
+	    else
+		fprintf(F.f,"# o$%s|%#06x, S",oi->name,gobj->obj_id&GOBJ_M_FLAGS);
+
+	    uint p;
+	    for ( p = 0; p < 8; p++ )
+		fputc( oi->param[p] ? '1'+p : '-', F.f );
+	    fprintf(F.f,"%s%s\r\n",char_sep, oi->charact);
+
+	    if (oi->format1)
+		form1 = oi->format1->std;
+	    if (oi->format2)
+		form2 = oi->format2->std;
+	}
+
+	//--- print special features
+
+	bool print_condition = false;
+	bool print_reference = false;
+
+	kmp_ana_defobj_t ad;
+	AnalyseDefObject(&ad,gobj);
+	if ( ad.is_defobj )
+	{
+	    char usage_info_buf[40], *usage_info;
+	    const uint usage = CountDefObjUsage(kmp,gobj->obj_id);
+	    if (usage)
+	    {
+		usage_info = usage_info_buf;
+		snprintf(usage_info_buf,sizeof(usage_info_buf),
+			"It is used by %u regular object%s.",
+			usage, usage == 1 ? "" : "s" );
+	    }
+	    else
+		usage_info = "It is not used by any regular object.";
+
+	    if ( ad.is_pure_defobj && !(KMP_MODE & KMPMD_FULL_DEFOBJ) )
+	    {
+		fprintf(F.f,
+			"# Definition object type %s. Param: %s\r\n",
+			ad.cmd_name, ad.par_info );
+		if (!ad.is_logical)
+		{
+		    fputs("# Meaning of the conditions:\r\n",F.f);
+		    PrintDefObjInfo(F.f,gobj);
+		}
+		fprintf(F.f,"# %s\r\n  $DEFOBJ-%-7s %#06x",
+			usage_info,ad.cmd_name,gobj->obj_id);
+		uint i;
+		for ( i = ad.index_beg; i < ad.index_end; i++ )
+		{
+		    if (ad.is_logical)
+		    {
+			if (!gobj->setting[i])
+			    continue;
+			cond_ref_info_t cri;
+			GetConditionRefInfo(&cri,gobj->setting[i],~0,true);
+			fprintf(F.f,", %s",cri.cond);
+			continue;
+		    }
+		    fprintf(F.f,", %s",GetDefObjConditionName(gobj->setting[i]));
+		}
+		fputs("\r\n",F.f);
+
+		if ( IsConditionRefId(gobj->ref_id) )
+		{
+		    cond_ref_info_t cri;
+		    GetConditionRefInfo(&cri,gobj->ref_id,gobj->obj_id,true);
+		    fprintf(F.f,"  $%s %s%s%s\r\n",
+			cri.cmd_suffix, cri.cond,
+			cri.info ? " # " : "", cri.info ? cri.info : "" );
+		}
+
+		fprintf(F.f,"#%.84s\r\n",Minus300);
+		continue;
+	    }
+	    fprintf(F.f,"# Type %#06x: Definition object!\r\n# %s\r\n",
+			GOBJ_M_DEFINITION, usage_info );
+	}
+	else
+	{
+	    if ( gobj->obj_id & GOBJ_M_LECODE )
+		fprintf(F.f,"# |%#x => Disabled object."
+			" Conditional enabled by LE-CODE.\r\n",
+			GOBJ_M_LECODE);
+
+	    const u16 mode = GetPFlagsMode(gobj->pflags);
+	    if (mode)
+		fprintf(F.f,"# Extended presence flags, mode %u\r\n",mode);
+
+	    kmp_ana_ref_t ar;
+	    AnalyseRefObject(&ar,gobj);
+	    if ( ar.is_condref || ar.is_condrnd || ar.is_condtest )
+		print_condition = true;
+	    else if (ar.is_objref)
+		print_reference = true;
+	    else if (ar.condref_valid)
+		fprintf(F.f,
+			"# Warning: Valid condition, but P-Flags mode is %u\r\n",
+			ar.mode );
+	    else if (ar.objref_valid)
+		fprintf(F.f,
+			"# Warning: Valid reference id, but P-Flags mode is %u\r\n",
+			ar.mode );
+	    else if ( ar.mode_valid && gobj->ref_id )
+		fprintf(F.f,
+			"# Warning: Invalid reference id: %#06x\r\n",
+			gobj->ref_id);
+	}
+
+	//--- print object information
+
+	snprintf(buf1,sizeof(buf1),form1,
+			gobj->setting[0], gobj->setting[1],
+			gobj->setting[2], gobj->setting[3] );
+	switch (relevant_id)
+	{
+	 case GOBJ_ELINE_CONTROL:
+	    {
+		const int idx = IS_M1(gobj->setting[7]) ? -1 : gobj->setting[7];
+		if ( (uint)idx < KMP_MAX_GROUP && kmp->enph.gname[idx] )
+		    snprintf(temp_buf,sizeof(temp_buf),"E.%s",kmp->enph.gname[idx]);
+		else
+		    snprintf(temp_buf,sizeof(temp_buf),"%6d",idx);
+		snprintf(buf2,sizeof(buf2),"%6u %6u %6u %6s",
+			gobj->setting[4], gobj->setting[5],
+			gobj->setting[6], temp_buf );
+	    }
+	    break;
+
+	 default:
+	    snprintf(buf2,sizeof(buf2),form2,
+			gobj->setting[4], gobj->setting[5],
+			gobj->setting[6], gobj->setting[7] );
+	}
+
+	PrintNameIL(F.f,ill+KMP_GOBJ,i,5,5,0);
+	fprintf(F.f,
+		       " %#6x %11.3f %11.3f %11.3f %s  %6s\r\n"
+		  "    > %#6x %11.3f %11.3f %11.3f %s  %#6x\r\n"
+		"    >        %11.3f %11.3f %11.3f\r\n",
+		gobj->obj_id,
+		 gobj->position[0], gobj->position[1], gobj->position[2],
+		 buf1, GetNameIL(ill+KMP_POTI,gobj->route_id),
+		gobj->ref_id,
+		 gobj->rotation[0], gobj->rotation[1], gobj->rotation[2],
+		 buf2, gobj->pflags,
+		gobj->scale[0], gobj->scale[1], gobj->scale[2] );
+
+
+	//--- print special definitions
+
+	if (print_condition)
+	{
+	    cond_ref_info_t cri;
+	    GetConditionRefInfo(&cri,gobj->ref_id,gobj->obj_id,true);
+	    if (cri.is_condref)
+		fprintf(F.f,"  $%s %s%s%s\r\n",
+			cri.cmd_suffix, cri.cond,
+			cri.info ? " # " : "", cri.info ? cri.info : "" );
+	    PRINT0("# CR[%#x,%#x]: is=%d, found=%d, cmd=%s, xor:%x->%#x, c=%s, i=%s\n",
+			gobj->ref_id, gobj->obj_id,
+			cri.is_condref, cri.condref!=0, cri.cmd_suffix,
+			cri.xor, gobj->ref_id^cri.xor, cri.cond, cri.info );
+	}
+	else if (print_reference)
+	{
+	    fprintf(F.f,"  $%sABLE-BY%s %#06x\r\n",
+		gobj->obj_id & GOBJ_M_LECODE ? "EN" : "DIS",
+		(gobj->obj_id ^ gobj->ref_id) & GOBJ_DEF_F_NOT ? "" : "-NOT",
+		gobj->ref_id & ~GOBJ_DEF_F_NOT );
+	}
+	fprintf(F.f,"#%.84s\r\n",Minus300);
+    }
+
+
+    //--- print ITPH entries
+
+    if ( brief_count < 2 && !export_count )
+    {
+	fwrite(text_kmp_itph_cr,1,sizeof(text_kmp_itph_cr)-1,F.f);
+	print_kmp_ph(&F,kmp,KMP_ITPH);
+    }
+
+
+    //--- print ITPT entries
+
+    fwrite(text_kmp_itpt_cr,1,sizeof(text_kmp_itpt_cr)-1,F.f);
+    print_kmp_pt(&F,kmp,KMP_ITPT);
+
+
+    //--- print JGPT entries
+
+    fwrite(text_kmp_jgpt_cr,1,sizeof(text_kmp_jgpt_cr)-1,F.f);
+    print_kmp_pt2(&F,kmp,KMP_JGPT,jgpt_count);
+
+
+    //--- print KTPT entries
+
+    fprintf(F.f,text_kmp_ktpt_cr,REVISION_NUM,kmp->value[KMP_KTPT]);
+
+    n = kmp->dlist[KMP_KTPT].used;
+    const kmp_ktpt_entry_t * ktpt = (kmp_ktpt_entry_t*)kmp->dlist[KMP_KTPT].list;
+    for ( i = 0; i < n; i++, ktpt++ )
+    {
+	fprintf(F.f,"%4u  %11.3f %11.3f %11.3f  %7.2f %7.2f %7.2f %5d %#6x\r\n",
+		i,
+		ktpt->position[0], ktpt->position[1], ktpt->position[2],
+		ktpt->rotation[0], ktpt->rotation[1], ktpt->rotation[2],
+		ktpt->player_index, ktpt->unknown );
+    }
+
+
+    //--- print MSPT entries
+
+    fwrite(text_kmp_mspt_cr,1,sizeof(text_kmp_mspt_cr)-1,F.f);
+    print_kmp_pt2(&F,kmp,KMP_MSPT,0);
+
+
+    //--- print POTI entries
+
+    fprintf(F.f,text_kmp_poti_cr,REVISION_NUM,1<<SHRT_POTI);
+
+    ng = kmp->dlist[KMP_POTI].used;
+    const kmp_poti_group_t * pg = (kmp_poti_group_t*)kmp->dlist[KMP_POTI].list;
+    np = kmp->poti_point.used;
+    const kmp_poti_point_t * pp = (kmp_poti_point_t*)kmp->poti_point.list;
+
+    for ( gi = i = 0; gi < ng && i < np; gi++, pg++ )
+    {
+	uint en = pg->n_point;
+	DASSERT( en <= np-i );
+	fprintf(F.f,"\r\n $ROUTE %s, settings: %u %u # section %u\r\n",
+			GetNameIL(ill+KMP_POTI,gi),
+			pg->smooth, pg->back, gi+1 );
+	const bool is_cyclic = !pg->back;
+
+	//--- GOBJ reference
+
+	const kmp_gobj_entry_t * gobj = (kmp_gobj_entry_t*)kmp->dlist[KMP_GOBJ].list;
+	uint count, idx, nn = kmp->dlist[KMP_GOBJ].used;
+	for ( count = idx = 0; idx < nn; idx++, gobj++ )
+	    if ( gobj->route_id == (uint)gi )
+	    {
+		const u16 relevant_id = gobj->obj_id & GOBJ_M_OBJECT;
+		fprintf(F.f,"\t# GOBJ reference: %-8s type %#6x",
+			GetNameIL(ill+KMP_GOBJ,idx), gobj->obj_id );
+		if ( relevant_id < N_KMP_GOBJ )
+		{
+		    const ObjectInfo_t *oi = ObjectInfo + relevant_id;
+		    if (oi->name)
+		    {
+			if ( relevant_id == gobj->obj_id )
+			    fprintf(F.f," = %s",oi->name);
+			else
+			    fprintf(F.f," = %#06x | %s",gobj->obj_id&GOBJ_M_FLAGS,oi->name);
+		//DEL	    fprintf(F.f," = %s | %#06x",oi->name,gobj->obj_id&GOBJ_M_FLAGS);
+		    }
+		}
+		fputs("\r\n",F.f);
+	    }
+
+	//--- CAME reference
+
+	ccp came_ref = 0;
+	const kmp_came_entry_t * came = (kmp_came_entry_t*)kmp->dlist[KMP_CAME].list;
+	nn = kmp->dlist[KMP_CAME].used;
+	for ( count = idx = 0; idx < nn; idx++, came++ )
+	    if ( came->route == gi )
+	    {
+		ccp came_name = GetNameIL(ill+KMP_CAME,idx);
+		if (!came_ref)
+		    came_ref = came_name;
+		fprintf(F.f,"%s %s",
+			count++ ? "" : "\t# CAME reference:",
+			came_name );
+	    }
+
+	if (came_ref)
+	    fprintf(F.f,"\r\n\r\n"
+		"   # @set-route-time = %s.came.time  # in 1/60 sec\r\n",came_ref);
+
+
+	//--- print points
+
+	fputs("\r\n",F.f);
+	double total_len = 0.0, total_tim = 0.0;
+	uint ei;
+	for ( ei = 0; ei < en; ei++, i++, pp++ )
+	{
+	    fprintf(F.f, "%4u  %11.3f %11.3f %11.3f %5u %5u  #",
+		ei,
+		pp->position[0], pp->position[1], pp->position[2],
+		pp->speed, pp->unknown );
+
+	    if ( ei < en-1 || is_cyclic )
+	    {
+		const kmp_poti_point_t * pnext = pp + 1;
+		if ( ei >= en-1 )
+		    pnext -= en;
+		double len = LengthF(pp->position,pnext->position);
+		total_len += len;
+		double tim = len > 0.0 && pp->speed > 0
+				? len / (pp->speed*60) : 0.0;
+		if ( tim >= 0.01 && tim <= 999.99 )
+		{
+		    total_tim += tim;
+		    fprintf(F.f," %6.2f %9.3f", tim, len );
+		}
+		else
+		    fprintf(F.f,"      - %9.3f", len );
+
+		if ( ei || is_cyclic )
+		{
+		    const kmp_poti_point_t * pprev = pp - 1;
+		    if (!ei)
+			pprev += en;
+		    fprintf(F.f," %7.2f",
+			AngleVector(pprev->position,pp->position,pnext->position,true) );
+		}
+	    }
+	    fputs("\r\n",F.f);
+	}
+
+	if ( en > 1 )
+	    fprintf(F.f,"%56s %6.2f %9.3f\r\n","#TOTAL#",total_tim,total_len);
+    }
+
+
+    //--- print STGI entries
+
+    fprintf(F.f,text_kmp_stgi_cr,REVISION_NUM,kmp->value[KMP_STGI]);
+
+    n = kmp->dlist[KMP_STGI].used;
+    const kmp_stgi_entry_t * stgi = (kmp_stgi_entry_t*)kmp->dlist[KMP_STGI].list;
+
+    for ( i = 0; i < n; i++, stgi++ )
+    {
+	PrintNameIL(F.f,ill+KMP_STGI,i,4,5,0);
+	fprintf(F.f,"%5u %4u %5u %5u   %#10x  0x%02x %#5x %#6x %#4x  # ",
+		stgi->lap_count, stgi->pole_pos,
+		stgi->narrow_start, stgi->enable_lens_flare,
+		stgi->flare_color,
+		stgi->flare_alpha, stgi->unknown_09,
+		stgi->speed_mod >> 8, stgi->speed_mod & 0xff );
+	if (stgi->speed_mod)
+	    fprintf(F.f,"%7.3f\r\n",SpeedMod2float(stgi->speed_mod));
+	else
+	    fputs("   -\r\n",F.f);
+    }
+
+
+    //--- terminate
+
+    fputs(section_end,F.f);
+    ResetFile(&F,set_time);
+    return ERR_OK;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    END				///////////////
+///////////////////////////////////////////////////////////////////////////////
+