SZS v2.18a

1 files changed, 6102 insertions, 0 deletions

diff --git a/project/dclib/dclib-numeric.c b/project/dclib/dclib-numeric.c
new file mode 100644
index 0000000..572211a
--- /dev/null
+++ b/project/dclib/dclib-numeric.c
@@ -0,0 +1,6102 @@
+
+/***************************************************************************
+ *                                                                         *
+ *                     _____     ____                                      *
+ *                    |  __ \   / __ \   _     _ _____                     *
+ *                    | |  \ \ / /  \_\ | |   | |  _  \                    *
+ *                    | |   \ \| |      | |   | | |_| |                    *
+ *                    | |   | || |      | |   | |  ___/                    *
+ *                    | |   / /| |   __ | |   | |  _  \                    *
+ *                    | |__/ / \ \__/ / | |___| | |_| |                    *
+ *                    |_____/   \____/  |_____|_|_____/                    *
+ *                                                                         *
+ *                       Wiimms source code library                        *
+ *                                                                         *
+ ***************************************************************************
+ *                                                                         *
+ *        Copyright (c) 2012-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       *
+ *                                                                         *
+ ***************************************************************************/
+
+#define _GNU_SOURCE 1
+
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <fcntl.h>
+
+#include "dclib-basics.h"
+#include "dclib-debug.h"
+#include "dclib-utf8.h"
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				bits			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint Count1Bits ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    uint count = 0;
+    const uchar *ptr = addr;
+    while ( size-- > 0 )
+	count += TableBitCount[*ptr++];
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int FindLowest0BitLE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr;
+    uint idx;
+    for ( idx = 0; idx < size; idx++ )
+    {
+	const int val = TableLowest0Bit[*ptr++];
+	if ( val >= 0 )
+	    return 8*idx + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindLowest1BitLE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr;
+    uint idx;
+    for ( idx = 0; idx < size; idx++ )
+    {
+	const int val = TableLowest1Bit[*ptr++];
+	if ( val >= 0 )
+	    return 8*idx + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindHighest0BitLE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr + size;
+    while ( size-- > 0 )
+    {
+	const int val = TableHighest0Bit[*--ptr];
+	if ( val >= 0 )
+	    return 8*size + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindHighest1BitLE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr + size;
+    while ( size-- > 0 )
+    {
+	const int val = TableHighest1Bit[*--ptr];
+	if ( val >= 0 )
+	    return 8*size + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u32 GetAlign32 ( u32 data )
+{
+    const int index = FindLowest1Bit(&data,sizeof(data));
+    return index < 0 ? 0 : 1 << index;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 GetAlign64 ( u64 data )
+{
+    const int index = FindLowest1Bit(&data,sizeof(data));
+    return index < 0 ? 0 : 1llu << index;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int FindLowest0BitBE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr + size;
+    uint idx;
+    for ( idx = 0; idx < size; idx++ )
+    {
+	const int val = TableLowest0Bit[*--ptr];
+	if ( val >= 0 )
+	    return 8*idx + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindLowest1BitBE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr + size;
+    uint idx;
+    for ( idx = 0; idx < size; idx++ )
+    {
+	const int val = TableLowest1Bit[*--ptr];
+	if ( val >= 0 )
+	    return 8*idx + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindHighest0BitBE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr;
+    while ( size-- > 0 )
+    {
+	const int val = TableHighest0Bit[*ptr++];
+	if ( val >= 0 )
+	    return 8*size + val;
+    }
+    return -1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int FindHighest1BitBE ( cvp addr, uint size )
+{
+    DASSERT( CHAR_BIT == 8 );
+
+    const uchar *ptr = addr;
+    while ( size-- > 0 )
+    {
+	const int val = TableHighest1Bit[*ptr++];
+	if ( val >= 0 )
+	    return 8*size + val;
+    }
+    return -1;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			bit manipulation		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+bool TestSetBit ( void *addr, uint bit_num )
+{
+    const u8 mask = 1 << ( bit_num & 7 );
+    u8 *ptr = ((u8*)addr) + ( bit_num >> 3 );
+    const bool result = ( *ptr & mask ) != 0;
+    *ptr |= mask;
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TestClearBit  ( void *addr, uint bit_num )
+{
+    const u8 mask = 1 << ( bit_num & 7 );
+    u8 *ptr = ((u8*)addr) + ( bit_num >> 3 );
+    const bool result = ( *ptr & mask ) != 0;
+    *ptr &= ~mask;
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+bool TestInvertBit ( void *addr, uint bit_num )
+{
+    const u8 mask = 1 << ( bit_num & 7 );
+    u8 *ptr = ((u8*)addr) + ( bit_num >> 3 );
+    const bool result = ( *ptr & mask ) != 0;
+    *ptr ^= mask;
+    return result;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void SetBits ( void *addr, uint beg_bitnum, uint end_bitnum )
+{
+    static uchar tab1[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
+    static uchar tab2[] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
+
+    if ( beg_bitnum < end_bitnum )
+    {
+	const uint lo8 =   beg_bitnum >> 3;
+	const uint hi8 = --end_bitnum >> 3;
+
+	if ( lo8 < hi8 )
+	{
+
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest++ |= tab1[ beg_bitnum & 7 ];
+
+	    uchar * end = (uchar*)addr + hi8;
+	    *end |= tab2[ end_bitnum & 7 ];
+
+	    while ( dest < end )
+		*dest++ = 0xff;
+	}
+	else
+	{
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest |= tab1[ beg_bitnum & 7 ] & tab2[ end_bitnum & 7 ];
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void ClearBits ( void *addr, uint beg_bitnum, uint end_bitnum )
+{
+    static uchar tab1[] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f };
+    static uchar tab2[] = { 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00 };
+
+    if ( beg_bitnum < end_bitnum )
+    {
+	const uint lo8 =   beg_bitnum >> 3;
+	const uint hi8 = --end_bitnum  >> 3;
+
+	if ( lo8 < hi8 )
+	{
+
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest++ &= tab1[ beg_bitnum & 7 ];
+
+	    uchar * end = (uchar*)addr + hi8;
+	    *end &= tab2[ end_bitnum & 7 ];
+
+	    while ( dest < end )
+		*dest++ = 0;
+	}
+	else
+	{
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest &= tab1[ beg_bitnum & 7 ] | tab2[ end_bitnum & 7 ];
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void InvertBits ( void *addr, uint beg_bitnum, uint end_bitnum )
+{
+    static uchar tab1[] = { 0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80 };
+    static uchar tab2[] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
+
+    if ( beg_bitnum < end_bitnum )
+    {
+	const uint lo8 =   beg_bitnum >> 3;
+	const uint hi8 = --end_bitnum >> 3;
+
+	if ( lo8 < hi8 )
+	{
+
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest++ ^= tab1[ beg_bitnum & 7 ];
+
+	    uchar * end = (uchar*)addr + hi8;
+	    *end ^= tab2[ end_bitnum & 7 ];
+
+	    while ( dest < end )
+		*dest++ ^= 0xff;
+	}
+	else
+	{
+	    uchar * dest = (uchar*)addr + lo8;
+	    *dest ^= tab1[ beg_bitnum & 7 ] & tab2[ end_bitnum & 7 ];
+	}
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#undef GET_NEXT
+#define GET_NEXT ch = *src++; \
+		if ( ++min_idx > max_idx ) goto term; \
+		if ( min_idx == max_idx ) ch &= max_mask
+
+int PrintBitfieldEx
+(
+    // returns the number of printed characters, or -1 if buffer is to small
+
+    char	*buf,		// buffer
+    uint	buf_size,	// size of 'buf'
+    cvp		bit_field,	// address of bit field
+    uint	min_idx,	// minimal index (inclusive) to check
+    uint	max_idx,	// maximal index (inclusive) to check
+    bool	use_ranges,	// true: create ranges 'a:b'
+    int		mult,		// each printed index is first multiplyed by 'mult'
+    int		add		// ... and then added to 'add'.
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size);
+    DASSERT(bit_field);
+
+    char *dest = buf;
+    char *end  = buf + buf_size;
+    char *sep = "";
+
+    const u8 *src = (u8*)bit_field + (min_idx >> 3);
+    u8 ch = *src++; // always preload the current byte
+    if ( min_idx & 7 )
+	ch &= ~((1<<(min_idx&7))-1);
+    min_idx >>= 3;
+    const u8 max_mask = (2<<(max_idx&7))-1;
+    max_idx >>= 3;
+    noPRINT("SETUP[%zx] %02x, %u..%u, max_mask=%02x\n",
+	src-(u8*)bit_field-1, ch, min_idx, max_idx, max_mask );
+
+    while ( min_idx <= max_idx )
+    {
+	//--- first skip bytes with value 0
+
+	if (!ch)
+	    do { GET_NEXT; } while (!ch);
+
+
+	//-- now find the first set bit
+
+	DASSERT(ch);
+	noPRINT("CHECK[%zx] %02x, %u..%u\n", src-(u8*)bit_field-1, ch, min_idx, max_idx);
+	u8 mask = 1;
+	uint bit_idx = 0;
+	while ( !(ch & mask) )
+	    mask <<= 1, bit_idx++;
+
+	uint first = 8*min_idx + bit_idx;
+	noPRINT("FOUND-BEG[%zx.%u=%u] %02x, %u..%u\n",
+		src-(u8*)bit_field-1, bit_idx, first, ch, min_idx, max_idx );
+
+
+	//-- now find the first bit not set
+
+	while ( ch & mask )
+	    mask <<= 1, bit_idx++;
+
+	if ( bit_idx == 8 )
+	{
+	    do { GET_NEXT; } while (ch == 0xff);
+
+	    mask = 1;
+	    bit_idx = 0;
+	    while ( ch & mask )
+		mask <<= 1, bit_idx++;
+	}
+
+	uint last = 8*min_idx + bit_idx - 1;
+	noPRINT("FOUND-END[%zx.%u=%u] %02x, %u..%u\n",
+		src-(u8*)bit_field-1, bit_idx, last, ch, min_idx, max_idx );
+
+	if ( first == last )
+	    dest = snprintfE(dest,end,"%s%d",sep,first*mult+add);
+	else if ( use_ranges )
+	    dest = snprintfE(dest,end,"%s%d:%d",
+			sep,
+			first * mult + add,
+			last * mult + add );
+	else
+	    while ( first <= last )
+	    {
+		dest = snprintfE(dest,end,"%s%d",sep,first++*mult+add);
+		sep = ",";
+	    }
+
+	if ( dest >= end-1 )
+	{
+	    *dest = 0;
+	    return -1;
+	}
+
+	sep = ",";
+	ch &= ~((1<<bit_idx)-1);
+    }
+
+ term:
+    *dest = 0;
+    return dest - buf;
+}
+
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		low level endian conversions		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void write_be16 ( void * be_data_ptr, u16 data )
+{
+    DASSERT(be_data_ptr);
+    u8 * dest = be_data_ptr;
+    *dest++ = data >> 8;
+    *dest   = data;
+}
+
+void write_be24 ( void * be_data_ptr, u32 data )
+{
+    DASSERT(be_data_ptr);
+    u8 * dest = be_data_ptr + 2;
+    *dest-- = data; data >>= 8;
+    *dest-- = data;
+    *dest   = data >> 8;
+}
+
+void write_be32 ( void * be_data_ptr, u32 data )
+{
+    DASSERT(be_data_ptr);
+    u8 * dest = be_data_ptr + 3;
+    *dest-- = data; data >>= 8;
+    *dest-- = data; data >>= 8;
+    *dest-- = data;
+    *dest   = data >> 8;
+}
+
+void write_be40 ( void * be_data_ptr, u64 data )
+{
+    DASSERT(be_data_ptr);
+    *(u8*)be_data_ptr = data>>32;
+    write_be32( (u8*)be_data_ptr+1, data );
+}
+
+void write_be48 ( void * be_data_ptr, u64 data )
+{
+    DASSERT(be_data_ptr);
+    write_be16( be_data_ptr, data>>32 );
+    write_be32( (u8*)be_data_ptr+2, data );
+}
+
+void write_be56 ( void * be_data_ptr, u64 data )
+{
+    DASSERT(be_data_ptr);
+    write_be24( be_data_ptr, data>>32 );
+    write_be32( (u8*)be_data_ptr+3, data );
+}
+
+void write_be64 ( void * be_data_ptr, u64 data )
+{
+    DASSERT(be_data_ptr);
+    write_be32( be_data_ptr, data >> 32 );
+    write_be32( (u8*)be_data_ptr+4, data );
+}
+
+void write_bef4 ( void * be_data_ptr, float data )
+{
+    // assume: local system supports IEEE 754
+
+    write_be32(be_data_ptr,*(u32*)&data);
+}
+
+void write_bef8 ( void * be_data_ptr, double data )
+{
+    // assume: local system supports IEEE 754
+
+    write_be64(be_data_ptr,*(u64*)&data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void write_le16 ( void * le_data_ptr, u16 data )
+{
+    DASSERT(le_data_ptr);
+    u8 * dest = le_data_ptr;
+    *dest++ = data;
+    *dest   = data >> 8;
+}
+
+void write_le24 ( void * le_data_ptr, u32 data )
+{
+    DASSERT(le_data_ptr);
+    u8 * dest = le_data_ptr;
+    *dest++ = data; data >>= 8;
+    *dest++ = data;
+    *dest   = data >> 8;
+}
+
+void write_le32 ( void * le_data_ptr, u32 data )
+{
+    DASSERT(le_data_ptr);
+    u8 * dest = le_data_ptr;
+    *dest++ = data; data >>= 8;
+    *dest++ = data; data >>= 8;
+    *dest++ = data;
+    *dest   = data >> 8;
+}
+
+void write_le40 ( void * le_data_ptr, u64 data )
+{
+    DASSERT(le_data_ptr);
+    *(u8*)le_data_ptr = (u8)data;
+    write_le32( (u8*)le_data_ptr+1, data >> 8 );
+}
+
+void write_le48 ( void * le_data_ptr, u64 data )
+{
+    DASSERT(le_data_ptr);
+    write_le16( le_data_ptr, data );
+    write_le32( (u8*)le_data_ptr+2, data >> 16 );
+}
+
+void write_le56 ( void * le_data_ptr, u64 data )
+{
+    DASSERT(le_data_ptr);
+    write_le32( le_data_ptr, data );
+    write_le24( (u8*)le_data_ptr+4, data >> 32 );
+}
+
+void write_le64 ( void * le_data_ptr, u64 data )
+{
+    DASSERT(le_data_ptr);
+    write_le32( le_data_ptr, data );
+    write_le32( (u8*)le_data_ptr+4, data >> 32 );
+}
+
+void write_lef4 ( void * le_data_ptr, float data )
+{
+    // assume: local system supports IEEE 754
+
+    write_le32(le_data_ptr,*(u32*)&data);
+}
+
+void write_lef8 ( void * le_data_ptr, double data )
+{
+    // assume: local system supports IEEE 754
+
+    write_le64(le_data_ptr,*(u64*)&data);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// convert lists
+
+void be16n ( u16 * dest, const u16 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	*dest++ = be16(src++);
+}
+
+void be32n ( u32 * dest, const u32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	*dest++ = be32(src++);
+}
+
+void bef4n ( float32 * dest, const float32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	*dest++ = bef4(src++);
+}
+
+void write_be16n ( u16 * dest, const u16 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	write_be16(dest++,*src++);
+}
+
+void write_be32n ( u32 * dest, const u32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	write_be32(dest++,*src++);
+}
+
+void write_bef4n ( float32 * dest, const float32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	write_bef4(dest++,*src++);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// convert lists
+
+void le16n ( u16 * dest, const u16 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	*dest++ = le16(src++);
+}
+
+void lef4n ( float32 * dest, const float32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	*dest++ = lef4(src++);
+}
+
+void write_le16n ( u16 * dest, const u16 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	write_le16(dest++,*src++);
+}
+
+void write_lef4n ( float32 * dest, const float32 * src, int n )
+{
+    DASSERT( dest );
+    DASSERT( n >= 0 );
+    DASSERT( src || !n );
+
+    while ( n-- > 0 )
+	write_lef4(dest++,*src++);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+const endian_func_t be_func =
+{
+    {0xfe,0xff}, true, false, DC_BIG_ENDIAN,
+    be16, be24, be32, be40, be48, be56, be64, bef4, bef8,
+    write_be16, write_be24, write_be32,
+    write_be40, write_be48, write_be56, write_be64,
+    write_bef4, write_bef8
+};
+
+const endian_func_t le_func =
+{
+    {0xff,0xfe}, false, true, DC_LITTLE_ENDIAN,
+    le16, le24, le32, le40, le48, le56, le64, lef4, lef8,
+    write_le16, write_le24, write_le32,
+    write_le40, write_le48, write_le56, write_le64,
+    write_lef4, write_lef8
+};
+
+const endian_func_t * GetEndianFunc ( const void * byte_order_mark )
+{
+    DASSERT(byte_order_mark);
+    const u8 * bom = byte_order_mark;
+    return bom[0] == 0xfe && bom[1] == 0xff
+		? &be_func
+		: bom[0] == 0xff && bom[1] == 0xfe
+			? &le_func
+			: 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint GetTextBOMLen ( const void * data, uint data_size )
+{
+    static const u8 be_bom[] = { 0xef, 0xbb, 0xbf };
+    static const u8 le_bom[] = { 0xef, 0xbf, 0xbe };
+
+    if ( data_size >= 3 && ( !memcmp(data,be_bom,3) || !memcmp(data,le_bom,3) ))
+	return 3;
+
+    if ( data_size >= 2 && ( *(u16*)data == 0xfeff || *(u16*)data == 0xfffe ))
+	return 2;
+
+    return 0;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			check index			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int CheckIndex1 ( int max, int index )
+{
+    DASSERT( max >= 0 );
+
+    if ( index >= 0 )
+	return index <= max ? index : max;
+
+    index += max;
+    return index >= 0 ? index : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CheckIndex1End ( int max, int index )
+{
+    DASSERT( max >= 0 );
+    if ( index > 0 )
+	return index <= max ? index : max;
+
+    index += max;
+    return index >= 0 ? index : 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CheckIndex2 ( int max, int * p_begin, int * p_end )
+{
+    DASSERT( max >= 0 );
+    DASSERT(p_begin);
+    DASSERT(p_end);
+
+    int begin = *p_begin;
+    if ( begin < 0 )
+    {
+	begin += max;
+	if ( begin < 0 )
+	    begin = 0;
+    }
+    else if ( begin > max )
+	begin = max;
+
+    int end = *p_end;
+    if ( end < 0 )
+    {
+	end += max;
+	// don't check for 'end<0' here, because 'end<begin' is checked later
+    }
+    else if ( end > max )
+	end = max;
+
+    if ( end < begin )
+	end = begin;
+
+    *p_begin = begin;
+    *p_end   = end;
+    return end - begin;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int CheckIndex2End ( int max, int * p_begin, int * p_end )
+{
+    DASSERT( max >= 0 );
+    DASSERT(p_begin);
+    DASSERT(p_end);
+
+    int begin = *p_begin;
+    if ( begin <= 0 )
+    {
+	begin += max;
+	if ( begin < 0 )
+	    begin = 0;
+    }
+    else if ( begin > max )
+	begin = max;
+
+    int end = *p_end;
+    if ( end <= 0 )
+    {
+	end += max;
+	// don't check for 'end<0' here, because 'end<begin' is checked later
+    }
+    else if ( end > max )
+	end = max;
+
+    if ( end < begin )
+	end = begin;
+
+    *p_begin = begin;
+    *p_end   = end;
+    return end - begin;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			encoding/decoding		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintEscapedString
+(
+    // returns 'buf'
+
+    char	*buf,		// valid destination buffer
+    uint	buf_size,	// size of 'buf', >= 10
+    ccp		source,		// NULL string to print
+    int		len,		// length of string. if -1, str is null terminated
+    CharMode_t	char_mode,	// modes, bit field (CHMD_*)
+    char	quote,		// NULL or quotation char, that must be quoted
+    uint	*dest_len	// not NULL: Store length of result here
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>=10);
+
+    const CharMode_t utf8	= char_mode & CHMD_UTF8;
+    const CharMode_t allow_e	= char_mode & CHMD_ESC;
+
+    char *dest = buf;
+    char *dest_end = dest + buf_size - 4;
+
+    if (!source)
+	source = "";
+    ccp str = source;
+    ccp end = len < 0 ? 0 : str + len;
+
+    while ( dest < dest_end && ( !end || str < end ) )
+    {
+	const u8 ch = (u8)*str++;
+	switch (ch)
+	{
+	    case 0:
+		if (!end)
+		{
+		    str--;
+		    goto eos;
+		}
+		*dest++ = '\\';
+		*dest++ = 'x';
+		*dest++ = '0';
+		*dest++ = '0';
+		break;
+
+	    case '\\': *dest++ = '\\'; *dest++ = '\\'; break;
+	    case '\a': *dest++ = '\\'; *dest++ = 'a'; break;
+	    case '\b': *dest++ = '\\'; *dest++ = 'b'; break;
+	    case '\f': *dest++ = '\\'; *dest++ = 'f'; break;
+	    case '\n': *dest++ = '\\'; *dest++ = 'n'; break;
+	    case '\r': *dest++ = '\\'; *dest++ = 'r'; break;
+	    case '\t': *dest++ = '\\'; *dest++ = 't'; break;
+	    case '\v': *dest++ = '\\'; *dest++ = 'v'; break;
+
+	    case '\033':
+		*dest++ = '\\';
+		if (allow_e)
+		    *dest++ = 'e';
+		else
+		{
+		    *dest++ = 'x';
+		    *dest++ = '1';
+		    *dest++ = 'B';
+		}
+		break;
+
+	    default:
+		if ( ch == quote )
+		{
+		    *dest++ = '\\';
+		    *dest++ = quote;
+		}
+		else if ( ch < ' ' || !utf8 && (ch&0x7f) < ' ' || (ch&0x7f) == 0x7f )
+		{
+		    *dest++ = '\\';
+		    *dest++ = 'x';
+		    *dest++ = HiDigits[ch>>4];
+		    *dest++ = HiDigits[ch&15];
+		}
+		else
+		    *dest++ = ch;
+	}
+    }
+ eos:
+    *dest = 0;
+    if (dest_len)
+	*dest_len = dest - buf;
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ScanEscapedString
+(
+    // returns the number of valid bytes in 'buf' (NULL term not counted)
+
+    char	*buf,		// valid destination buffer, maybe source
+    uint	buf_size,	// size of 'buf'
+    ccp		source,		// string to scan
+    int		len,		// length of string. if -1, str is null terminated
+    bool	utf8,		// true: source and output is UTF-8
+    int		quote,		// 0:none, -1:auto, >0: quotation char
+    uint	*scanned_len	// not NULL: Store number of scanned 'source' bytes here
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>3);
+    DASSERT(source);
+
+    char *dest = buf;
+    char *dest_end = dest + buf_size - ( utf8 ? 4 : 1 );
+
+    ccp src = source;
+    ccp src_end = src + ( len < 0 ? strlen(src) : len );
+
+    bool have_quote = quote > 0;
+    if ( quote == -1 && src < src_end && ( *src == '"' || *src == '\'' ))
+    {
+	quote = *src++;
+	have_quote = true;
+    }
+
+    while ( dest < dest_end && src < src_end )
+    {
+	uint code;
+	if ( *src == '\\' )
+	    src = ScanEscape(&code,src+1,src_end);
+	else
+	{
+	    if (utf8)
+		code = ScanUTF8AnsiCharE(&src,src_end);
+	    else
+		code = *src++;
+
+	    if ( code == quote && have_quote )
+		break;
+	}
+
+	if (utf8)
+	    dest = PrintUTF8Char(dest,code);
+	else
+	    *dest++ = code;
+    }
+
+    if (scanned_len)
+	*scanned_len = src - source;
+
+    *dest = 0;
+    return dest - buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u32 CalcCRC32 ( u32 crc, cvp buf, uint size )
+{
+ #if HAVE_PRINT0
+    static bool done = false;
+    if ( !done && TRACE_FILE )
+    {
+	done = true;
+	fprintf(TRACE_FILE,"\nstatic const u32 TableCRC32[0x100] =\n{\n");
+	uint i;
+	for ( i = 0; i < 0x100; i += 8 )
+	    fprintf(TRACE_FILE," %#010x,%#010x,%#010x,%#010x, %#010x,%#010x,%#010x,%#010x,\n",
+		TableCRC32[i+0],
+		TableCRC32[i+1],
+		TableCRC32[i+2],
+		TableCRC32[i+3],
+		TableCRC32[i+4],
+		TableCRC32[i+5],
+		TableCRC32[i+6],
+		TableCRC32[i+7] );
+	fprintf(TRACE_FILE,"};\n");
+    }
+ #endif
+
+    crc = ~crc;
+    const u8 *p = buf;
+    while ( size-- )
+	crc = TableCRC32[ (crc ^ *p++) & 0xff ] ^ crc >> 8;
+
+    return ~crc;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u64 DecodeU64
+(
+    ccp		source,			// string to decode
+    int		len,			// length of string. if -1, str is null terminated
+    uint	base,			// number of possible digits (2..36):
+    uint	*scanned_len		// not NULL: Store number of scanned 'str' bytes here
+)
+{
+    DASSERT(source);
+    DASSERT( base <= 36 );
+
+    u64 num = 0;
+    ccp src = source;
+    ccp end = len < 0 ? 0 : src + len;
+
+    while ( !end || src < end )
+    {
+	u8 digit = TableNumbers[(u8)*src];
+	if ( digit >= base )
+	    break;
+	num = num * base + digit;
+	src++;
+    }
+
+    if (scanned_len)
+	*scanned_len = src - source;
+    return num;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp EncodeU64
+(
+    char	* buf,		// result buffer (size depends on base)
+				// If NULL, a local circulary static buffer is used
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u64		num,		// number to encaode
+    uint	base		// number of possible digits (2..64):
+)
+{
+    DASSERT( base >= 2 );
+    DASSERT( base <= 64 );
+    if ( base < 2 )
+	base = 2;
+    else if ( base > 64 )
+	base = 64;
+
+    char digits[65], *dest = digits + sizeof(digits);
+    *--dest = 0;
+
+    while ( num )
+    {
+	*--dest = LoDigits[ num % base ];
+	num /= base;
+    }
+
+    if (!buf)
+	buf = GetCircBuf ( buf_size = digits + sizeof(digits)-1 - dest );
+
+    StringCopyS(buf,buf_size,dest);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+// Default tables for DecodeBase64() and EncodeBase64(), if no table is defined.
+
+ccp TableDecode64default = TableDecode64;
+ccp TableEncode64default = TableEncode64;
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint DecodeBase64
+(
+    // returns the number of valid bytes in 'buf'
+
+    char	*buf,			// valid destination buffer
+    uint	buf_size,		// size of 'buf', >= 3
+    ccp		source,			// NULL or string to decode
+    int		len,			// length of string. if -1, str is null terminated
+    const char	decode64[256],		// decoding table; if NULL: use TableDecode64default
+    bool	allow_white_spaces,	// true: skip white spaces
+    uint	*scanned_len		// not NULL: Store number of scanned 'str' bytes here
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>=3);
+    u8 *dest = (u8*)buf;
+    u8 *dest_end = dest + ( scanned_len ? buf_size / 3 * 3 : buf_size );
+
+    if (!source)
+	source = "";
+    ccp src = source;
+    ccp end = src + ( len < 0 ? strlen(src) : len );
+    int ch1, ch2;
+
+    if (!decode64)
+	decode64 = TableDecode64default;
+
+    while ( dest < dest_end && src < end )
+    {
+	ch1 = decode64[(u8)*src++];
+	if (allow_white_spaces)
+	    while ( ch1 == DECODE_SPACE && src < end )
+		ch1 = decode64[(u8)*src++];
+	if ( ch1 < 0 )
+	{
+	    src--;
+	    break;
+	}
+	if ( src == end )
+	    break;
+
+	ch2 = decode64[(u8)*src++];
+	if (allow_white_spaces)
+	    while ( ch2 == DECODE_SPACE && src < end )
+		ch2 = decode64[(u8)*src++];
+	if ( ch2 < 0 )
+	{
+	    src--;
+	    break;
+	}
+
+	*dest++ = ch1 << 2 | ch2 >> 4;
+	if ( src == end || dest == dest_end )
+	    break;
+
+	ch1 = decode64[(u8)*src++];
+	if (allow_white_spaces)
+	    while ( ch1 == DECODE_SPACE && src < end )
+		ch1 = decode64[(u8)*src++];
+	if ( ch1 < 0 )
+	{
+	    src--;
+	    break;
+	}
+
+	*dest++ = ch2 << 4 | ch1 >> 2;
+	if ( src == end || dest == dest_end )
+	    break;
+
+	ch2 = decode64[(u8)*src++];
+	if (allow_white_spaces)
+	    while ( ch2 == DECODE_SPACE && src < end )
+		ch2 = decode64[(u8)*src++];
+	if ( ch2 < 0 )
+	{
+	    src--;
+	    break;
+	}
+	*dest++ = ch1 << 6 | ch2;
+    }
+
+    if (scanned_len)
+    {
+	while ( src < end && decode64[(u8)*src] == DECODE_FILLER )
+	    src++;
+	*scanned_len = src - source;
+    }
+    return dest - (u8*)buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t DecodeBase64Circ
+(
+    // Returns a buffer alloced by GetCircBuf()
+    // with valid pointer and null terminated.
+    // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned.
+
+    ccp		source,			// NULL or string to decode
+    int		len,			// length of string. if -1, str is null terminated
+    const char	decode64[256]		// decoding table; if NULL: use TableDecode64default
+)
+{
+    char buf[CIRC_BUF_MAX_ALLOC+10];
+    mem_t mem;
+    mem.len = DecodeBase64(buf,sizeof(buf),source,len,decode64,false,0);
+    if ( mem.len < CIRC_BUF_MAX_ALLOC )
+	mem.ptr = CopyCircBuf0(buf,mem.len);
+    else
+    {
+	mem.ptr = 0;
+	mem.len = 0;
+    }
+    return mem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint EncodeBase64
+(
+    // returns the number of scanned bytes of 'source'
+
+    char	*buf,			// valid destination buffer
+    uint	buf_size,		// size of 'buf', >= 4
+    const void	*source,		// NULL or data to encode
+    int		source_len,		// length of 'source'; if <0: use strlen(source)
+    const char	encode64[64+1],		// encoding table; if NULL: use TableEncode64default
+    bool	use_filler,		// use filler for aligned output
+    ccp		next_line,		// not NULL: use this string as new line sep
+    uint	next_line_trigger	// >0: use 'next_line' every # input bytes
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>3);
+    DASSERT(source||!source_len);
+
+    noPRINT("EncodeBase64(sz=%u,len=%d,fil=%d)\n",buf_size,source_len,use_filler);
+
+    if (!next_line)
+	next_line_trigger = ~0;
+    else if (!next_line_trigger)
+	next_line_trigger = 19;
+    else
+	next_line_trigger /= 3;
+
+    char *dest = buf;
+    char *dest_end = buf + buf_size - 4;
+
+    if (!source)
+	source = "";
+    const u8 *src = source;
+    const u8 *src_end = src + ( source_len < 0 ? strlen(source) : source_len );
+
+    if (!encode64)
+	encode64 = TableEncode64default;
+
+    uint n_tupel = 0;
+
+    while ( src < src_end && dest < dest_end )
+    {
+	if ( ++n_tupel > next_line_trigger && next_line )
+	{
+	    char *next = StringCopyE(dest,(char*)buf+buf_size,next_line);
+	    if ( next >= dest_end )
+		break;
+	    dest = next;
+	    n_tupel = 1;
+	}
+
+	//----- start: no pending bits
+
+	u8 ch1 = *src++;
+	*dest++ = encode64 [ ch1 >> 2 ];
+	ch1 &= 0x03;
+	DASSERT( (ch1 & ~0x03) == 0 );
+	if ( src == src_end )
+	{
+	    *dest++ = encode64[ch1<<4];
+	    if (use_filler)
+	    {
+		*dest++ = encode64[64];
+		*dest++ = encode64[64];
+	    }
+	    break;
+	}
+
+	//----- 2 pending bits in 'ch1'
+
+	u8 ch2 = *src++;
+	*dest++ = encode64 [ ch1 << 4 | ch2 >> 4 ];
+	ch2 &= 0x0f;
+	DASSERT( (ch2 & ~0x0f) == 0 );
+	if ( src == src_end )
+	{
+	    *dest++ = encode64[ch2<<2];
+	    if (use_filler)
+		*dest++ = encode64[64];
+	    break;
+	}
+
+	//----- 4 pending bits in 'ch2'
+
+	ch1 = *src++;
+	*dest++ = encode64 [ ch2 << 2 | ch1 >> 6 ];
+
+	//----- 6 pending bits in 'ch1'
+
+	*dest++ = encode64[ch1&0x3f];
+    }
+
+    *dest = 0;
+
+    return src - (const u8*)source;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t EncodeBase64Circ
+(
+    // Returns a buffer alloced by GetCircBuf()
+    // with valid pointer and null terminated.
+    // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned.
+
+    const void	*source,		// NULL or data to encode
+    int		source_len,		// length of 'source'; if <0: use strlen(source)
+    const char	encode64[64+1]		// encoding table; if NULL: use TableEncode64default
+)
+{
+    char buf[CIRC_BUF_MAX_ALLOC+10];
+    EncodeBase64(buf,sizeof(buf),source,source_len,encode64,false,0,0);
+    mem_t mem;
+    mem.len = strlen(buf);
+    if ( mem.len < CIRC_BUF_MAX_ALLOC )
+	mem.ptr = CopyCircBuf(buf,mem.len+1);
+    else
+    {
+	mem.ptr = 0;
+	mem.len = 0;
+    }
+    return mem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint EncodeJSON
+(
+    // returns the number of valid bytes in 'buf'. Result is NULL-terminated.
+
+    char	*buf,			// valid destination buffer
+    uint	buf_size,		// size of 'buf', >2 and 2 bytes longer than needed
+    const void	*source,		// NULL or data to encode
+    int		source_len		// length of 'source'; if <0: use strlen(source)
+)
+{
+    DASSERT(buf);
+    DASSERT(buf_size>2);
+
+    char *dest = buf;
+    char *dest_end = dest + buf_size - 2;
+
+    if (!source)
+	source = "";
+    ccp str = source;
+    ccp end = str + ( source_len < 0 ? strlen(str) : source_len );
+
+    while ( dest < dest_end && str < end )
+    {
+	const u8 ch = (u8)*str++;
+	switch (ch)
+	{
+	    case '"':  *dest++ = '\\'; *dest++ = '"'; break;
+	    case '\\': *dest++ = '\\'; *dest++ = '\\'; break;
+	    case '\b': *dest++ = '\\'; *dest++ = 'b'; break;
+	    case '\f': *dest++ = '\\'; *dest++ = 'f'; break;
+	    case '\n': *dest++ = '\\'; *dest++ = 'n'; break;
+	    case '\r': *dest++ = '\\'; *dest++ = 'r'; break;
+	    case '\t': *dest++ = '\\'; *dest++ = 't'; break;
+
+	    default:
+		if ( ch >= ' ' )
+		    *dest++ = ch;
+		else if ( dest + 5 > dest_end )
+		    goto eos;
+		else
+		{
+		    *dest++ = '\\';
+		    *dest++ = 'u';
+		    *dest++ = '0';
+		    *dest++ = '0';
+		    *dest++ = HiDigits[ch>>4];
+		    *dest++ = HiDigits[ch&15];
+		}
+		break;
+	}
+    }
+
+ eos:
+    *dest = 0;
+    return dest - buf;
+}
+
+//-----------------------------------------------------------------------------
+
+mem_t EncodeJSONCirc
+(
+    // Returns a buffer alloced by GetCircBuf()
+    // with valid pointer and null terminated.
+    // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned.
+
+    const void	*source,		// NULL or data to encode
+    int		source_len		// length of 'source'; if <0: use strlen(source)
+)
+{
+    char buf[CIRC_BUF_MAX_ALLOC+10];
+    mem_t mem;
+    mem.len = EncodeJSON(buf,sizeof(buf),source,source_len);
+    if ( mem.len < CIRC_BUF_MAX_ALLOC )
+	mem.ptr = CopyCircBuf(buf,mem.len+1);
+    else
+    {
+	mem.ptr = 0;
+	mem.len = 0;
+    }
+    return mem;
+}
+
+//-----------------------------------------------------------------------------
+
+mem_t QuoteJSONCirc
+(
+    // Returns a buffer alloced by GetCircBuf()
+    // with valid pointer and null terminated.
+    // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned.
+
+    const void	*source,		// NULL or data to encode
+    int		source_len,		// length of 'source'; if <0: use strlen(source)
+    int		null_if			// return 'null' without quotes ...
+					//	<=0: never
+					//	>=1: if source == NULL
+					//	>=2: if source_len == 0
+)
+{
+    if ( source_len < 0 )
+	source_len = source ? strlen(source) : 0;
+
+    mem_t mem;
+    if ( null_if > 0 && !source || null_if > 1 && !source_len )
+    {
+	mem.ptr = "null";
+	mem.len = 4;
+    }
+    else
+    {
+	char buf[CIRC_BUF_MAX_ALLOC+10];
+	mem.len = EncodeJSON(buf+1,sizeof(buf)-2,source,source_len) + 2;
+	if ( mem.len < CIRC_BUF_MAX_ALLOC - 2 )
+	{
+	    buf[0] = buf[mem.len-1] = '"';
+	    buf[mem.len] = 0;
+	    mem.ptr = CopyCircBuf(buf,mem.len+1);
+	}
+	else
+	{
+	    mem.ptr = 0;
+	    mem.len = 0;
+	}
+    }
+    return mem;
+}
+
+//-----------------------------------------------------------------------------
+
+mem_t DecodeJSONCirc
+(
+    // Returns a buffer alloced by GetCircBuf()
+    // with valid pointer and null terminated.
+    // If result is too large (>CIRC_BUF_MAX_ALLOC) then (0,0) is returned.
+
+    ccp		source,			// NULL or string to decode
+    int		source_len		// length of 'source'. If -1, str is NULL terminated
+)
+{
+    char buf[CIRC_BUF_MAX_ALLOC+10];
+    mem_t mem;
+    mem.len = DecodeJSON(buf,sizeof(buf),source,source_len,0);
+    if ( mem.len < CIRC_BUF_MAX_ALLOC )
+	mem.ptr = CopyCircBuf(buf,mem.len+1);
+    else
+    {
+	mem.ptr = 0;
+	mem.len = 0;
+    }
+    return mem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint DecodeByMode
+(
+    // returns the number of valid bytes in 'buf'. Result is NULL-terminated.
+
+    char		*buf,		// valid destination buffer
+    uint		buf_size,	// size of 'buf', >= 3
+    ccp			source,		// string to decode
+    int			slen,		// length of string. if -1, str is null terminated
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT(buf);
+    DASSERT( buf_size >= 1 );
+    DASSERT( source || !slen );
+    DASSERT( (uint)emode < ENCODE__N );
+
+    uint len = 0;
+    if ( buf_size < 4 )
+    {
+	char temp[4];
+	len = DecodeByMode(temp,sizeof(temp),source,slen,emode);
+	memcpy(buf,temp,buf_size);
+	goto term;
+    }
+
+    DASSERT( buf_size >= 3 );
+    switch (emode)
+    {
+      case ENCODE_STRING:
+	len = ScanEscapedString(buf,buf_size,source,slen,false,0,0);
+	break;
+
+      case ENCODE_UTF8:
+	len = ScanEscapedString(buf,buf_size,source,slen,true,0,0);
+	break;
+
+      case ENCODE_BASE64:
+	len = DecodeBase64(buf,buf_size-1,source,slen,TableDecode64,true,0);
+	break;
+
+      case ENCODE_BASE64URL:
+      case ENCODE_BASE64STAR:
+	len = DecodeBase64(buf,buf_size-1,source,slen,TableDecode64url,true,0);
+	break;
+
+      case ENCODE_BASE64XML:
+	len = DecodeBase64(buf,buf_size-1,source,slen,TableDecode64xml,true,0);
+	break;
+
+      case ENCODE_JSON:
+	len = DecodeJSON(buf,buf_size,source,slen,0);
+	break;
+
+      default:
+	if ( slen < 0 )
+	    len = StringCopyS(buf,buf_size,source) - buf;
+	else
+	    len = StringCopySM(buf,buf_size,source,slen) - buf;
+	break;
+    }
+
+    //--- terminate with NULL
+
+ term:;
+    if ( len >= buf_size )
+	len = buf_size - 1;
+    buf[len] = 0;
+    return len;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t DecodeByModeMem
+(
+    // Returns the decoded 'source'. Result is NULL-terminated.
+    // It points either to 'buf' or is alloced (on buf==NULL or to less space)
+    // If alloced (mem.ptr!=buf) => call FreeMem(&mem)
+
+    char		*buf,		// NULL or destination buffer
+    uint		buf_size,	// size of 'buf'
+    ccp			source,		// string to decode
+    int			slen,		// length of string. if -1, str is null terminated
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT( source || !slen );
+    DASSERT( (uint)emode < ENCODE__N );
+
+    if ( slen < 0 )
+	slen = source ? strlen(source) : 0;
+
+    uint need;
+    switch (emode)
+    {
+      case ENCODE_STRING:
+      case ENCODE_UTF8:
+	need = slen + 5;
+	break;
+
+      case ENCODE_BASE64:
+      case ENCODE_BASE64URL:
+      case ENCODE_BASE64STAR:
+      case ENCODE_BASE64XML:
+	need = ( 3*slen ) / 4 + 12;
+	break;
+
+      //case ENCODE_JSON: // [[json]]
+      default:
+	need = slen + 3; // at least 3 bytes
+	break;
+    }
+
+    const bool alloced = !buf || buf_size < need;
+    if (alloced)
+    {
+	buf = MALLOC(need);
+	buf_size = need;
+    }
+
+    mem_t mem;
+    mem.len = DecodeByMode(buf,buf_size,source,slen,emode);
+    if ( alloced && mem.len+10 < buf_size )
+	buf = REALLOC( buf, mem.len+1 );
+    mem.ptr = buf;
+    return mem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint EncodeByMode
+(
+    // returns the number of valid bytes in 'buf'. Result is NULL-terminated.
+
+    char		*buf,		// valid destination buffer
+    uint		buf_size,	// size of 'buf', >= 4
+    ccp			source,		// string to encode
+    int			slen,		// length of string. if -1, str is null terminated
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT(buf);
+    DASSERT( buf_size >= 3 );
+    DASSERT( source || !slen );
+    DASSERT( (uint)emode < ENCODE__N );
+
+    noPRINT("EncodeByMode(,%u,%d,%d)\n",buf_size,slen,emode);
+
+    uint len = 0;
+    switch (emode)
+    {
+      case ENCODE_STRING:
+	PrintEscapedString(buf,buf_size,source,slen,0,0,&len);
+	break;
+
+      case ENCODE_UTF8:
+	PrintEscapedString(buf,buf_size,source,slen,CHMD__ALL,0,&len);
+	break;
+
+      case ENCODE_BASE64:
+	len = EncodeBase64(buf,buf_size,source,slen,TableEncode64,true,0,0);
+	len = EncodeBase64FillLen(len);
+	break;
+
+      case ENCODE_BASE64URL:
+	len = EncodeBase64(buf,buf_size,source,slen,TableEncode64url,true,0,0);
+	len = EncodeBase64FillLen(len);
+	break;
+
+      case ENCODE_BASE64STAR:
+	len = EncodeBase64(buf,buf_size,source,slen,TableEncode64star,true,0,0);
+	len = EncodeBase64FillLen(len);
+	break;
+
+      case ENCODE_BASE64XML:
+	len = EncodeBase64(buf,buf_size,source,slen,TableEncode64xml,true,0,0);
+	len = EncodeBase64FillLen(len);
+	break;
+
+      case ENCODE_JSON:
+	len = EncodeJSON(buf,buf_size,source,slen);
+	break;
+
+      default:
+	if ( slen < 0 )
+	    len = StringCopyS(buf,buf_size,source) - buf;
+	else
+	    len = StringCopySM(buf,buf_size,source,slen) - buf;
+	break;
+    }
+
+    //--- terminate with NULL
+
+    if ( len >= buf_size )
+	len = buf_size - 1;
+    buf[len] = 0;
+    return len;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+mem_t EncodeByModeMem
+(
+    // Returns the encoded 'source'. Result is NULL-terminated.
+    // It points either to 'buf' or is alloced (on buf==NULL or to less space)
+    // If alloced (mem.ptr!=buf) => call FreeMem(&mem)
+
+    char		*buf,		// NULL or destination buffer
+    uint		buf_size,	// size of 'buf'
+    ccp			source,		// string to encode
+    int			slen,		// length of string. if -1, str is null terminated
+    EncodeMode_t	emode		// encoding mode
+)
+{
+    DASSERT( source || !slen );
+    DASSERT( (uint)emode < ENCODE__N );
+
+    if ( slen < 0 )
+	slen = source ? strlen(source) : 0;
+
+    uint need;
+    switch (emode)
+    {
+      case ENCODE_STRING:
+      case ENCODE_UTF8:
+	need = slen * 4 + 5;
+	break;
+
+      case ENCODE_BASE64:
+      case ENCODE_BASE64URL:
+      case ENCODE_BASE64STAR:
+      case ENCODE_BASE64XML:
+	need = ( 4*slen ) / 3 + 10;
+	break;
+
+      case ENCODE_JSON: // [[json]]
+	{
+	    need = slen + 1;
+	    ccp ptr = source;
+	    ccp end = ptr + slen;
+	    while ( ptr < end )
+		if ( (uchar)*ptr++ < ' ' )
+		    need += 5;
+	}
+	break;
+
+      default:
+	need = slen + 1;
+	break;
+    }
+
+    const bool alloced = !buf || buf_size < need;
+    if (alloced)
+    {
+	buf = MALLOC(need);
+	buf_size = need;
+    }
+
+    mem_t mem;
+    mem.len = EncodeByMode(buf,buf_size,source,slen,emode);
+    if ( alloced && mem.len+10 < buf_size )
+	buf = REALLOC( buf, mem.len+1 );
+    mem.ptr = buf;
+    return mem;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    time			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+s64 timezone_adjust_sec   = -1;
+s64 timezone_adjust_usec  = -1;
+int timezone_adjust_isdst = -1;
+
+///////////////////////////////////////////////////////////////////////////////
+
+void SetupTimezone ( bool force )
+{
+    if ( force || timezone_adjust_sec == -1 )
+    {
+	tzset();
+	timezone_adjust_sec = timezone;
+
+	time_t tim = GetTimeSec(false);
+	struct tm *tm = localtime(&tim);
+	timezone_adjust_isdst = tm->tm_isdst;
+	if (tm->tm_isdst)
+	    timezone_adjust_sec -= 3600;
+
+	timezone_adjust_usec = 1000000ll * timezone_adjust_sec;
+	TRACE("TZ: %s,%s, %ld, %d => %lld %lld\n",
+		tzname[0], tzname[1], timezone, daylight,
+		timezone_adjust_sec, timezone_adjust_usec );
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct timeval GetTimeOfDay ( bool localtime )
+{
+    static uint last_hour = 0;
+    struct timeval tval;
+    gettimeofday(&tval,NULL);
+    if (localtime)
+    {
+	const uint hour = tval.tv_sec / 3600;
+	if ( last_hour != hour )
+	{
+	    last_hour = hour;
+	    SetupTimezone(true);
+	}
+	tval.tv_sec -= timezone_adjust_sec;
+    }
+    return tval;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+DayTime_t GetDayTime ( bool localtime )
+{
+    struct timeval tval = GetTimeOfDay(localtime);
+    div_t d;
+
+    DayTime_t dt;
+    dt.time	= tval.tv_sec;
+    d		= div(tval.tv_sec,86400);
+    dt.day	= d.quot;
+    d		= div(d.rem,3600);
+    dt.hour	= d.quot;
+    d		= div(d.rem,60);
+    dt.min	= d.quot;
+    dt.sec	= d.rem;
+    dt.usec	= tval.tv_usec;
+
+    return dt;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u_sec_t GetTimeSec ( bool localtime )
+{
+    struct timeval tval = GetTimeOfDay(localtime);
+    return tval.tv_sec;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u_msec_t GetTimeMSec ( bool localtime )
+{
+    struct timeval tval = GetTimeOfDay(localtime);
+    return (u64)(tval.tv_sec) * 1000ll + tval.tv_usec/1000;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u_usec_t GetTimeUSec ( bool localtime )
+{
+    struct timeval tval = GetTimeOfDay(localtime);
+    return (u64)(tval.tv_sec) * 1000000ll + tval.tv_usec;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    timer			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+static time_t time_base = 0;
+
+///////////////////////////////////////////////////////////////////////////////
+
+u_msec_t GetTimerMSec()
+{
+    struct timeval tval;
+    gettimeofday(&tval,NULL);
+    if (!time_base)
+	time_base = tval.tv_sec;
+
+    return (u_msec_t)( tval.tv_sec - time_base ) * 1000 + tval.tv_usec/1000;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u_usec_t GetTimerUSec()
+{
+    struct timeval tval;
+    gettimeofday(&tval,NULL);
+    if (!time_base)
+	time_base = tval.tv_sec;
+
+    return (u_usec_t)( tval.tv_sec - time_base ) * 1000000 + tval.tv_usec;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimeByFormat
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    time_t		time		// seconds since epoch -> time()
+)
+{
+    char buf[100];
+    struct tm *tm = localtime(&time);
+    const uint len = strftime(buf,sizeof(buf),format,tm);
+    return CopyCircBuf(buf,len+1);
+}
+
+//-----------------------------------------------------------------------------
+
+ccp PrintTimeByFormatUTC
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    time_t		time		// seconds since epoch -> time()
+)
+{
+    char buf[100];
+    struct tm *tm = gmtime(&time);
+    const uint len = strftime(buf,sizeof(buf),format,tm);
+    return CopyCircBuf(buf,len+1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintUsecByFormat
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    time_t		time,		// seconds since epoch -> time()
+    uint		usec		// micro second of second
+)
+{
+    char buf[100];
+    struct tm *tm = localtime(&time);
+    const uint len = strftime(buf,sizeof(buf),format,tm);
+    char *at = strchr(buf,'@');
+    if (at)
+    {
+	char ubuf[8];
+	snprintf(ubuf,sizeof(ubuf),"%06u",usec);
+	ccp src = ubuf;
+	while ( *at == '@' && *src )
+	    *at++ = *src++;
+    }
+
+    return CopyCircBuf(buf,len+1);
+}
+
+//-----------------------------------------------------------------------------
+
+ccp PrintUsecByFormatUTC
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    time_t		time,		// seconds since epoch -> time()
+    uint		usec		// micro second of second
+)
+{
+    char buf[100];
+    struct tm *tm = gmtime(&time);
+    const uint len = strftime(buf,sizeof(buf),format,tm);
+    char *at = strchr(buf,'@');
+    if (at)
+    {
+	char ubuf[8];
+	snprintf(ubuf,sizeof(ubuf),"%06u",usec);
+	ccp src = ubuf;
+	while ( *at == '@' && *src )
+	    *at++ = *src++;
+    }
+
+    return CopyCircBuf(buf,len+1);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimevalByFormat
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    const struct timeval *tv		// time to print, if NULL use gettimeofday()
+)
+{
+    struct timeval temp;
+    if (!tv)
+    {
+	gettimeofday(&temp,0);
+	tv = &temp;
+    }
+
+    return PrintUsecByFormat(format,tv->tv_sec,tv->tv_usec);
+}
+
+//-----------------------------------------------------------------------------
+
+ccp PrintTimevalByFormatUTC
+(
+    // returns temporary buffer by GetCircBuf();
+
+    ccp			format,		// format string for strftime()
+    const struct timeval *tv		// time to print, if NULL use gettimeofday()
+)
+{
+    struct timeval temp;
+    if (!tv)
+    {
+	gettimeofday(&temp,0);
+	tv = &temp;
+    }
+
+    return PrintUsecByFormatUTC(format,tv->tv_sec,tv->tv_usec);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimeSec
+(
+    char		* buf,		// result buffer (>19 bytes are good)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    uint		sec		// seconds (=time) to print
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 20 );
+
+    time_t time = sec;
+    struct tm *tm = localtime(&time);
+    strftime(buf,buf_size,"%F %T",tm);
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimeMSec
+(
+    char		* buf,		// result buffer (>23 bytes are good)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u_msec_t		msec,		// milliseconds to print
+    uint		fraction	// number of digits (0-3) to print as fraction
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 24 );
+
+    time_t time = msec / 1000;
+    struct tm *tm = localtime(&time);
+    uint len = strftime(buf,buf_size,"%F %T",tm);
+
+    if ( fraction && len + 4 < buf_size )
+    {
+	len += snprintf(buf+len, buf_size-len, ".%03llu", msec % 1000 );
+	const uint pos = len - 3 + ( fraction < 3 ? fraction : 3 );
+	if ( pos < buf_size )
+	    buf[pos] = 0;
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimeUSec
+(
+    char		* buf,		// result buffer (>26 bytes are good)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u_usec_t		usec,		// microseconds to print
+    uint		fraction	// number of digits (0-6) to print as fraction
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 28 );
+
+    time_t time = usec / 1000000;
+    struct tm *tm = localtime(&time);
+    uint len = strftime(buf,buf_size,"%F %T",tm);
+
+    if ( fraction && len + 7 < buf_size )
+    {
+	len += snprintf(buf+len, buf_size-len, ".%06llu", usec % 1000000 );
+	const uint pos = len - 6 + ( fraction < 6 ? fraction : 6 );
+	if ( pos < buf_size )
+	    buf[pos] = 0;
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimerMSec
+(
+    char		* buf,		// result buffer (>12 bytes are good)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u32			msec,		// milliseconds to print
+    uint		fraction	// number of digits (0-3) to print as fraction
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 16 );
+
+    if (fraction)
+    {
+	const uint len = snprintf(buf,buf_size,"%02d:%02d:%02d.%03d",
+		msec/3600000, msec/60000%60, msec/1000%60, msec%1000 );
+	if ( len > 3 && fraction < 3 )
+	{
+	    const uint pos = len - 3 + fraction;
+	    if ( pos < buf_size )
+		buf[pos] = 0;
+	}
+    }
+    else
+	snprintf(buf,buf_size,"%02d:%02d:%02d",
+	    msec/3600000, msec/60000%60, msec/1000%60 );
+
+    ccp ptr = buf;
+    int colon_counter = 0;
+    while ( *ptr == '0' || *ptr == ':' && !colon_counter++ )
+	ptr++;
+    return *ptr == ':' ? ptr-1 : ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimerUSec
+(
+    char		* buf,		// result buffer (>16 bytes are good)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s_usec_t		usec,		// microseconds to print
+    uint		fraction	// number of digits (0-3) to print as fraction
+)
+{
+    if ( !buf || buf_size < 4 )
+	buf = GetCircBuf( buf_size = 20 );
+
+    const bool minus = usec < 0;
+    if (minus)
+	usec = -usec;
+
+    u32 sec = (u64)usec / 1000000;
+
+    if (fraction)
+    {
+	const uint len = snprintf(buf+1,buf_size-1,"%02d:%02d:%02d.%06lld",
+	    sec/3600, sec/60%60, sec%60, (u64)usec%1000000 );
+	if ( len > 6 && fraction < 6 )
+	{
+	    const uint pos = len - 6 + fraction;
+	    if ( pos < buf_size )
+		buf[pos] = 0;
+	}
+    }
+    else
+	snprintf(buf+1,buf_size-1,"%02d:%02d:%02d",
+	    sec/3600, sec/60%60, sec%60 );
+
+    char *ptr = buf+1;
+    while ( *ptr == '0' || *ptr == ':' )
+	ptr++;
+    if ( *ptr == '.' )
+	ptr--;
+    if (minus)
+	*--ptr = '-';
+    return ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimer3
+(
+    char		* buf,		// result buffer (>3 bytes)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			sec,		// seconds to print
+    int			usec,		// 0...999999: usec fraction,
+					// otherwise suppress ms/us output
+    bool		aligned		// true: print aligned 3 character output
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 4 );
+
+    if ( !sec && usec >= 0 && usec <= 999999 )
+    {
+	if (!usec)
+	    StringCopyS(buf,buf_size,aligned?"  0":"0");
+	else if ( usec < 100 )
+	    snprintf(buf,buf_size,aligned?"%2uu":"%uu",usec);
+	else if ( usec < 1000 )
+	    snprintf(buf,buf_size,".%ui",usec/100);
+	else if ( usec < 100000 )
+	    snprintf(buf,buf_size,aligned?"%2ui":"%ui",usec/1000);
+	else
+	    snprintf(buf,buf_size,".%us",usec/100000);
+    }
+    else if ( sec < 100 )
+	snprintf(buf,buf_size,aligned?"%2llus":"%llus",sec);
+    else if ( sec < 6000 )
+	snprintf(buf,buf_size,aligned?"%2llum":"%llum",sec/60);
+    else if ( sec < 360000 )
+	snprintf(buf,buf_size,aligned?"%2lluh":"%lluh",sec/3600);
+    else
+    {
+	const u64 days = sec / (24*3600);
+	if ( days < 100 )
+	    snprintf(buf,buf_size,aligned?"%2llud":"%llud",days);
+	else if ( days < 700 )
+	    snprintf(buf,buf_size,aligned?"%2lluw":"%lluw",days/7);
+	else
+	{
+	    const u32 years = days / 365;
+	    if ( years < 100 )
+		snprintf(buf,buf_size,aligned?"%2uy":"%uy",years);
+	    else
+		buf = "***";
+	}
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimer4
+(
+    char		* buf,		// result buffer (>4 bytes)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			sec,		// seconds to print
+    int			usec,		// 0...999999: usec fraction,
+					// otherwise suppress ms/us output
+    bool		aligned		// true: print aligned 4 character output
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 5 );
+
+    if ( sec < 10 && usec >= 0 && usec <= 999999 )
+    {
+	if (sec)
+	    snprintf(buf,buf_size,"%llu.%us",sec,usec/100000);
+	else if (!usec)
+	    StringCopyS(buf,buf_size,aligned?"   0":"0");
+	else if ( usec < 1000 )
+	    snprintf(buf,buf_size,aligned?"%3uu":"%uu",usec);
+	else if ( usec < 10000 )
+	    snprintf(buf,buf_size,"%u.%ui",usec/1000,usec/100%10);
+	else
+	    snprintf(buf,buf_size,aligned?"%3ui":"%ui",usec/1000);
+    }
+    else if ( sec < 600 )
+	snprintf(buf,buf_size,aligned?"%3llus":"%llus",sec);
+    else if ( sec < 36000 )
+	snprintf(buf,buf_size,aligned?"%3llum":"%llum",sec/60);
+    else if ( sec < 168*3600 )
+	snprintf(buf,buf_size,aligned?"%3lluh":"%lluh",sec/3600);
+    else
+    {
+	const u64 days = sec / (24*3600);
+	if ( days < 365 )
+	    snprintf(buf,buf_size,aligned?"%3llud":"%llud",days);
+	else if ( days < 10*365 )
+	    snprintf(buf,buf_size,aligned?"%3lluw":"%lluw",days/7);
+	else
+	{
+	    const u32 years = days / 365;
+	    if ( years < 1000 )
+		snprintf(buf,buf_size,aligned?"%3uy":"%uy",years);
+	    else
+		buf = "****";
+	}
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimer6
+(
+    char		* buf,		// result buffer (>6 bytes)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			sec,		// seconds to print
+    int			usec,		// 0...999999: usec fraction,
+					//    otherwise suppress ms/us output
+    bool		aligned		// true: print aligned 6 character output
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 7 );
+
+    if (aligned)
+    {
+	if ( sec < 10 && usec >= 0 && usec <= 999999 )
+	{
+	    usec += 1000000 * sec;
+	    if (!usec)
+		StringCopyS(buf,buf_size,"     0");
+	    else if ( usec < 10000 )
+		snprintf(buf,buf_size,"%4uus",usec);
+	    else
+		snprintf(buf,buf_size,"%4ums",usec/1000);
+	}
+	else if ( sec < 100 )
+	{
+	    if ( usec >= 0 && usec <= 999999 )
+		snprintf(buf,buf_size,"%2llu.%02us",sec,usec/10000);
+	    else
+		snprintf(buf,buf_size,"%5llus",sec);
+	}
+	else if ( sec < 100*60 )
+	    snprintf(buf,buf_size,"%2llum%02llus",sec/60,sec%60);
+	else if ( sec < 100*3600 )
+	    snprintf(buf,buf_size,"%2lluh%02llum",sec/3600,sec/60%60);
+	else
+	{
+	    const u64 days = sec / (24*3600);
+	    if ( days < 100 )
+		snprintf(buf,buf_size,"%2llud%02lluh",days,sec/3600%24);
+	    else if ( days < 7000 )
+		snprintf(buf,buf_size,"%3lluw%llud",days/7,days%7);
+	    else
+	    {
+		const u32 years = days / 365;
+		if ( years < 100 )
+		    snprintf(buf,buf_size,"%2uy%02lluw",years,days%365/7);
+		else if ( years < 100000 )
+		    snprintf(buf,buf_size,"%5uy",years);
+		else
+		    buf = "******";
+	    }
+	}
+    }
+    else
+    {
+	if ( sec < 10 )
+	{
+	    usec += 1000000 * sec;
+	    if (!usec)
+		StringCopyS(buf,buf_size,"0");
+	    else if ( usec < 10000 )
+		snprintf(buf,buf_size,"%uus",usec);
+	    else
+		snprintf(buf,buf_size,"%ums",usec/1000);
+	}
+	else if ( sec < 100 )
+	{
+	    if ( usec >= 0 && usec <= 999999 )
+	    {
+		const uint val2 = usec/10000;
+		if (val2)
+		    snprintf(buf,buf_size,"%llu.%02us",sec,val2);
+		else
+		    snprintf(buf,buf_size,"%llus",sec);
+	    }
+	    else
+		snprintf(buf,buf_size,"%llus",sec);
+	}
+	else if ( sec < 100*60 )
+	{
+	    const uint val2 = sec%60;
+	    if (val2)
+		snprintf(buf,buf_size,"%llum%02us",sec/60,val2);
+	    else
+		snprintf(buf,buf_size,"%llum",sec/60);
+	}
+	else if ( sec < 100*3600 )
+	{
+	    const uint val2 = sec/60%60;
+	    if (val2)
+		snprintf(buf,buf_size,"%lluh%02um",sec/3600,val2);
+	    else
+		snprintf(buf,buf_size,"%lluh",sec/3600);
+	}
+	else
+	{
+	    const u64 days = sec / (24*3600);
+	    if ( days < 100 )
+	    {
+		const uint val2 = sec/3600%24;
+		if (val2)
+		    snprintf(buf,buf_size,"%llud%02uh",days,val2);
+		else
+		    snprintf(buf,buf_size,"%llud",days);
+	    }
+	    else if ( days < 7000 )
+	    {
+		const uint val2 = days%7;
+		if (val2)
+		    snprintf(buf,buf_size,"%lluw%ud",days/7,val2);
+		else
+		    snprintf(buf,buf_size,"%lluw",days/7);
+	    }
+	    else
+	    {
+		const u32 years = days / 365;
+		if ( years < 100 )
+		{
+		    const uint val2 = days%365/7;
+		    if (val2)
+			snprintf(buf,buf_size,"%uy%02uw",years,val2);
+		    else
+			snprintf(buf,buf_size,"%uy",years);
+		}
+		else if ( years < 100000 )
+		    snprintf(buf,buf_size,"%uy",years);
+		else
+		    buf = "******";
+	    }
+	}
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimerUSec4s
+(
+    char		* buf,		// result buffer (>4 bytes)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s_usec_t		usec,		// microseconds to print
+    sizeform_mode_t	mode		// support of DC_SFORM_ALIGN, DC_SFORM_PLUS
+)
+{
+    if ( !buf || buf_size < 2 )
+	buf = GetCircBuf( buf_size = 5 );
+
+    if (!usec)
+	StringCopyS(buf,buf_size, mode & DC_SFORM_ALIGN ? "   0" : "0" );
+    else
+    {
+	char sign;
+	if ( usec < 0 )
+	{
+	    usec = -usec;
+	    sign = '-';
+	}
+	else
+	    sign = mode & DC_SFORM_PLUS ? '+' : ' ';
+
+	PrintTimerUSec3(buf+1,buf_size-1,usec,mode&DC_SFORM_ALIGN);
+	*buf = ' ';
+
+	char *ptr = buf+1;
+	while ( *ptr == ' ' )
+	    ptr++;
+	ptr[-1] = sign;
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintTimerUSec7s
+(
+    char		* buf,		// result buffer (>7 bytes)
+					// If NULL, a local circulary static buffer is used
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s_usec_t		usec,		// microseconds to print
+    sizeform_mode_t	mode		// support of DC_SFORM_ALIGN, DC_SFORM_PLUS
+)
+{
+    if ( !buf || buf_size < 2 )
+	buf = GetCircBuf( buf_size = 8 );
+
+    if (!usec)
+	StringCopyS(buf,buf_size, mode & DC_SFORM_ALIGN ? "      0" : "0" );
+    else
+    {
+	char sign;
+	if ( usec < 0 )
+	{
+	    usec = -usec;
+	    sign = '-';
+	}
+	else
+	    sign = mode & DC_SFORM_PLUS ? '+' : ' ';
+
+	PrintTimerUSec6(buf+1,buf_size-1,usec, mode & DC_SFORM_ALIGN );
+	*buf = ' ';
+
+	char *ptr = buf+1;
+	while ( *ptr == ' ' )
+	    ptr++;
+	ptr[-1] = sign;
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#if 0
+u64 GetXTime ( xtime_t * xtime )
+{
+    struct timeval tval;
+    gettimeofday(&tval,0);
+    if (!time_base)
+	time_base = tval.tv_sec;
+    if (!rel_usec_base)
+	rel_usec_base = (u64)( tval.tv_sec - time_base ) * 1000000 + tval.tv_usec;
+
+    const ull total_usec = 1000000ull * tval.tv_sec + tval.tv_usec;
+
+    if (xtime)
+    {
+	xtime->time       = tval.tv_sec;
+	xtime->usec       = tval.tv_usec;
+	xtime->total_usec = total_usec;
+	xtime->rel_usec   = total_usec - rel_usec_base;
+    }
+    return total_usec;
+}
+#endif
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			scan date & time		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanInterval
+(
+    time_t	*res_time,	// not NULL: store seconds
+    u32		*res_usec,	// not NULL: store micro seconds of second
+    ccp		source		// source text
+)
+{
+    uint days = 0, sec = 0, usec = 0;
+    bool day_possible = true;
+    uint colon_count = 0;
+    char *src = source ? (char*)source : "";
+
+    while ( *src > 0 && *src <= ' ' )
+	src++;
+
+    for(;;)
+    {
+	if ( *src < '0' || *src >='9' )
+	    break;
+	ulong num = strtoul(src,&src,10);
+	if ( *src == 'd' && day_possible )
+	{
+	    src++;
+	    days = num;
+	    day_possible = false;
+	}
+	else if ( *src == ':' && colon_count < 2 )
+	{
+	    src++;
+	    colon_count++;
+	    sec = ( sec + num ) * 60;
+	}
+	else
+	{
+	    sec += num;
+	    if ( *src == '.' )
+	    {
+		src++;
+		uint i;
+		for ( i = 0; i < 6; i++ )
+		{
+		    usec *= 10;
+		    if ( *src >= '0' && *src <= '9' )
+			usec += *src++ - '0';
+		}
+		while ( *src >= '0' && *src <= '9' )
+		    src++;
+	    }
+	    else if ( colon_count == 1 )
+		sec *= 60;
+	}
+    }
+
+    if (res_time)
+	*res_time = days * 86400 + sec;
+    if (res_usec)
+	*res_usec = usec;
+    return src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanInterval64
+(
+    u64		*res_usec,	// not NULL: store total micro seconds
+    ccp		source		// source text
+)
+{
+    time_t time;
+    u32 usec;
+    char *src = ScanInterval(&time,&usec,source);
+    if (res_usec)
+	*res_usec = time * 1000000ull + usec;
+    return src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanDateTime
+(
+    time_t	*res_time,	// not NULL: store seconds here
+    u32		*res_usec,	// not NULL: store useconds of second here
+    ccp		source,		// source text
+    bool	allow_delta	// true: allow +|- interval
+)
+{
+    //--- scan date
+
+    time_t total_time = 0;
+    int total_usec = 0;
+    ccp src = source ? source : "";
+    while ( *src > 0 && *src <= ' ' )
+	src++;
+
+    struct tm tm;
+    memset(&tm,0,sizeof(tm));
+    src = strptime(src,"%Y-%m-%d",&tm);
+
+    noPRINT(" %4u-%02u-%02u %2u:%02u:%02u |%s|\n",
+	tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
+	tm.tm_hour, tm.tm_min, tm.tm_sec, src );
+
+    if (src)
+	total_time = mktime(&tm);
+    else
+	src = source ? source : "";
+    noPRINT_TIME(total_time,"DATE");
+
+
+    //--- scan time
+
+    time_t time;
+    u32 usec;
+    src = ScanInterval(&time,&usec,src);
+    total_time += time;
+    total_usec += usec;
+    noPRINT_TIME(total_time,"TIME");
+
+
+    //--- scan timezone
+
+    ccp src2 = src;
+    while ( *src2 > 0 && *src2 <= ' ' )
+	src2++;
+    if ( ( src2[0] == '-' || src2[0] == '+' )
+	&& src2[1] >= '0' && src2[1] <= '9'
+	&& src2[2] >= '0' && src2[2] <= '9'
+	&& src2[3] >= '0' && src2[3] <= '9'
+	&& src2[4] >= '0' && src2[4] <= '9'
+	&& ( src2[5] < '0' || src2[5] > '9' ))
+    {
+	int delta = 36000 * src2[1]
+		  +  3600 * src2[2]
+		  +   600 * src2[3]
+		  +    60 * src2[4]
+		  - 40260 * '0';
+	if ( src2[0] == '-' )
+	    delta = -delta;
+
+	noPRINT("GOT TIMEZONE: %.5s => %d\n",src2,delta);
+	total_time -= delta + timezone;
+	src = src2 + 5;
+    }
+    else
+    {
+	PRINT("timezone=%ld\n",timezone);
+	struct tm *tm = localtime(&total_time);
+	if (tm->tm_isdst)
+	    total_time -= 3600;
+    }
+    noPRINT_TIME(total_time,"ZONE");
+
+
+    //--- scan delta
+
+    if (allow_delta)
+    {
+	ccp src2 = src;
+	while ( *src2 > 0 && *src2 <= ' ' )
+	    src2++;
+	bool minus = *src2 == '-';
+	if ( minus || *src2 == '+' )
+	{
+	    src = ScanInterval(&time,&usec,src2+1);
+	    if (minus)
+	    {
+		total_time -= time;
+		total_usec -= usec;
+	    }
+	    else
+	    {
+		total_time += time;
+		total_usec += usec;
+	    }
+	}
+    }
+
+    if ( total_usec < 0 )
+    {
+	total_time -= ( 999999 - total_usec ) / 1000000;
+	total_usec  = 1000000 - (-total_usec) % 1000000;
+    }
+    else if ( total_usec >= 1000000 )
+    {
+	total_time += total_usec / 1000000;
+	total_usec %= 1000000;
+    }
+
+    if (res_time)
+	*res_time = total_time;
+    if (res_usec)
+	*res_usec = total_usec;
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanDateTime64
+(
+    u64		*res_usec,	// not NULL: store total micro seconds
+    ccp		source,		// source text
+    bool	allow_delta	// true: allow +|- interval
+)
+{
+    time_t time;
+    u32 usec;
+    char *src = ScanDateTime(&time,&usec,source,allow_delta);
+    if (res_usec)
+	*res_usec = time * 1000000ull + usec;
+    return src;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			Since 2001			///////////////
+///////////////////////////////////////////////////////////////////////////////
+// hour support
+
+ccp hour2text
+(
+	int hour,	// hour to print
+	int fw,		// wanted field width assuming separators are 1 char
+	ccp sep_date,	// NULL or separator within date
+			// if NULL: use '-'
+	ccp sep_dt	// NULL or separator of between date and time
+			// if NULL: use ' '
+)
+{
+    time_t tim = hour2time(hour);
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+
+    if (!sep_date)
+	sep_date = "-";
+
+    if (!sep_dt)
+	sep_dt = " ";
+
+    return fw >= 13
+	? PrintCircBuf("%04d%s%02u%s%02u%s%02u",
+		tm.tm_year + 1900, sep_date,
+		tm.tm_mon  +    1, sep_date,
+		tm.tm_mday, sep_dt,
+		tm.tm_hour
+		)
+	: fw >= 11
+	? PrintCircBuf("%02d%s%02u%s%02u%s%02u",
+		tm.tm_year % 100, sep_date,
+		tm.tm_mon  +   1, sep_date,
+		tm.tm_mday, sep_dt,
+		tm.tm_hour
+		)
+	: fw >= 10
+	? PrintCircBuf("%2u.%s%02u:xx",
+		tm.tm_mday, sep_dt,
+		tm.tm_hour
+		)
+	: PrintCircBuf("%02u%s%02u%s%02u",
+		tm.tm_mon  +   1, sep_date,
+		tm.tm_mday, sep_dt,
+		tm.tm_hour
+		);
+}
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// day support
+
+ccp day2text
+(
+	int day,	// day to print
+	int fw,		// wanted field width assuming separators are 1 char
+	ccp sep_date,	// NULL or separator within date
+			// if NULL: use '-'
+	ccp sep_dt	// ignored
+)
+{
+    time_t tim = day2time(day);
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+
+    if (!sep_date)
+	sep_date = "-";
+
+    return fw >= 10
+	? PrintCircBuf("%04d%s%02u%s%02u",
+		tm.tm_year + 1900, sep_date,
+		tm.tm_mon  +    1, sep_date,
+		tm.tm_mday )
+	: PrintCircBuf("%02d%s%02u%s%02u",
+		tm.tm_year % 100, sep_date,
+		tm.tm_mon  +   1, sep_date,
+		tm.tm_mday );
+}
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// week support
+
+ccp week2text
+(
+	int week,	// week to print
+	int fw,		// wanted field width assuming separators are 1 char
+	ccp sep_date,	// NULL or separator within date
+			// if NULL: use 'w'
+	ccp sep_dt	// ignored
+)
+{
+    time_t tim = week2time(week) + 4*86400;
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+
+    return PrintCircBuf("%04d%s%02u",
+		tm.tm_year + 1900,
+		sep_date ? sep_date : "w",
+		tm.tm_yday / 7 + 1 );
+}
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// month support
+
+int time2month ( time_t tim )
+{
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+    return ( tm.tm_mon + 12 * tm.tm_year ) - 101*12;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+time_t month2time ( int month )
+{
+    SetupTimezone(false);
+    struct tm tm = {0};
+
+    tm.tm_isdst	= -1;
+    tm.tm_year	= month / 12 + 101;
+    tm.tm_mon	= month % 12;
+    tm.tm_mday	= 1;
+
+    int delta = 43200-timezone_adjust_sec;
+    if ( delta < 0 )
+    {
+	delta += 86400;
+	tm.tm_mday++;
+    }
+
+    tm.tm_hour	= delta / 3600;
+    tm.tm_min	= delta / 60 % 60;
+    return mktime(&tm) / 86400 * 86400;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+ccp month2text
+(
+	int month,	// month to print
+	int fw,		// wanted field width assuming separators are 1 char
+	ccp sep_date,	// NULL or separator within date
+			// if NULL: use '-'
+	ccp sep_dt	// ignored
+)
+{
+    month += 2001*12;
+    return PrintCircBuf("%4d%s%02u",
+		month/12,
+		sep_date ? sep_date : "-",
+		month%12 + 1 );
+}
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// quarter support
+
+int time2quarter ( time_t tim )
+{
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+    return ( tm.tm_mon/3 + 4 * tm.tm_year ) - 101*4;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+time_t quarter2time ( int quarter )
+{
+    SetupTimezone(false);
+    struct tm tm = {0};
+
+    tm.tm_isdst	= -1;
+    tm.tm_year	= quarter / 4 + 101;
+    tm.tm_mon	= quarter % 4 * 3;
+    tm.tm_mday	= 1;
+
+    int delta = 43200-timezone_adjust_sec;
+    if ( delta < 0 )
+    {
+	delta += 86400;
+	tm.tm_mday++;
+    }
+
+    tm.tm_hour	= delta / 3600;
+    tm.tm_min	= delta / 60 % 60;
+    return mktime(&tm) / 86400 * 86400;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+ccp quarter2text
+(
+	int quarter,	// quarter to print
+	int fw,		// wanted field width assuming separators are 1 char
+	ccp sep_date,	// NULL or separator within date
+			// if NULL: use 'q'
+	ccp sep_dt	// ignored
+)
+{
+    quarter += 2001*4;
+    return PrintCircBuf("%4d%s%u",
+		quarter/4,
+		sep_date ? sep_date : "q",
+		quarter%4 + 1 );
+}
+
+///////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// year support
+
+int time2year ( time_t tim )
+{
+    struct tm tm;
+    gmtime_r(&tim,&tm);
+    return tm.tm_year + 1900;
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+time_t year2time ( int year )
+{
+    SetupTimezone(false);
+    struct tm tm = {0};
+
+    tm.tm_isdst	= -1;
+    tm.tm_year	= year - 1900;
+    tm.tm_mday	= 1;
+
+    int delta = 43200-timezone_adjust_sec;
+    if ( delta < 0 )
+    {
+	delta += 86400;
+	tm.tm_mday++;
+    }
+
+    tm.tm_hour	= delta / 3600;
+    tm.tm_min	= delta / 60 % 60;
+    return mktime(&tm) / 86400 * 86400;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			urandom support			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+int urandom_available = 0; // <0:not, =0:not tested, >0:ok
+bool use_urandom_for_myrandom = true;
+
+uint ReadFromUrandom ( void *dest, uint size )
+{
+    static int fd = -1;
+
+    if ( fd == -1 )
+    {
+	if ( urandom_available < 0 )
+	    return 0;
+     #ifdef O_CLOEXEC
+	fd = open("/dev/urandom",O_CLOEXEC|O_NONBLOCK);
+     #else
+	fd = open("/dev/urandom",O_NONBLOCK);
+     #endif
+	if ( fd == -1 )
+	{
+	    urandom_available = -1;
+	    return 0;
+	}
+     #ifndef O_CLOEXEC
+	fcntl(fd,F_SETFD,FD_CLOEXEC);
+     #endif
+	urandom_available = 1;
+    }
+
+    u8 *buf = dest;
+    while ( size > 0 )
+    {
+	ssize_t stat = read(fd,buf,size);
+	if ( stat < 0 )
+	{
+	    urandom_available = -1;
+	    close(fd);
+	    return 0;
+	}
+	buf  += stat;
+	size -= stat;
+    }
+
+    return buf - (u8*)dest;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			random numbers			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+//------------------------------------------------------------------
+// Algorithm: The Art of Computer Programming, part II, section 3.6
+// by Donald E. Knuth
+//------------------------------------------------------------------
+
+const u32 RANDOM32_C_ADD = 2 * 197731421; // 2 Primzahlen
+const u32 RANDOM32_COUNT_BASE = 4294967; // Primzahl == ~UINT_MAX32/1000;
+
+static int random32_a_index = -1;	// Index in die a-Tabelle
+static u32 random32_count = 1;		// Abwärts-Zähler bis zum Wechsel von a,c
+static u32 random32_a,
+	   random32_c,
+	   random32_X;			// Die letzten Werte
+
+static u32 random32_a_tab[] = // Init-Tabelle
+{
+    0xbb40e62d, 0x3dc8f2f5, 0xdc024635, 0x7a5b6c8d,
+    0x583feb95, 0x91e06dbd, 0xa7ec03f5, 0
+};
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u32 MyRandom ( u32 max )
+{
+    if (use_urandom_for_myrandom)
+    {
+	u32 res32;
+	if (ReadFromUrandom(&res32,sizeof(res32)))
+	{
+	    if (!max)
+		return res32;
+
+	    u64 res64 = (u64)max * res32;
+	    return res64 >> 32;
+	}
+	use_urandom_for_myrandom = false;
+    }
+
+    if (!--random32_count)
+    {
+	// Neue Berechnung von random32_a und random32_c fällig
+
+	if ( random32_a_index < 0 )
+	{
+	    // allererste Initialisierung auf Zeitbasis
+
+	    MySeedByTime();
+	}
+	else
+	{
+	    random32_c += RANDOM32_C_ADD;
+	    random32_a = random32_a_tab[++random32_a_index];
+	    if (!random32_a)
+	    {
+		random32_a_index = 0;
+		random32_a = random32_a_tab[0];
+	    }
+
+	    random32_count = RANDOM32_COUNT_BASE;
+	}
+    }
+
+    // Jetzt erfolgt die eigentliche Berechnung
+
+    random32_X = random32_a * random32_X + random32_c;
+
+    if (!max)
+	return random32_X;
+
+    u64 res = (u64)max * random32_X;
+    return res >> 32;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 MySeed ( u64 base )
+{
+    uint a_tab_len = 0;
+    while (random32_a_tab[a_tab_len])
+	a_tab_len++;
+    const u32 base32 = base / a_tab_len;
+
+    random32_a_index	= (int)( base % a_tab_len );
+    random32_a		= random32_a_tab[random32_a_index];
+    random32_c		= ( base32 & 15 ) * RANDOM32_C_ADD + 1;
+    random32_X		= base32 ^ ( base >> 32 );
+    random32_count	= RANDOM32_COUNT_BASE;
+
+    return base;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 MySeedByTime()
+{
+ #if WIN_SZS_LIB
+
+    u64 time;
+    QueryPerformanceCounter((LARGE_INTEGER*)&time);
+    return MySeed(time);
+
+ #else
+
+    struct timeval tval;
+    gettimeofday(&tval,NULL);
+    return MySeed( tval.tv_sec ^ tval.tv_usec );
+
+ #endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+void MyRandomFill ( void * buf, size_t size )
+{
+    size_t xsize = size / sizeof(u32);
+    if (xsize)
+    {
+	size -= xsize * sizeof(u32);
+	u32 * ptr = buf;
+	while ( xsize-- > 0 )
+	    *ptr++ = MyRandom(0);
+	buf = ptr;
+    }
+
+    u8 * ptr = buf;
+    while ( size-- > 0 )
+	*ptr++ = MyRandom(0);
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			UUID				///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void CreateUUID ( uuid_buf_t dest )
+{
+    DASSERT(dest);
+    const uint stat = ReadFromUrandom(dest,sizeof(uuid_buf_t));
+    if (!stat)
+	MyRandomFill(dest,sizeof(uuid_buf_t));
+
+    dest[6] = dest[6] & 0x0f | 0x40;
+    dest[8] = dest[8] & 0x3f | 0x80;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint CreateTextUUID ( char *buf, uint bufsize )
+{
+    uuid_buf_t uuid;
+    CreateUUID(uuid);
+    return PrintUUID(buf,bufsize,uuid);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint PrintUUID ( char *buf, uint bufsize, uuid_buf_t uuid )
+{
+    return snprintf(buf,bufsize,
+	"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+	uuid[0],uuid[1],uuid[2],uuid[3],
+	uuid[4],uuid[5], uuid[6],uuid[7],  uuid[8],uuid[9],
+	uuid[10],uuid[11],uuid[12],uuid[13],uuid[14],uuid[15] );
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanUUID ( uuid_buf_t uuid, ccp source )
+{
+    memset(uuid,0,sizeof(uuid_buf_t));
+
+    uint i;
+    ccp src = source;
+    for ( i = 0; i < sizeof(uuid_buf_t); i++ )
+    {
+	if ( *src == '-' )
+	    src++;
+
+	uint num;
+	ccp end = ScanNumber(&num,src,0,16,2);
+	if ( end != src+2 )
+	    return (char*)source;
+	uuid[i] = num;
+	src = end;
+    }
+    return (char*)src;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			gcd(), lcm()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint gcd ( uint n1, uint n2 ) // greatest common divisor, german: ggt
+{
+    if ( !n1 || !n2 )
+	return 0;
+
+    if ( n1 > n2 )
+    {
+	uint temp = n1;
+	n1 = n2;
+	n2 = temp;
+    }
+
+    while ( n1 != 1 )
+    {
+	DASSERT ( n1 > 1 );
+	DASSERT ( n2 >= n1 );
+
+	uint temp = n2 % n1;
+	if ( !temp )
+	    break;
+	n2 = n1;
+	n1 = temp;
+    }
+    return n1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 gcd32 ( u32 n1, u32 n2 ) // greatest common divisor, german: ggt
+{
+    if ( !n1 || !n2 )
+	return 0;
+
+    if ( n1 > n2 )
+    {
+	u32 temp = n1;
+	n1 = n2;
+	n2 = temp;
+    }
+
+    while ( n1 != 1 )
+    {
+	DASSERT ( n1 > 1 );
+	DASSERT ( n2 > n1 );
+
+	u32 temp = n2 % n1;
+	if ( !temp )
+	    break;
+	n2 = n1;
+	n1 = temp;
+    }
+    return n1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 gcd64 ( u64 n1, u64 n2 ) // greatest common divisor, german: ggt
+{
+    if ( !n1 || !n2 )
+	return 0;
+
+    if ( n1 > n2 )
+    {
+	u64 temp = n1;
+	n1 = n2;
+	n2 = temp;
+    }
+
+    while ( n1 != 1 )
+    {
+	DASSERT ( n1 > 1 );
+	DASSERT ( n2 > n1 );
+
+	u64 temp = n2 % n1;
+	if ( !temp )
+	    break;
+	n2 = n1;
+	n1 = temp;
+    }
+    return n1;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+uint lcm ( uint n1, uint n2 ) // lowest common multiple, german: kgv
+{
+    uint g = gcd(n1,n2);
+    if ( g > 0 )
+    {
+	n1 /= g;
+	g = n1 * n2;
+	if ( g < n1 || g < n2 ) // overflow?
+	    g = 0;
+    }
+    return g;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u32 lcm32 ( u32 n1, u32 n2 ) // lowest common multiple, german: kgv
+{
+    u32 g = gcd32(n1,n2);
+    if ( g > 0 )
+    {
+	n1 /= g;
+	g = n1 * n2;
+	if ( g < n1 || g < n2 ) // overflow?
+	    g = 0;
+    }
+    return g;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 lcm64 ( u64 n1, u64 n2 ) // lowest common multiple, german: kgv
+{
+    u64 g = gcd64(n1,n2);
+    if ( g > 0 )
+    {
+	n1 /= g;
+	g = n1 * n2;
+	if ( g < n1 || g < n2 ) // overflow?
+	    g = 0;
+    }
+    return g;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    scan number			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+#define NN NUMBER_NULL
+#define NC NUMBER_CONTROL
+#define NL NUMBER_LINE
+#define NS NUMBER_SPACE
+#define NT NUMBER_TIE
+#define NP NUMBER_SEPARATE
+#define NX NUMBER_OTHER
+
+const char DigitTable[] =
+{
+    NN, NC, NC, NC,  NC, NC, NC, NC,  NC, NS, NL, NC,  NS, NL, NC, NC,
+    NC, NC, NC, NC,  NC, NC, NC, NC,  NC, NC, NC, NC,  NC, NC, NC, NC,
+    NS, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NP, NT, NT, NX,	//  !"#$%&' ()*+,-./
+     0,  1,  2,  3,   4,  5,  6,  7,   8,  9, NT, NP,  NX, NX, NX, NX,	// 01234567 89:;<=>?
+
+    NX, 10, 11, 12,  13, 14, 15, 16,  17, 18, 19, 20,  21, 22, 23, 24,	// @ABCDEFG HIJKLMNO
+    25, 26, 27, 28,  29, 30, 31, 32,  33, 34, 35, NX,  NX, NX, NX, NX,	// PQRSTUVW XYZ[\]^_
+    NX, 10, 11, 12,  13, 14, 15, 16,  17, 18, 19, 20,  21, 22, 23, 24,	// `abcdefg hijklmno
+    25, 26, 27, 28,  29, 30, 31, 32,  33, 34, 35, NX,  NX, NX, NX, NX,	// pqrstuvw xyz{|}~
+
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+    NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,  NX, NX, NX, NX,
+};
+
+#undef NN
+#undef NC
+#undef NL
+#undef NS
+#undef NT
+#undef NP
+#undef NX
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 ScanDigits
+(
+    // same as ScanNumber(), but other interface
+    // returns the scanned number
+
+    ccp	  *source,	// pointer to source string, modified
+    ccp	  end_source,	// NULL or end of 'source'
+    uint  intbase,	// integer base, 2..36
+    int	  maxchar,	// max number of digits to read
+    uint  *count	// not NULL: store number of scanned digits here
+)
+{
+    DASSERT(source);
+    DASSERT( intbase >= 2 && intbase <= 36 );
+
+    ccp src = *source;
+    u64 num = 0;
+    while ( maxchar-- && ( !end_source || src < end_source ) )
+    {
+	const u8 digit = (u8)DigitTable[(u8)*src];
+	if ( digit >= intbase )
+	    break;
+	num = num * intbase + digit;
+	src++;
+    }
+    if (count)
+	*count = src - *source;
+    *source = src;
+    return num;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanNumber
+(
+    // same as ScanDigits(), but other interface
+    // returns a pointer to the first not used character
+
+    uint  *dest_num,	// store result here, never NULL
+    ccp	  src,		// pointer to source string, modified
+    ccp	  src_end,	// NULL or end of 'src'
+    uint  intbase,	// integer base, 2..36
+    int	  maxchar	// max number of digits to read
+)
+{
+    DASSERT(dest_num);
+    uint num = 0;
+    if (src)
+    {
+	while ( maxchar-- && ( !src_end || src < src_end ) )
+	{
+	    const uint n = (uint)DigitTable[*(uchar*)src];
+	    if ( n >= (uint)intbase )
+		break;
+	    num = num * intbase + n;
+	    src++;
+	}
+    }
+    *dest_num = num;
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanEscape
+(
+    // returns a pointer to the first not used character
+
+    uint  *dest_code,	// store result here, never NULL
+    ccp	  src,		// pointer to source string (behind escape char)
+    ccp	  src_end	// NULL or end of 'src'
+)
+{
+    DASSERT(dest_code);
+    DASSERT(src);
+    if ( !src || ( src_end ? src >= src_end : !*src ) )
+    {
+	*dest_code = 0;
+	return (char*)src;
+    }
+
+    uint code = 0;
+    switch (*src++)
+    {
+	case '\\': code = '\\'; break;
+	case 'a':  code = '\a'; break;
+	case 'b':  code = '\b'; break;
+	case 'E':
+	case 'e':  code = '\e'; break;
+	case 'f':  code = '\f'; break;
+	case 'n':  code = '\n'; break;
+	case 'r':  code = '\r'; break;
+	case 't':  code = '\t'; break;
+	case 'v':  code = '\v'; break;
+
+	case 'x':
+	    src = ScanNumber(&code,src,src_end,16,2);
+	    break;
+
+	case 'u':
+	    src = ScanNumber(&code,src,src_end,16,4);
+	    break;
+
+	case 'U':
+	    src = ScanNumber(&code,src,src_end,16,8);
+	    break;
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	    src = ScanNumber(&code,src-1,src_end,8,3);
+	    break;
+
+	default:
+	    code = src[-1];
+	    break;
+    }
+
+    *dest_code = code;
+    return (char*)src;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+uint ScanHexString
+(
+    // return the number of written bytes
+
+    void  *buf,		// write scanned data here
+    uint  buf_size,	// size of buf
+    ccp	  *source,	// pointer to source string, modified
+    ccp	  end_source,	// NULL or end of 'source'
+    bool  allow_tie	// allow chars ' .:-' and TAB,VT as byte separator
+)
+{
+    DASSERT(buf);
+    DASSERT(source);
+
+    u8 *dest = buf;
+    uint count = 0;
+    while ( count < buf_size )
+    {
+	ccp src = *source;
+	if (allow_tie)
+	{
+	    while ( !end_source || src < end_source )
+	    {
+		const char res = DigitTable[(u8)*src];
+		if ( res != NUMBER_SPACE && res != NUMBER_TIE )
+		    break;
+		src++;
+	    }
+	    *source = src;
+	}
+
+	while ( !end_source || src < end_source )
+	{
+	    const char res = DigitTable[(u8)*src];
+	    if ( res < 0 || res >= 16 )
+		break;
+	    src++;
+	}
+
+	uint n_digits = src - *source;
+	if (!n_digits)
+	    break;
+
+	while ( n_digits > 0 )
+	{
+	    uint scanned;
+	    uint num = ScanDigits( source, end_source, 16,
+					n_digits & 1 ? 1 : 2, &scanned );
+	    if (!scanned)
+		return count;
+
+	    n_digits -= scanned;
+	    *dest++ = num;
+	    count++;
+	}
+    }
+
+    return count;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanS32
+(
+    // return 'source' on error
+
+    s32		*res_num,		// not NULL: store result (only on success)
+    ccp		source,			// NULL or source text
+    uint	default_base		// base for numbers without '0x' prefix
+					//  0: C like with octal support
+					// 10: standard value for decimal numbers
+					// 16: standard value for hex numbers
+)
+{
+    if (!source)
+	return 0;
+
+    ccp src = source;
+    while ( *src > 0 && *src <= ' ' )
+	src++;
+
+    const bool minus = *src == '-';
+    if ( minus || *src == '+' )
+    {
+	src++;
+	while ( *src > 0 && *src <= ' ' )
+	    src++;
+    }
+    const uint base = src[0] == '0' && ( src[1] == 'x' || src[1] == 'X' )
+			? 16 : default_base;
+    char *end;
+    const s32 num = strtoul( src, &end, base );
+    if ( (ccp)end > src )
+    {
+	if (res_num)
+	    *res_num = minus ? -num : num;
+	return end;
+    }
+
+    return (char*)source;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanS64
+(
+    // return 'source' on error
+
+    s64		*res_num,		// not NULL: store result (only on success)
+    ccp		source,			// NULL or source text
+    uint	default_base		// base for numbers without '0x' prefix
+					//  0: C like with octal support
+					// 10: standard value for decimal numbers
+					// 16: standard value for hex numbers
+)
+{
+    if (!source)
+	return 0;
+
+    ccp src = source;
+    while ( *src > 0 && *src <= ' ' )
+	src++;
+
+    const bool minus = *src == '-';
+    if ( minus || *src == '+' )
+    {
+	src++;
+	while ( *src > 0 && *src <= ' ' )
+	    src++;
+    }
+    const uint base = src[0] == '0' && ( src[1] == 'x' || src[1] == 'X' )
+			? 16 : default_base;
+    char *end;
+    const s64 num = strtoull( src, &end, base );
+    if ( (ccp)end > src )
+    {
+	if (res_num)
+	    *res_num = minus ? -num : num;
+	return end;
+    }
+
+    return (char*)source;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// strto*() replacements, base ion Scan*() with better base support
+
+long int str2l ( const char *nptr, char **endptr, int base )
+{
+    s32 res = 0;
+    char *end = ScanS32(&res,nptr,base);
+    if (endptr)
+	*endptr = end;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+long long int str2ll ( const char *nptr, char **endptr, int base )
+{
+    s64 res = 0;
+    char *end = ScanS64(&res,nptr,base);
+    if (endptr)
+	*endptr = end;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned long int str2ul ( const char *nptr, char **endptr, int base )
+{
+    u32 res = 0;
+    char *end = ScanU32(&res,nptr,base);
+    if (endptr)
+	*endptr = end;
+    return res;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+unsigned long long int str2ull ( const char *nptr, char **endptr, int base )
+{
+    u64 res = 0;
+    char *end = ScanU64(&res,nptr,base);
+    if (endptr)
+	*endptr = end;
+    return res;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////		round float/double (zero LSB)		///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+float RoundF2bytes ( float f )
+{
+    union { float f; u32 u; } x;
+    x.f = f;
+    if ( x.u & 0x8000 )
+    {
+	x.u &= 0xffff0000;
+	int exp;
+	const float frac = frexpf(x.f,&exp);
+	x.f = ldexpf(frac+0.00585938,exp);
+    }
+
+    x.u &= 0xffff0000;
+    return x.f;
+}
+
+//-----------------------------------------------------------------------------
+
+float RoundF3bytes ( float f )
+{
+    union { float f; u32 u; } x;
+    x.f = f;
+    if ( x.u & 0x80 )
+    {
+	x.u &= 0xffffff00;
+	int exp;
+	const float frac = frexpf(x.f,&exp);
+	x.f = ldexpf(frac+0.00002289,exp);
+    }
+
+    x.u &= 0xffffff00;
+    return x.f;
+}
+
+//-----------------------------------------------------------------------------
+
+double RoundD6bytes ( double d )
+{
+    union { double d; u64 u; } x;
+    x.d = d;
+    if ( x.u & 0x8000 )
+    {
+	x.u &= 0xffffffffffff0000ull;
+	int exp;
+	const double frac = frexp(x.d,&exp);
+	x.d = ldexp(frac+0.000000000010913936,exp);
+    }
+
+    x.u &= 0xffffffffffff0000ull;
+    return x.d;
+}
+
+//-----------------------------------------------------------------------------
+
+double RoundD7bytes ( double d )
+{
+    union { double d; u64 u; } x;
+    x.d = d;
+    if ( x.u & 0x80 )
+    {
+	x.u &= 0xffffffffffffff00ull;
+	int exp;
+	const double frac = frexp(x.d,&exp);
+	x.d = ldexp(frac+0.000000000000042633,exp);
+    }
+
+    x.u &= 0xffffffffffffff00ull;
+    return x.d;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			print number			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberU4
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 5 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num < 1000000000 ) // 1e9
+    {
+	u32 n32 = num;
+	if ( !n32 && mode & DC_SFORM_DASH )
+	    StringCopyS(buf,buf_size, aligned ? "   -" : "-" );
+	else if ( n32 < 10000 )
+	    snprintf(buf,buf_size, aligned ? "%4u" : "%u", n32 );
+	else if ( n32 < 1000000 )
+	    snprintf(buf,buf_size, aligned ? "%3uk" : "%uk", n32/1000 );
+	else if ( n32 < 10000000 )
+	{
+	    n32 /= 100000;
+	    snprintf(buf,buf_size,"%u.%uM", n32/10, n32%10 );
+	}
+	else
+	    snprintf(buf,buf_size, aligned ? "%3uM" : "%uM", n32/1000000 );
+    }
+    else
+    {
+	u32 n32;
+	ccp factor = "GTPE";
+	if ( num < 1000000000000000ull ) // 1e15
+	    n32 = num / 100000000; // 1e8
+	else
+	{
+	    factor += 2;
+	    n32 = num / 100000000000000ull; // 1e14
+	}
+
+	while (*factor)
+	{
+	    if ( n32 < 100 )
+	    {
+		snprintf(buf,buf_size,"%u.%u%c", n32/10, n32%10, *factor );
+		break;
+	    }
+	    else if ( n32 < 10000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%3u%c" : "%u%c", n32/10, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberU5
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 6 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num < 1000000000 ) // 1e9
+    {
+	u32 n32 = num;
+	if ( !n32 && mode & DC_SFORM_DASH )
+	    StringCopyS(buf,buf_size, aligned ? "    -" : "-" );
+	else if ( n32 < 100000 )
+	    snprintf(buf,buf_size, aligned ? "%5u" : "%u", n32 );
+	else if ( n32 < 10000000 )
+	    snprintf(buf,buf_size, aligned ? "%4uk" : "%uk", n32/1000 );
+	else
+	    snprintf(buf,buf_size, aligned ? "%4uM" : "%uM", n32/1000000 );
+    }
+    else
+    {
+	u32 n32;
+	ccp factor = "MGTPE";
+	if ( num < 1000000000000000ull ) // 1e15
+	    n32 = num / 1000000; // 1e6
+	else
+	{
+	    factor += 2;
+	    n32 = num / 1000000000000ull; // 1e12
+	}
+
+	while (*factor)
+	{
+	    if ( n32 < 10000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%4u%c" : "%u%c", n32, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberU6
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 7 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num < 1000000000 ) // 1e9
+    {
+	u32 n32 = num;
+	if ( !n32 && mode & DC_SFORM_DASH )
+	    StringCopyS(buf,buf_size, aligned ? "     -" : "-" );
+	else if ( n32 < 1000000 )
+	    snprintf(buf,buf_size, aligned ? "%6u" : "%u", n32 );
+	else if ( n32 < 100000000 )
+	    snprintf(buf,buf_size, aligned ? "%5uk" : "%uk", n32/1000 );
+	else
+	    snprintf(buf,buf_size, aligned ? "%5uM" : "%uM", n32/1000000 );
+    }
+    else
+    {
+	u32 n32;
+	ccp factor = "MGTPE";
+	if ( num < 1000000000000000ull ) // 1e15
+	    n32 = num / 1000000; // 1e6
+	else
+	{
+	    factor += 2;
+	    n32 = num / 1000000000000ull; // 1e12
+	}
+
+	while (*factor)
+	{
+	    if ( n32 < 100000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%5u%c" : "%u%c", n32, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberU7
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 8 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num < 1000000000 ) // 1e9
+    {
+	u32 n32 = num;
+	if ( !n32 && mode & DC_SFORM_DASH )
+	    StringCopyS(buf,buf_size, aligned ? "      -" : "-" );
+	else if ( n32 < 10000000 )
+	    snprintf(buf,buf_size, aligned ? "%7u" : "%u", n32 );
+	else
+	    snprintf(buf,buf_size, aligned ? "%6uk" : "%uk", n32/1000 );
+    }
+    else
+    {
+	u32 n32;
+	ccp factor = "MGTPE";
+	if ( num < 1000000000000000ull ) // 1e15
+	    n32 = num / 1000000; // 1e6
+	else
+	{
+	    factor += 2;
+	    n32 = num / 1000000000000ull; // 1e12
+	}
+
+	while (*factor)
+	{
+	    if ( n32 < 1000000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%6u%c" : "%u%c", n32, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberS5
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if ( num >= 0 )
+	return PrintNumberU5(buf,buf_size,num,mode);
+
+    if (!buf)
+	buf = GetCircBuf( buf_size = 6 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num > -1000000000 ) // -1e9
+    {
+	s32 n32 = num;
+	if ( n32 > -10000 )
+	    snprintf(buf,buf_size, aligned ? "%5d" : "%d", n32 );
+	else if ( n32 > -1000000 )
+	    snprintf(buf,buf_size, aligned ? "%4dk" : "%dk", n32/1000 );
+	else if ( n32 > -10000000 )
+	{
+	    n32 /= -100000;
+	    snprintf(buf,buf_size,"-%u.%uM", n32/10, n32%10 );
+	}
+	else
+	    snprintf(buf,buf_size, aligned ? "%4dM" : "%dM", n32/1000000 );
+    }
+    else
+    {
+	s32 n32;
+	ccp factor = "GTPE";
+	if ( num > -1000000000000000ull ) // -1e15
+	    n32 = num / 100000000; // -1e8
+	else
+	{
+	    factor += 2;
+	    n32 = num / 100000000000000ull; // -1e14
+	}
+
+	while (*factor)
+	{
+	    if ( n32 > -100 )
+	    {
+		snprintf(buf,buf_size,"-%u.%u%c", -n32/10, -n32%10, *factor );
+		break;
+	    }
+	    else if ( n32 > -10000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%4d%c" : "%d%c", n32/10, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberS6
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if ( num >= 0 )
+	return PrintNumberU6(buf,buf_size,num,mode);
+
+    if (!buf)
+	buf = GetCircBuf( buf_size = 7 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num > -1000000000 ) // -1e9
+    {
+	s32 n32 = num;
+	if ( n32 > -100000 )
+	    snprintf(buf,buf_size, aligned ? "%6d" : "%d", n32 );
+	else if ( n32 > -10000000 )
+	    snprintf(buf,buf_size, aligned ? "%5dk" : "%dk", n32/1000 );
+	else
+	    snprintf(buf,buf_size, aligned ? "%5dM" : "%dM", n32/1000000 );
+    }
+    else
+    {
+	s32 n32;
+	ccp factor = "MGTPE";
+	if ( num > -1000000000000000ull ) // -1e15
+	    n32 = num / 1000000; // -1e6
+	else
+	{
+	    factor += 2;
+	    n32 = num / 1000000000000ull; // -1e12
+	}
+
+	while (*factor)
+	{
+	    if ( n32 > -10000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%5d%c" : "%d%c", n32, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberS7
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    s64			num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN, DC_SFORM_DASH
+)
+{
+    if ( num >= 0 )
+	return PrintNumberU7(buf,buf_size,num,mode);
+
+    if (!buf)
+	buf = GetCircBuf( buf_size = 8 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    if ( num > -100000000 ) // -1e8
+    {
+	s32 n32 = num;
+	if ( n32 > -1000000 )
+	    snprintf(buf,buf_size, aligned ? "%7d" : "%d", n32 );
+	else
+	    snprintf(buf,buf_size, aligned ? "%6dk" : "%dk", n32/1000 );
+    }
+    else
+    {
+	s32 n32;
+	ccp factor = "MGTPE";
+	if ( num > -1000000000000000ull ) // -1e15
+	    n32 = num / 1000000; // -1e6
+	else
+	{
+	    factor += 2;
+	    n32 = num / 1000000000000ull; // -1e12
+	}
+
+	while (*factor)
+	{
+	    if ( n32 > -100000 )
+	    {
+		snprintf(buf,buf_size, aligned ? "%6d%c" : "%d%c", n32, *factor );
+		break;
+	    }
+	    n32 /= 1000;
+	    factor++;
+	}
+    }
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberD5
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    double		num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 16 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    double abs = fabs(num);
+    if ( abs >= 1e2 )
+    {
+	if ( num <= 0 )
+	{
+	    if ( abs <= S64_MAX )
+		return PrintNumberS5(buf,buf_size,double2int64(num),mode);
+	    return "-****";
+	}
+	else
+	{
+	    if ( abs <= U64_MAX )
+		return PrintNumberU5(buf,buf_size,double2int64(num),mode);
+	}
+	snprintf(buf,buf_size,"%5.0e",num);
+	return buf;
+    }
+
+    if ( num < 0.0 )
+    {
+	if ( abs < 1e-2 )
+	    return aligned ? "   -0" : "-0";
+
+	if ( abs < 10.0 )
+	    snprintf(buf,buf_size,"%5.2f",num);
+	else
+	    snprintf(buf,buf_size,"%5.1f",num);
+    }
+    else
+    {
+	if ( num < 1e-3 )
+	    return aligned ? "    0" : "0";
+
+	if ( num < 10.0 )
+	    snprintf(buf,buf_size,"%5.3f",num);
+	else
+	    snprintf(buf,buf_size,"%5.2f",num);
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberD6
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    double		num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 7 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    double abs = fabs(num);
+    if ( abs >= 1e3 )
+    {
+	if ( num <= 0 )
+	{
+	    if ( abs <= S64_MAX )
+		return PrintNumberS6(buf,buf_size,double2int64(num),mode);
+	}
+	else
+	{
+	    if ( abs <= U64_MAX )
+		return PrintNumberU6(buf,buf_size,double2int64(num),mode);
+	}
+	snprintf(buf,buf_size,"%6.0e",num);
+	return buf;
+    }
+
+    if ( num < 0.0 )
+    {
+	if ( abs < 1e-3 )
+	    return aligned ? "    -0" : "-0";
+
+	if ( abs < 10.0 )
+	    snprintf(buf,buf_size,"%6.3f",num);
+	else if ( abs < 100.0 )
+	    snprintf(buf,buf_size,"%6.2f",num);
+	else
+	    snprintf(buf,buf_size,"%6.1f",num);
+    }
+    else
+    {
+	if ( num < 1e-4 )
+	    return aligned ? "     0" : "0";
+
+	if ( num < 10.0 )
+	    snprintf(buf,buf_size,"%6.4f",num);
+	else if ( num < 100.0 )
+	    snprintf(buf,buf_size,"%6.3f",num);
+	else
+	    snprintf(buf,buf_size,"%6.2f",num);
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintNumberD7
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    double		num,		// number to print
+    sizeform_mode_t	mode		// any of DC_SFORM_ALIGN
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 18 );
+    const sizeform_mode_t aligned = mode & DC_SFORM_ALIGN;
+
+    double abs = fabs(num);
+    if ( abs >= 1e4 )
+    {
+	if ( num <= 0 )
+	{
+	    if ( abs <= S64_MAX )
+		return PrintNumberS7(buf,buf_size,double2int64(num),mode);
+	    snprintf(buf,buf_size,"%7.0e",num);
+	    return buf;
+	}
+	else
+	{
+	    if ( abs <= U64_MAX )
+		return PrintNumberU7(buf,buf_size,double2int64(num),mode);
+	}
+	snprintf(buf,buf_size,"%7.1e",num);
+	return buf;
+    }
+
+    if ( num < 0.0 )
+    {
+	if ( abs < 1e-4 )
+	    return aligned ? "     -0" : "-0";
+
+	if ( abs < 10.0 )
+	    snprintf(buf,buf_size,"%7.4f",num);
+	else if ( abs < 100.0 )
+	    snprintf(buf,buf_size,"%7.3f",num);
+	else if ( abs < 1000.0 )
+	    snprintf(buf,buf_size,"%7.2f",num);
+	else
+	    snprintf(buf,buf_size,"%7.1f",num);
+    }
+    else
+    {
+	if ( num < 1e-5 )
+	    return aligned ? "      0" : "0";
+
+	if ( num < 10.0 )
+	    snprintf(buf,buf_size,"%7.5f",num);
+	else if ( num < 100.0 )
+	    snprintf(buf,buf_size,"%7.4f",num);
+	else if ( num < 1000.0 )
+	    snprintf(buf,buf_size,"%7.3f",num);
+	else
+	    snprintf(buf,buf_size,"%7.2f",num);
+    }
+
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			print size			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp dc_size_tab_1000[DC_SIZE_N_MODES+1] =
+{
+    0,		// DC_SIZE_DEFAULT
+    0,		// DC_SIZE_AUTO
+
+    "B",	// DC_SIZE_BYTES
+    "kB",	// DC_SIZE_K
+    "MB",	// DC_SIZE_M
+    "GB",	// DC_SIZE_G
+    "TB",	// DC_SIZE_T
+    "PB",	// DC_SIZE_P
+    "EB",	// DC_SIZE_E
+
+    0		// all others
+};
+
+//-----------------------------------------------------------------------------
+
+ccp dc_size_tab_1024[DC_SIZE_N_MODES+1] =
+{
+    0,		// DC_SIZE_DEFAULT
+    0,		// DC_SIZE_AUTO
+
+    "B",	// DC_SIZE_BYTES
+    "KiB",	// DC_SIZE_K
+    "MiB",	// DC_SIZE_M
+    "GiB",	// DC_SIZE_G
+    "TiB",	// DC_SIZE_T
+    "PiB",	// DC_SIZE_P
+    "EiB",	// DC_SIZE_E
+
+    0		// all others
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+ccp GetSizeUnit // get a unit for column headers
+(
+    size_mode_t	mode,		// print mode
+    ccp		if_invalid	// output for invalid modes
+)
+{
+    const bool force_1000 = ( mode & DC_SIZE_M_BASE ) == DC_SIZE_F_1000;
+
+    switch ( mode & DC_SIZE_M_MODE )
+    {
+	//---- SI and IEC units
+
+	case DC_SIZE_DEFAULT:
+	case DC_SIZE_AUTO:	return "size";
+	case DC_SIZE_BYTES:	return "bytes";
+
+	case DC_SIZE_K:		return force_1000 ? "kB" : "KiB";
+	case DC_SIZE_M:		return force_1000 ? "MB" : "MiB";
+	case DC_SIZE_G:		return force_1000 ? "GB" : "GiB";
+	case DC_SIZE_T:		return force_1000 ? "TB" : "TiB";
+	case DC_SIZE_P:		return force_1000 ? "PB" : "PiB";
+	case DC_SIZE_E:		return force_1000 ? "EB" : "EiB";
+    }
+
+    return if_invalid;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+int GetSizeFW // get a good value field width
+(
+    size_mode_t	mode,		// print mode
+    int		min_fw		// minimum fw => return max(calc_fw,min_fw);
+				// this value is also returned for invalid modes
+)
+{
+    int fw = mode & (DC_SIZE_F_AUTO_UNIT|DC_SIZE_F_NO_UNIT) ? 0 : 4;
+
+    switch ( mode & DC_SIZE_M_MODE )
+    {
+	case DC_SIZE_DEFAULT:
+	case DC_SIZE_AUTO:
+	    if ( !(mode & DC_SIZE_F_NO_UNIT) )
+		fw = 4;
+	    fw += 4;
+	    break;
+
+	case DC_SIZE_BYTES:	fw += 10; break;
+	case DC_SIZE_K:		fw +=  7; break;
+	case DC_SIZE_M:		fw +=  4; break;
+	case DC_SIZE_G:		fw +=  3; break;
+	case DC_SIZE_T:		fw +=  3; break;
+	case DC_SIZE_P:		fw +=  3; break;
+	case DC_SIZE_E:		fw +=  3; break;
+
+	default:		fw = min_fw;
+    }
+
+    return fw > min_fw ? fw : min_fw;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// [[PrintSize]]
+
+char * PrintSize
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			size,		// size to print
+    sizeform_mode_t	sform_mode,	// output format, bit field
+    size_mode_t		mode		// print mode
+)
+{
+    DASSERT( DC_SIZE_N_MODES <= DC_SIZE_M_MODE + 1 );
+
+
+    if (!buf)
+	buf = GetCircBuf( buf_size = 20 );
+
+    const bool force_1000 = ( mode & DC_SIZE_M_BASE ) == DC_SIZE_F_1000;
+
+    // ??? [[2do]] follow 'sform_mode'
+    const sizeform_mode_t aligned = sform_mode & DC_SFORM_ALIGN;
+
+    switch ( mode & DC_SIZE_M_MODE )
+    {
+	//---- SI and IEC units
+
+	case DC_SIZE_BYTES:
+	    snprintf(buf,buf_size, aligned ? "%6llu B" : "%llu B", size );
+	    break;
+
+	case DC_SIZE_K:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu kB" : "%llu kB",
+			( size + KB_SI/2 ) / KB_SI );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu KiB" : "%llu KiB",
+			( size + KiB/2 ) / KiB );
+	    break;
+
+	case DC_SIZE_M:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu MB" : "%llu MB",
+			( size + MB_SI /2 ) / MB_SI  );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu MiB" : "%llu MiB",
+			( size + MiB /2 ) / MiB  );
+	    break;
+
+	case DC_SIZE_G:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu GB" : "%llu GB",
+			( size + GB_SI/2 ) / GB_SI );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu GiB" : "%llu GiB",
+			( size + GiB/2 ) / GiB );
+	    break;
+
+	case DC_SIZE_T:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu TB" : "%llu TB",
+			( size + TB_SI/2 ) / TB_SI );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu TiB" : "%llu TiB",
+			( size + TiB/2 ) / TiB );
+	    break;
+
+	case DC_SIZE_P:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu PB" : "%llu PB",
+			( size + PB_SI/2 ) / PB_SI );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu PiB" : "%llu PiB",
+			( size + PiB/2 ) / PiB );
+	    break;
+
+	case DC_SIZE_E:
+	    if (force_1000)
+		snprintf(buf,buf_size, aligned ? "%5llu EB" : "%llu EB",
+			( size + EB_SI/2 ) / EB_SI );
+	    else
+		snprintf(buf,buf_size, aligned ? "%4llu EiB" : "%llu EiB",
+			( size + EiB/2 ) / EiB );
+	    break;
+
+
+	//----- default == auto
+
+	default:
+	    buf = force_1000
+			? PrintSize1000(buf,buf_size,size,sform_mode)
+			: PrintSize1024(buf,buf_size,size,sform_mode);
+	    if ( !(mode&DC_SIZE_F_NO_UNIT) )
+		return buf;
+    }
+
+    if ( mode & (DC_SIZE_F_AUTO_UNIT|DC_SIZE_F_NO_UNIT) )
+    {
+	char * ptr = buf;
+	while ( *ptr == ' ' )
+	    ptr++;
+	while ( *ptr && *ptr != ' ' )
+	    ptr++;
+	*ptr  = 0;
+    }
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// [[PrintSize1000]]
+
+char * PrintSize1000
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			size,		// size to print
+    sizeform_mode_t	sform_mode	// output format, bit field
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 20 );
+
+    u64 num;
+    size_mode_t unit;
+
+    u64 mb = (size+MB_SI/2)/MB_SI; // maybe an overflow => extra if
+    if ( mb < 10000 && size < EB_SI )
+    {
+	u64 kb = (size+KB_SI/2)/KB_SI;
+	if ( kb < 10 )
+	{
+	    num  = size;
+	    unit = DC_SIZE_BYTES;
+	}
+	else if ( kb < 10000 )
+	{
+	    num  = kb;
+	    unit = DC_SIZE_K;
+	}
+	else
+	{
+	    num  = mb;
+	    unit = DC_SIZE_M;
+	}
+    }
+    else
+    {
+	mb = size / MB_SI; // recalc because of possible overflow
+	u64 tb = (mb+MB_SI/2)/MB_SI;
+	if ( tb < 10000 )
+	{
+	    if ( tb < 10 )
+	    {
+		num  = (mb+KB_SI/2)/KB_SI;
+		unit = DC_SIZE_G;
+	    }
+	    else
+	    {
+		num  = tb;
+		unit = DC_SIZE_T;
+	    }
+	}
+	else
+	{
+	    u64 pb = (mb+GB_SI/2)/GB_SI;
+	    if ( pb < 10000 )
+	    {
+		num  = pb;
+		unit = DC_SIZE_P;
+	    }
+	    else
+	    {
+		num  = (mb+TB_SI/2)/TB_SI;
+		unit = DC_SIZE_E;
+	    }
+	}
+    }
+
+    if	(  sform_mode & DC_SFORM_INC
+	&& num
+	&& !( num % 1000 )
+	&& dc_size_tab_1000[unit+1]
+	)
+    {
+	unit++;
+	num /= 1000;
+    }
+
+    char unit_buf[8];
+    char *dest = unit_buf;
+    if ( !(sform_mode & DC_SFORM_NARROW) )
+	*dest++ = ' ';
+
+    if ( sform_mode & DC_SFORM_UNIT1 )
+    {
+	if ( unit != DC_SIZE_BYTES )
+	    *dest++ = dc_size_tab_1000[unit][0];
+	else if ( sform_mode & DC_SFORM_ALIGN )
+	    *dest++ = ' ';
+	else
+	    dest = unit_buf; // not any char
+	*dest = 0;
+    }
+    else if ( sform_mode & DC_SFORM_ALIGN )
+	snprintf(dest,sizeof(unit_buf)-1,"%-3s",dc_size_tab_1000[unit]);
+    else
+	StringCopyS(dest,sizeof(unit_buf)-1,dc_size_tab_1000[unit]);
+
+    if ( !num && unit == DC_SIZE_BYTES && sform_mode & DC_SFORM_DASH )
+    {
+	if ( sform_mode & DC_SFORM_ALIGN )
+	    snprintf(buf,buf_size,"   -%s",unit_buf);
+	else
+	    StringCopyS(buf,buf_size,"-");
+    }
+    if ( sform_mode & DC_SFORM_ALIGN )
+	snprintf(buf,buf_size,"%4llu%s",num,unit_buf);
+    else
+	snprintf(buf,buf_size,"%llu%s",num,unit_buf);
+
+    return buf;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// [[PrintSize1024]]
+
+char * PrintSize1024
+(
+    char		*buf,		// result buffer
+					// NULL: use a local circulary static buffer
+    size_t		buf_size,	// size of 'buf', ignored if buf==NULL
+    u64			size,		// size to print
+    sizeform_mode_t	sform_mode	// output format, bit field
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 20 );
+
+    u64 num;
+    size_mode_t unit;
+
+    u64 mib = (size+MiB/2)/MiB; // maybe an overflow => extra if
+    if ( mib < 10000 && size < EiB )
+    {
+	u64 kib = (size+KiB/2)/KiB;
+	if ( kib < 10 )
+	{
+	    num  = size;
+	    unit = DC_SIZE_BYTES;
+	}
+	else if ( kib < 10000 )
+	{
+	    num  = kib;
+	    unit = DC_SIZE_K;
+	}
+	else
+	{
+	    num  = mib;
+	    unit = DC_SIZE_M;
+	}
+    }
+    else
+    {
+	mib = size / MiB; // recalc because of possible overflow
+	u64 tib = (mib+MiB/2)/MiB;
+	if ( tib < 10000 )
+	{
+	    if ( tib < 10 )
+	    {
+		num  = (mib+KiB/2)/KiB;
+		unit = DC_SIZE_G;
+	    }
+	    else
+	    {
+		num  = tib;
+		unit = DC_SIZE_T;
+	    }
+	}
+	else
+	{
+	    u64 pib = (mib+GiB/2)/GiB;
+	    if ( pib < 10000 )
+	    {
+		num  = pib;
+		unit = DC_SIZE_P;
+	    }
+	    else
+	    {
+		num  = (mib+TiB/2)/TiB;
+		unit = DC_SIZE_E;
+	    }
+	}
+    }
+
+    if	(  sform_mode & DC_SFORM_INC
+	&& num
+	&& !( num & 0x3ff )
+	&& dc_size_tab_1024[unit+1]
+	)
+    {
+	unit++;
+	num /= 0x400;
+    }
+
+    char unit_buf[8];
+    char *dest = unit_buf;
+    if ( !(sform_mode & DC_SFORM_NARROW) )
+	*dest++ = ' ';
+
+    if ( sform_mode & DC_SFORM_UNIT1 )
+    {
+	if ( unit != DC_SIZE_BYTES )
+	    *dest++ = dc_size_tab_1000[unit][0];
+	else if ( sform_mode & DC_SFORM_ALIGN )
+	    *dest++ = ' ';
+	else
+	    dest = unit_buf; // not any char
+	*dest = 0;
+    }
+    else if ( sform_mode & DC_SFORM_ALIGN )
+	snprintf(dest,sizeof(unit_buf)-1,"%-3s",dc_size_tab_1024[unit]);
+    else
+	StringCopyS(dest,sizeof(unit_buf)-1,dc_size_tab_1024[unit]);
+
+    if ( !num && unit == DC_SIZE_BYTES && sform_mode & DC_SFORM_DASH )
+    {
+	if ( sform_mode & DC_SFORM_ALIGN )
+	    snprintf(buf,buf_size,"   -%s",unit_buf);
+	else
+	    StringCopyS(buf,buf_size,"-");
+    }
+    else if ( sform_mode & DC_SFORM_ALIGN )
+	snprintf(buf,buf_size,"%4llu%s",num,unit_buf);
+    else
+	snprintf(buf,buf_size,"%llu%s",num,unit_buf);
+
+    return buf;
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			   scan size			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+u64 (*ScanSizeFactorHook)
+(
+    char	ch_factor,		// char to analyze
+    int		force_base		// if 1000|1024: force multiple of this
+) = 0;
+
+//-----------------------------------------------------------------------------
+
+u64 ScanSizeFactor
+(
+    char	ch_factor,		// char to analyze
+    int		force_base		// if 1000|1024: force multiple of this
+)
+{
+    if (ScanSizeFactorHook)
+    {
+	u64 res = ScanSizeFactorHook(ch_factor,force_base);
+	if (res)
+	    return res;
+    }
+
+    if ( force_base == 1000 )
+    {
+	switch (ch_factor)
+	{
+	    case 'b': case 'c': return     1;
+	    case 'k': case 'K': return KB_SI;
+	    case 'm': case 'M': return MB_SI;
+	    case 'g': case 'G': return GB_SI;
+	    case 't': case 'T': return TB_SI;
+	    case 'p': case 'P': return PB_SI;
+	    case 'e': case 'E': return EB_SI;
+	}
+    }
+    else if ( force_base == 1024 )
+    {
+	switch (ch_factor)
+	{
+	    case 'b': case 'c': return   1;
+	    case 'k': case 'K': return KiB;
+	    case 'm': case 'M': return MiB;
+	    case 'g': case 'G': return GiB;
+	    case 't': case 'T': return TiB;
+	    case 'p': case 'P': return PiB;
+	    case 'e': case 'E': return EiB;
+	}
+    }
+    else
+    {
+	switch (ch_factor)
+	{
+	    case 'b':
+	    case 'c': return 1;
+
+	    case 'k': return KB_SI;
+	    case 'm': return MB_SI;
+	    case 'g': return GB_SI;
+	    case 't': return TB_SI;
+	    case 'p': return PB_SI;
+	    case 'e': return EB_SI;
+
+	    case 'K': return KiB;
+	    case 'M': return MiB;
+	    case 'G': return GiB;
+	    case 'T': return TiB;
+	    case 'P': return PiB;
+	    case 'E': return EiB;
+	}
+    }
+
+    return 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeTerm
+(
+    double	*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    int		force_base		// if 1000|1024: force multiple of this
+)
+{
+    ASSERT(source);
+
+    char * end;
+    double d = strtod(source,&end);
+    if ( end > source )
+    {
+	// something was read
+
+	if ( *end == '/' )
+	{
+	    const double div = strtod(end+1,&end);
+	    if ( div > 0.0 )
+		d /= div;
+	}
+
+	u64 factor = ScanSizeFactor(*end,force_base);
+	if (factor)
+	    end++;
+	else
+	    factor = default_factor;
+
+	if (factor)
+	    d *= factor;
+	else
+	    end = (char*)source;
+    }
+
+    if (num)
+	*num = d;
+
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSize
+(
+    double	*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base		// if 1000|1024: force multiple of this
+)
+{
+    DASSERT(source);
+    TRACE("ScanSize(df=%llx,%llx, base=%u)\n",
+			default_factor, default_factor_add, force_base );
+
+    double sum = 0.0;
+    bool add = true;
+    char * end = 0;
+    for(;;)
+    {
+	double term;
+	end = ScanSizeTerm(&term,source,default_factor,force_base);
+	if ( end == source )
+	    break;
+
+	if (add)
+	    sum += term;
+	else
+	    sum -= term;
+
+	while ( *end > 0 && *end <= ' ' )
+	    end++;
+
+	if ( *end == '+' )
+	    add = true;
+	else if ( *end == '-' )
+	    add = false;
+	else
+	    break;
+
+	source = end+1;
+	while ( *source > 0 && *source <= ' ' )
+	    source++;
+
+	if ( !*source && default_factor_add )
+	{
+	    if (add)
+		sum += default_factor_add;
+	    else
+		sum -= default_factor_add;
+	    end = (char*)source;
+	    break;
+	}
+
+	default_factor = default_factor_add;
+    }
+
+    if (num)
+	*num = sum;
+
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeU32
+(
+    u32		*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base		// if 1000|1024: force multiple of this
+)
+{
+    double d;
+    char * end = ScanSize(&d,source,default_factor,default_factor_add,force_base);
+    if ( d < 0 || d > ~(u32)0 )
+	end = (char*)source;
+    else if (num)
+	*num = (u32)d;
+
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeU64
+(
+    u64		*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base		// if 1000|1024: force multiple of this
+)
+{
+    double d;
+    char * end = ScanSize(&d,source,default_factor,default_factor_add,force_base);
+    if ( d < 0 || d > ~(u64)0 )
+	end = (char*)source;
+    else if (num)
+	*num = (u64)d;
+
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRange
+(
+    int		*stat,			// if not NULL: store result
+					//	0:none, 1:single, 2:range
+    double	*num1,			// not NULL: store 'from' result
+    double	*num2,			// not NULL: store 'to' result
+
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    double	max_value		// >0: max value for open ranges
+)
+{
+    int count = 0;
+    double d1, d2;
+
+    char *end = ScanSize(&d1,source,default_factor,default_factor_add,force_base);
+    if ( end == source )
+    {
+	d1 = d2 = 0.0;
+	count = 0;
+    }
+    else
+    {
+	count++;
+	d2 = d1;
+	if ( *end == '#' || *end == ':' )
+	{
+	    source = end;
+	    end = ScanSize(&d2,source+1,default_factor,default_factor_add,force_base);
+	    if ( end == source+1 )
+	    {
+		if ( *source == ':' && max_value > 0.0 )
+		{
+		    count++;
+		    d2 = max_value;
+		    if ( *end == '*' )
+			end++;
+		}
+		else
+		{
+		    end--;
+		    d2 = d1;
+		}
+	    }
+	    else
+	    {
+		count++;
+		if ( *source == '#' )
+		    d2 += d1-1;
+	    }
+	    if ( d2 < d1 )
+		d2 = d1;
+	}
+    }
+
+    if (stat)
+	*stat = count;
+    if (num1)
+	*num1 = d1;
+    if (num2)
+	*num2 = d2;
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRangeU32
+(
+    int		*stat,			// if not NULL: store result
+					//	0:none, 1:single, 2:range
+    u32		*num1,			// not NULL: store 'from' result
+    u32		*num2,			// not NULL: store 'to' result
+
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    u32		max_value		// >0: max value for open ranges
+)
+{
+    double d1, d2;
+    char * end = ScanSizeRange(stat,&d1,&d2,source,
+			default_factor,default_factor_add,force_base,
+			max_value>0 ? max_value : U32_MAX );
+
+    if ( d1 < 0 || d1 > U32_MAX || d2 < 0 || d2 > U32_MAX )
+	end = (char*)source;
+    else
+    {
+	if (num1)
+	    *num1 = (u32)d1;
+	if (num2)
+	    *num2 = (u32)d2;
+    }
+
+    return end;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRangeU64
+(
+    int		*stat,			// if not NULL: store result
+					//	0:none, 1:single, 2:range
+    u64		*num1,			// not NULL: store 'from' result
+    u64		*num2,			// not NULL: store 'to' result
+
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    u64		max_value		// >0: max value for open ranges
+)
+{
+    double d1, d2;
+    char * end = ScanSizeRange(stat,&d1,&d2,source,
+			default_factor,default_factor_add,force_base,
+			max_value>0 ? max_value : U64_MAX );
+
+    if ( d1 < 0 || d1 > U64_MAX || d2 < 0 || d2 > U64_MAX )
+	end = (char*)source;
+    else
+    {
+	if (num1)
+	    *num1 = (u64)d1;
+	if (num2)
+	    *num2 = (u64)d2;
+    }
+
+    return end;
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRangeList
+(
+    uint	*n_range,		// not NULL: store number of scanned ranges
+    double	*num,			// array with '2*max_range' elements
+					//	unused elements are filled with 0.0
+    uint	max_range,		// max number of allowed ranges
+
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    double	max_value		// >0: max value for open ranges
+)
+{
+    DASSERT(num);
+
+    uint i = 0;
+    char *ptr = (char*)source;
+
+    while ( i < max_range )
+    {
+	while ( *ptr > 0 && *ptr <= ' ' || *ptr == ',' )
+	    ptr++;
+
+	int stat;
+	ptr = ScanSizeRange( &stat, num, num+1, ptr,
+			default_factor, default_factor_add, force_base, max_value );
+	if (!stat)
+	    break;
+	num += 2;
+	i++;
+
+	char *ptr2 = ptr;
+	while ( *ptr2 > 0 && *ptr2 <= ' ' )
+	    ptr2++;
+	if ( *ptr2 != ',' )
+	    break;
+
+	ptr = ptr2 + 1;
+    }
+
+    if (n_range)
+	*n_range = i;
+
+    while ( i < max_range )
+    {
+	*num++ = 0.0;
+	*num++ = 0.0;
+	i++;
+    }
+
+    return ptr;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRangeListU32
+(
+    uint	*n_range,		// not NULL: store number of scanned ranges
+    u32		*num,			// array with '2*max_range' elements
+					//	unused elements are filled with 0
+    uint	max_range,		// max number of allowed ranges
+
+    ccp		source,			// source text
+    u32		default_factor,		// use this factor if number hasn't one
+    u32		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    u32		max_value		// >0: max value for open ranges
+)
+{
+    DASSERT(num);
+
+    const uint max = 100;
+    double d_buf[2*max];
+    double *d = max_range < max ? d_buf : MALLOC(max_range*2*sizeof(double));
+
+    char *end = ScanSizeRangeList( n_range, d, max_range,
+			source, default_factor, default_factor_add,
+			force_base, max_value );
+
+    uint i;
+    for ( i = 0; i < 2*max_range; i++ )
+	num[i] = d[i] < 0.0 ? 0.0 : d[i] < U32_MAX ? d[i] : U32_MAX;
+
+    if ( d != d_buf )
+	FREE(d);
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSizeRangeListU64
+(
+    uint	*n_range,		// not NULL: store number of scanned ranges
+    u64		*num,			// array with '2*max_range' elements
+					//	unused elements are filled with 0
+    uint	max_range,		// max number of allowed ranges
+
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+    u64		max_value		// >0: max value for open ranges
+)
+{
+    DASSERT(num);
+
+    const uint max = 100;
+    double d_buf[2*max];
+    double *d = max_range < max ? d_buf : MALLOC(max_range*2*sizeof(double));
+
+    char *end = ScanSizeRangeList( n_range, d, max_range,
+			source, default_factor, default_factor_add,
+			force_base, max_value );
+
+    uint i;
+    for ( i = 0; i < 2*max_range; i++ )
+	num[i] = d[i] < 0.0 ? 0.0 : d[i] < U64_MAX ? d[i] : U64_MAX;
+
+    if ( d != d_buf )
+	FREE(d);
+    return end;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanSizeOpt
+(
+    double	*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    u64		default_factor_add,	// use this factor for summands
+    int		force_base,		// if 1000|1024: force multiple of this
+
+    ccp		opt_name,		// NULL or name of option for error messages
+    u64		min,			// minimum allowed value
+    u64		max,			// maximum allowed value
+    bool	print_err		// true: print error messages
+)
+{
+    double d;
+    char * end = ScanSize(&d,source,default_factor,default_factor_add,force_base);
+
+ #ifdef DEBUG
+    {
+	u64 size = d;
+	TRACE("--%s %8.6g ~ %llu ~ %llu GiB ~ %llu GB\n",
+		opt_name, d, size, (size+GiB/2)/GiB, (size+500000000)/1000000000 );
+    }
+ #endif
+
+    enumError err = ERR_OK;
+
+    if ( source == end || *end )
+    {
+	err = ERR_SYNTAX;
+	if (print_err)
+	    ERROR0(ERR_SYNTAX,
+			"Illegal number for option --%s: %s\n",
+			opt_name, source );
+    }
+    else if ( min > 0 && d < min )
+    {
+	err = ERR_SYNTAX;
+	if (print_err)
+	    ERROR0(ERR_SEMANTIC,
+			"Value of --%s too small (must not <%llu): %s\n",
+			opt_name, min, source );
+    }
+    else if ( max > 0 && d > max )
+    {
+	err = ERR_SYNTAX;
+	if (print_err)
+	    ERROR0(ERR_SEMANTIC,
+			"Value of --%s too large (must not >%llu): %s\n",
+			opt_name, max, source );
+    }
+
+    if ( num && !err )
+	*num = d;
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanSizeOptU64
+(
+    u64		*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    int		force_base,		// if 1000|1024: force multiple of this
+
+    ccp		opt_name,		// NULL or name of option for error messages
+    u64		min,			// >0: minimum allowed value
+    u64		max,			// >0: maximum allowed value
+    u32		multiple,		// >0: result must be multiple
+    u32		pow2,			// >0: result must power of '1<<pow2'
+    bool	print_err		// true: print error messages
+)
+{
+    if (!max)
+	max = ~(u64)0;
+
+    if ( pow2 && !force_base )
+    {
+	// try base 1024 first without error messages
+	u64 val;
+	if (!ScanSizeOptU64( &val, source, default_factor, 1024,
+				opt_name, min,max, multiple, pow2, false ))
+	{
+	    if (num)
+		*num = val;
+	    return ERR_OK;
+	}
+    }
+
+    double d = 0.0;
+    enumError err = ScanSizeOpt(&d,source,default_factor,
+				multiple ? multiple : 1,
+				force_base,opt_name,min,max,print_err);
+
+    u64 val;
+    if ( d < 0.0 )
+    {
+	val = 0;
+	err = ERR_SEMANTIC;
+	if (print_err)
+	    ERROR0(ERR_SEMANTIC, "--%s: negative values not allowed: %s\n",
+			opt_name, source );
+    }
+    else
+	val = d;
+
+    if ( err == ERR_OK && pow2 > 0 )
+    {
+	int shift_count = 0;
+	u64 shift_val = val;
+	if (val)
+	{
+	    while (!(shift_val&1))
+	    {
+		shift_count++;
+		shift_val >>= 1;
+	    }
+	}
+
+	if ( shift_val != 1 || shift_count/pow2*pow2 != shift_count )
+	{
+	    err = ERR_SEMANTIC;
+	    if (print_err)
+		ERROR0(ERR_SYNTAX,
+			"--%s: value must be a power of %d but not %llu\n",
+			opt_name, 1<<pow2, val );
+	}
+    }
+
+    if ( err == ERR_OK && multiple > 1 )
+    {
+	u64 xval = val / multiple * multiple;
+	if ( xval != val )
+	{
+	    if ( min > 0 && xval < min )
+		xval += multiple;
+
+	    if (print_err)
+		ERROR0(ERR_WARNING,
+		    "--%s: value must be a multiple of %u -> use %llu instead of %llu.\n",
+		    opt_name, multiple, xval, val );
+	    val = xval;
+	}
+    }
+
+    if ( num && !err )
+	*num = val;
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+enumError ScanSizeOptU32
+(
+    u32		*num,			// not NULL: store result
+    ccp		source,			// source text
+    u64		default_factor,		// use this factor if number hasn't one
+    int		force_base,		// if 1000|1024: force multiple of this
+
+    ccp		opt_name,		// NULL or name of option for error messages
+    u64		min,			// >0: minimum allowed value
+    u64		max,			// >0: maximum allowed value
+    u32		multiple,		// >0: result must be multiple
+    u32		pow2,			// >0: result must power of '1<<pow2'
+    bool	print_err		// true: print error messages
+)
+{
+    if ( !max || max > ~(u32)0 )
+	max = ~(u32)0;
+
+    u64 val = 0;
+    enumError err = ScanSizeOptU64( &val, source, default_factor, force_base,
+				opt_name, min, max, multiple, pow2, print_err );
+
+    if ( num && !err )
+	*num = (u32)val;
+    return err;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+// strto*() like wrappers
+
+u32 GetSizeU32	( ccp src, char **end, int force_base )
+{
+    u32 num = 0;
+    char *ptr = ScanSizeU32(&num,src,1,1,force_base);
+    if (end)
+	*end = ptr;
+    return num;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+u64 GetSizeU64	( ccp src, char **end, int force_base )
+{
+    u64 num = 0;
+    char *ptr = ScanSizeU64(&num,src,1,1,force_base);
+    if (end)
+	*end = ptr;
+    return num;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+double GetSizeD	( ccp src, char **end, int force_base )
+{
+    double num = 0.0;
+    char *ptr = ScanSize(&num,src,1,1,force_base);
+    if (end)
+	*end = ptr;
+    return num;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			Scan Duration			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanSIFactor
+(
+    // returns end of scanned string
+
+    double	*num,			// not NULL: store result
+    ccp		source,			// source text
+    double	default_factor		// return this if no factor found
+)
+{
+    DASSERT(source);
+    switch (*(uchar*)source++)
+    {
+	case 'y': default_factor = 1e-24; break;
+	case 'z': default_factor = 1e-21; break;
+	case 'a': default_factor = 1e-18; break;
+	case 'f': default_factor = 1e-15; break;
+	case 'p': default_factor = 1e-12; break;
+	case 'n': default_factor = 1e-9; break;
+	case 0xb5: // µ as ANSI
+	case 'u': default_factor = 1e-6; break;
+	case 'm': default_factor = 1e-3; break;
+	case 'c': default_factor = 1e-2; break;
+	case 'd': default_factor = 1e-1; break;
+
+	case 'h': default_factor = 1e2; break;
+	case 'k': default_factor = 1e3; break;
+	case 'M': default_factor = 1e6; break;
+	case 'G': default_factor = 1e9; break;
+	case 'T': default_factor = 1e12; break;
+	case 'P': default_factor = 1e15; break;
+	case 'E': default_factor = 1e18; break;
+	case 'Z': default_factor = 1e21; break;
+	case 'Y': default_factor = 1e24; break;
+
+	case 0xc2:
+	    if ( (uchar)*source == 0xb5 )
+	    {
+		// µ as UTF-8
+		source++;
+		default_factor = 1e-6;
+		break;
+	    }
+	    else
+		source--;
+	    break;
+
+	default:
+	   source--;
+    }
+    if (num)
+	*num = default_factor;
+    return (char*)source;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+double GetDurationFactor ( char ch )
+{
+    switch (ch)
+    {
+	case 's': return 1.0; break;
+	case 'm': return 60.0; break;
+	case 'h': return 3600.0; break;
+	case 't':
+	case 'd': return 86400.0; break;
+	case 'w': return 7*86400.0; break;
+	case 'j':
+	case 'y': return 365*86400.0; break;
+	default:  return 0.0;
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanDuration
+(
+    double		*num,		// not NULL: store result
+    ccp			source,		// source text
+    double		default_factor,	// default factor if no SI unit found
+    ScanDuration_t	mode
+)
+{
+    if (!source)
+	return 0;
+
+    ccp src = source;
+    if ( mode & SDUMD_SKIP_BLANKS )
+	while ( *src == ' ' || *src == '\t' )
+	    src++;
+
+    if ( mode & SDUMD_ALLOW_LIST )
+    {
+	bool valid = false;
+	mode &= ~(SDUMD_SKIP_BLANKS|SDUMD_ALLOW_LIST);
+	double sum = 0.0;
+	bool sub = false;
+	for(;;)
+	{
+	    double val;
+	    ccp end = ScanDuration(&val,src,default_factor,mode);
+	    if ( src == end )
+		break;
+	    if (sub)
+	    {
+		sub = false;
+		sum -= val;
+	    }
+	    else
+		sum += val;
+	    src = end;
+	    valid = true;
+
+	    if ( mode & SDUMD_ALLOW_SPACE_SEP )
+		while ( *src == ' ' || *src == '\t' )
+		    src++;
+	    if ( *src == '+' && mode & SDUMD_ALLOW_PLUS_SEP )
+		src++;
+	    else if ( *src == '-' && mode & SDUMD_ALLOW_MINUS_SEP )
+	    {
+		src++;
+		sub = true;
+	    }
+	    mode |= SDUMD_SKIP_BLANKS;
+	}
+	if (num)
+	    *num = sum;
+	return (char*)( valid ? src : source );
+    }
+
+
+    //--- single scan
+
+    char *end;
+    double val = strtod(src,&end);
+    if ( end > src )
+    {
+	if ( *end == ':' && mode & SDUMD_ALLOW_COLON )
+	{
+	    // 'H:M' or 'H:M:S'
+	    src = end + 1;
+	    val *= 3600;
+	    double min = strtod(src,&end);
+	    if ( end > src )
+	    {
+		val += 60*min;
+		src = end;
+		if ( *src == ':' )
+		{
+		    // 'H:M:S'
+		    double sec = strtod(++src,&end);
+		    if ( end > src )
+		    {
+			src = end;
+			val += sec;
+		    }
+		}
+	    }
+	}
+	else
+	{
+	    if ( *end == '/' && mode & SDUMD_ALLOW_DIV )
+	    {
+		const double div = strtod(end+1,&end);
+		if ( div > 0.0 )
+		    val /= div;
+	    }
+	    src = end;
+
+	    double si_factor;
+	    end = ScanSIFactor(&si_factor,src,1.0);
+
+	    double unit = GetDurationFactor(*end);
+	    if (unit)
+	    {
+		val *= unit * si_factor;
+		src = end+1;
+	    }
+	    else
+	    {
+		unit = GetDurationFactor(*src);
+		if (unit)
+		{
+		    val *= unit;
+		    src++;
+		}
+		else
+		{
+		    val *= (end>src) ? si_factor : default_factor;
+		    src = end;
+		}
+	    }
+	}
+	if (num)
+	    *num = val;
+	return (char*)src;
+    }
+
+    if (num)
+	*num = 0.0;
+    return (char*)source;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			PrintIP4*()			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintIP4A
+(
+    // print in A-notation
+
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port		// 0..0xffff: add ':port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = FW_IPV4_A_PORT+1 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+
+    if ( port >= 0 && port <= 0xffff )
+	snprintf(buf,buf_size,"%u.%u:%u",
+		addr[0], ip4 & 0xffffff, port );
+    else
+	snprintf(buf,buf_size,"%u.%u",
+		addr[0], ip4 & 0xffffff );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintIP4B
+(
+    // print in A-notation
+
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port		// 0..0xffff: add ':port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = FW_IPV4_B_PORT+1 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+
+    if ( port >= 0 && port <= 0xffff )
+	snprintf(buf,buf_size,"%u.%u.%u:%u",
+		addr[0], addr[1], ip4 & 0xffff, port );
+    else
+	snprintf(buf,buf_size,"%u.%u.%u",
+		addr[0], addr[1], ip4 & 0xffff );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintIP4
+(
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port		// 0..0xffff: add ':port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = FW_IPV4_C_PORT+1 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+
+    if ( port >= 0 && port <= 0xffff )
+	snprintf(buf,buf_size,"%u.%u.%u.%u:%u",
+		addr[0], addr[1], addr[2], addr[3], port );
+    else
+	snprintf(buf,buf_size,"%u.%u.%u.%u",
+		addr[0], addr[1], addr[2], addr[3] );
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintLeftIP4
+(
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port		// 0..0xffff: add ':port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = FW_IPV4_C_PORT+1 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+    uint len, fw;
+
+    if ( port >= 0 && port <= 0xffff )
+    {
+	fw = 21;
+	len = snprintf(buf,buf_size,"%u.%u.%u.%u:%u",
+			addr[0], addr[1], addr[2], addr[3], port );
+    }
+    else
+    {
+	fw = 15;
+	len = snprintf(buf,buf_size,"%u.%u.%u.%u",
+			addr[0], addr[1], addr[2], addr[3] );
+    }
+
+    char *dest = buf + len;
+    char *end  = buf + ( fw < buf_size ? fw : buf_size );
+    while ( dest < end )
+	*dest++ = ' ';
+    *dest = 0;
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintRightIP4
+(
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port,		// 0..0xffff: add ':port'
+    uint	port_mode	// 0: 'ip:port', 1: 'ip :port', 2: 'ip : port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = 24 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+
+    char tempbuf[16];
+    snprintf(tempbuf,sizeof(tempbuf),"%u.%u.%u.%u",
+			addr[0], addr[1], addr[2], addr[3] );
+
+    if ( port >= 0 && port <= 0xffff )
+    {
+	if (!port_mode)
+	    snprintf(buf,buf_size,"%15s:%-5u",tempbuf,port);
+	else if ( port_mode == 1 )
+	    snprintf(buf,buf_size,"%15s :%-5u",tempbuf,port);
+	else
+	    snprintf(buf,buf_size,"%15s : %-5u",tempbuf,port);
+    }
+    else
+	snprintf(buf,buf_size,"%15s",tempbuf);
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * PrintAlignedIP4
+(
+    char	*buf,		// result buffer
+				// NULL: use a local circulary static buffer
+    size_t	buf_size,	// size of 'buf', ignored if buf==NULL
+    u32		ip4,		// IP4 to print
+    s32		port		// 0..0xffff: add ':port'
+)
+{
+    if (!buf)
+	buf = GetCircBuf( buf_size = FW_IPV4_C_PORT+1 );
+
+    u8 addr[4];
+    write_be32(addr,ip4);
+
+    if ( port >= 0 && port <= 0xffff )
+	snprintf(buf,buf_size,"%3u.%3u.%3u.%3u:%5u",
+		addr[0], addr[1], addr[2], addr[3], port );
+    else
+	snprintf(buf,buf_size,"%3u.%3u.%3u.%3u",
+		addr[0], addr[1], addr[2], addr[3] );
+    return buf;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				CRC16			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+void CreateCRC16Table ( u16 table[0x100], u16 polynom )
+{
+    int i, j;
+    for ( i = 0; i < 256; i++ )
+    {
+	u16 val = i << 8;
+	for ( j = 0; j < 8; j++ )
+	{
+	    if ( val & 0x8000 )
+		val = val << 1 ^ polynom;
+	    else
+		val <<= 1;
+	}
+	table[i] = val;
+    }
+}
+
+//-----------------------------------------------------------------------------
+
+const u16 * GetCRC16Table ( u16 polynom )
+{
+    static u16 *table = 0;
+    static u16 active_polynom = 0;
+
+    if ( !table || active_polynom != polynom )
+    {
+	if (!table)
+	    table = MALLOC(sizeof(u16)*0x100);
+	CreateCRC16Table(table,polynom);
+	active_polynom = polynom;
+    }
+    return table;
+}
+
+//-----------------------------------------------------------------------------
+
+u16 CalcCRC16 ( cvp data, uint data_size, u16 polynom, u16 preset )
+{
+    DASSERT( data || !data_size );
+
+    register u16 crc = preset;
+    if ( data_size > 0 )
+    {
+	const u16 *table = GetCRC16Table(polynom);
+	const u8 *ptr = data;
+	while ( data_size-- > 0 )
+	    crc = table[ ( *ptr++ ^ crc >> 8 ) & 0xff ] ^ crc << 8;
+    }
+    return crc;
+}
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////			    misc			///////////////
+///////////////////////////////////////////////////////////////////////////////
+
+float double2float ( double d )
+{
+    // reduce precision
+    return d;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
+
+ccp PrintNiceID4 ( uint id )
+{
+    if (!id)
+	return "----";
+
+    char *buf = GetCircBuf(5);
+    DASSERT(buf);
+
+ #if 0 // the second solution is much faster!
+
+    buf[4]  = 0;
+    div_t d = div( (int)( id % (26*26*100) ), 10 );
+    buf[3]  = '0' + d.rem;
+    d       = div(d.quot,10);
+    buf[2]  = '0' + d.rem;
+    d       = div(d.quot,26);
+    buf[1]  = 'A' + d.rem;
+    buf[0]  = 'A' + d.quot;
+
+ #else
+
+    buf[0] = 'A' + id / 2600 % 26;
+    buf[1] = 'A' + id /  100 % 26;
+    buf[2] = '0' + id /   10 % 10;
+    buf[3] = '0' + id        % 10;
+    buf[4] = 0;
+
+ #endif
+
+    return buf;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+char * ScanNiceID4 ( int * res, ccp arg )
+{
+    DASSERT(res);
+    *res = -1;
+
+    if (!arg)
+	return 0;
+
+    char ch = tolower((int)arg[0]);
+    if ( ch >= 'a' && ch <= 'z' )
+    {
+	int num = ch - 'a';
+	ch = tolower((int)arg[1]);
+	if ( ch >= 'a' && ch <= 'z' )
+	{
+	    num = 26 * num + ch - 'a';
+	    ch = arg[2];
+	    if ( ch >= '0' && ch <= '9' )
+	    {
+		num = 10 * num + ch - '0';
+		ch = arg[3];
+		if ( ch >= '0' && ch <= '9' )
+		{
+		    *res = 10 * num + ch - '0';
+		    return (char*)arg+4;
+		}
+	    }
+	}
+    }
+    return (char*)arg;
+};
+
+//
+///////////////////////////////////////////////////////////////////////////////
+///////////////				END			///////////////
+///////////////////////////////////////////////////////////////////////////////
+