quickjs/tests/test_conv.c

/*
 * Benchmark integer conversion variants
 *
 * Copyright (c) 2024 Charlie Gordon
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <ctype.h>
#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

//#define USE_SINGLE_CASE  1  // special case single digit numbers
#define USE_SPECIAL_RADIX_10  1  // special case single digit numbers
#define USE_SINGLE_CASE_FAST  1  // special case single digit numbers

#define TEST_SNPRINTF     1  // use snprintf for specific bases (for reference)
#define TEST_NAIVE        1  // naive digit loop and copy loops
#define TEST_REVERSE      1  // naive digit loop and reverse digit string
#define TEST_DIGIT_PAIRS  1  // generate 2 decimal digits at a time
#define TEST_DIGIT_1PASS  1  // generate left to right decimal digits
#define TEST_LENGTH_LOOP  1  // compute length before digit loop using loop
#define TEST_LENGTH_EXPR  1  // compute length before digit loop using expression
#define TEST_SHIFTBUF     1  // generate up to 7 byte chunks in a register
#define TEST_BLOCKMOV     1  // move all digits together
#define TEST_DIV_TABLE    1  // use multiplier table instead of radix divisions
#define TEST_DISPATCH     1  // use dispatch table to optimal 64-bit radix converters

#if (defined(__GNUC__) && !defined(__clang__))
#undef TEST_NAIVE            // 32-bit gcc overoptimizes this code
#undef TEST_DIGIT_PAIRS
#endif

/* definitions from cutils.h */

#if !defined(_MSC_VER) && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define minimum_length(n)  static n
#else
#define minimum_length(n)  n
#endif

#if defined(_MSC_VER) && !defined(__clang__)
#  define likely(x)       (x)
#else
#  define likely(x)       __builtin_expect(!!(x), 1)
#endif

#ifndef countof
#define countof(a)  (sizeof(a) / sizeof((a)[0]))
#endif

static inline uint8_t is_be(void) {
    union {
        uint16_t a;
        uint8_t  b;
    } u = { 0x100 };
    return u.b;
}

/* WARNING: undefined if a = 0 */
static inline int clz32(unsigned int a)
{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned long index;
    _BitScanReverse(&index, a);
    return 31 - index;
#else
    return __builtin_clz(a);
#endif
}

/* WARNING: undefined if a = 0 */
static inline int clz64(uint64_t a)
{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned long index;
    _BitScanReverse64(&index, a);
    return 63 - index;
#else
    return __builtin_clzll(a);
#endif
}

// prototypes for final functions
extern char const digits36[36];
size_t u32toa(char buf[minimum_length(11)], uint32_t n);
size_t i32toa(char buf[minimum_length(12)], int32_t n);
size_t u64toa(char buf[minimum_length(21)], uint64_t n);
size_t i64toa(char buf[minimum_length(22)], int64_t n);
size_t u32toa_radix(char buf[minimum_length(33)], uint32_t n, unsigned base);
size_t i32toa_radix(char buf[minimum_length(34)], int32_t n, unsigned base);
size_t u64toa_radix(char buf[minimum_length(65)], uint64_t n, unsigned base);
size_t i64toa_radix(char buf[minimum_length(66)], int64_t n, unsigned base);

/*---- integer to string conversions ----*/

/* All conversion functions:
   - require a destination array `buf` of sufficient length
   - write the string representation at the beginning of `buf`
   - null terminate the string
   - return the string length
 */

/* 2 <= base <= 36 */
char const digits36[36] = "0123456789abcdefghijklmnopqrstuvwxyz";

/*---- variants ----*/

#define define_i32toa(v) \
size_t i32toa_##v(char buf[minimum_length(12)], int32_t n) \
{ \
    if (likely(n >= 0)) \
        return u32toa_##v(buf, n); \
    buf[0] = '-'; \
    return 1 + u32toa_##v(buf + 1, -(uint32_t)n); \
}

#define define_i64toa(v) \
size_t i64toa_##v(char buf[minimum_length(22)], int64_t n) \
{ \
    if (likely(n >= 0)) \
        return u64toa_##v(buf, n); \
    buf[0] = '-'; \
    return 1 + u64toa_##v(buf + 1, -(uint64_t)n); \
}

#ifdef TEST_SHIFTBUF

#define gen_digit(buf, c)  if (is_be()) \
            buf = (buf >> 8) | ((uint64_t)(c) << ((sizeof(buf) - 1) * 8)); \
        else \
            buf = (buf << 8) | (c)

size_t u7toa_shift(char dest[minimum_length(8)], uint32_t n)
{
    size_t len = 1;
    uint64_t buf = 0;
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        gen_digit(buf, '0' + quo);
        len++;
    }
    gen_digit(buf, '0' + n);
    memcpy(dest, &buf, sizeof buf);
    return len;
}

size_t u07toa_shift(char dest[minimum_length(8)], uint32_t n, size_t len)
{
    size_t i;
    dest += len;
    dest[7] = '\0';
    for (i = 7; i-- > 1;) {
        uint32_t quo = n % 10;
        n /= 10;
        dest[i] = (char)('0' + quo);
    }
    dest[i] = (char)('0' + n);
    return len + 7;
}

size_t u32toa_shift(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 10% */
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
#define TEN_POW_7 10000000
    if (n >= TEN_POW_7) {
        uint32_t quo = n / TEN_POW_7;
        n %= TEN_POW_7;
        size_t len = u7toa_shift(buf, quo);
        return u07toa_shift(buf, n, len);
    }
    return u7toa_shift(buf, n);
}

size_t u64toa_shift(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_shift(buf, n);

    size_t len;
    if (n >= TEN_POW_7) {
        uint64_t n1 = n / TEN_POW_7;
        n %= TEN_POW_7;
        if (n1 >= TEN_POW_7) {
            uint32_t quo = n1 / TEN_POW_7;
            n1 %= TEN_POW_7;
            len = u7toa_shift(buf, quo);
            len = u07toa_shift(buf, n1, len);
        } else {
            len = u7toa_shift(buf, n1);
        }
        return u07toa_shift(buf, n, len);
    }
    return u7toa_shift(buf, n);
}

define_i32toa(shift)
define_i64toa(shift)

#endif /* TEST_SHIFTBUF */

#if defined(TEST_DIGIT_PAIRS) || defined(TEST_DIGIT_1PASS)
static char const digits100[200] =
    "00010203040506070809"
    "10111213141516171819"
    "20212223242526272829"
    "30313233343536373839"
    "40414243444546474849"
    "50515253545556575859"
    "60616263646566676869"
    "70717273747576777879"
    "80818283848586878889"
    "90919293949596979899";
#endif

#ifdef TEST_DIGIT_PAIRS
size_t u32toa_pair(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
    char *p = buf;
    char *q = buf + 10;
    while (n >= 100) {
        uint32_t quo = n % 100;
        n /= 100;
        *--q = digits100[2 * quo + 1];
        *--q = digits100[2 * quo];
    }
    *p = digits100[2 * n];
    p += *p != '0';
    *p++ = digits100[2 * n + 1];
    while (q < buf + 10) {
        *p++ = *q++;
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

size_t u64toa_pair(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_pair(buf, n);

    char *p = buf;
    char *q = buf + 20;
    while (n >= 100) {
        uint32_t quo = n % 100;
        n /= 100;
        *--q = digits100[2 * quo + 1];
        *--q = digits100[2 * quo];
    }
    *p = digits100[2 * n];
    p += *p != '0';
    *p++ = digits100[2 * n + 1];
    while (q < buf + 20) {
        *p++ = *q++;
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

define_i32toa(pair)
define_i64toa(pair)

#endif /* TEST_DIGIT_PAIRS */

#if TEST_DIGIT_1PASS
static char *u4toa(char p[minimum_length(4)], uint32_t n)
{
    const char *digits = digits100;
    if (n >= 100) {
        uint32_t n1 = n / 100;
        n -= n1 * 100;
        *p = digits[2 * n1];
        p += digits[2 * n1] != '0';
        *p++ = digits[2 * n1 + 1];
        *p++ = digits[2 * n];
        *p++ = digits[2 * n + 1];
        return p;
    } else {
        *p = digits[2 * n];
        p += digits[2 * n] != '0';
        *p++ = digits[2 * n + 1];
        return p;
    }
}

static char *u04toa(char p[minimum_length(4)], uint32_t n)
{
    const char *digits = digits100;
    uint32_t n1 = n / 100;
    n -= n1 * 100;
    *p++ = digits[2 * n1];
    *p++ = digits[2 * n1 + 1];
    *p++ = digits[2 * n];
    *p++ = digits[2 * n + 1];
    return p;
}

static char *u8toa(char p[minimum_length(8)], uint32_t n)
{
    if (n >= 10000) {
        uint32_t n1 = n / 10000;
        n -= n1 * 10000;
        p = u4toa(p, n1);
        return u04toa(p, n);
    }
    return u4toa(p, n);
}

static char *u08toa(char p[minimum_length(8)], uint32_t n)
{
    uint32_t n1 = n / 10000;
    n -= n1 * 10000;
    p = u04toa(p, n1);
    return u04toa(p, n);
}

size_t u32toa_pair_1pass(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE /* 6% */
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
    char *p = buf;
    /* division by known base uses multiplication */
    if (n >= 100000000) {
        uint32_t n1 = n / 100000000;
        n -= n1 * 100000000;
        /* 1 <= n1 <= 42 */
        *p = digits100[2 * n1];
        p += *p != '0';
        *p++ = digits100[2 * n1 + 1];
        p = u08toa(p, n);
    } else {
        p = u8toa(p, n);
    }
    *p = '\0';
    return p - buf;
}

size_t u64toa_pair_1pass(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_pair_1pass(buf, n);

    char *p = buf;

    /* division by known base uses multiplication */
    if (n >= 100000000) {
        uint64_t n1 = n / 100000000;
        n -= n1 * 100000000;
        if (n1 >= 100000000) {
            uint32_t n2 = n1 / 100000000;
            n1 -= n2 * 100000000;
            // 1 <= n2 <= 1844
            p = u4toa(p, n2);
            p = u08toa(p, n1);
            p = u08toa(p, n);
        } else {
            p = u8toa(p, n1);
            p = u08toa(p, n);
        }
    } else {
        p = u8toa(p, n);
    }
    *p = '\0';
    return p - buf;
}

define_i32toa(pair_1pass)
define_i64toa(pair_1pass)

#endif /* TEST_DIGIT_1PASS */

#ifdef TEST_SNPRINTF
size_t u32toa_snprintf(char buf[minimum_length(11)], uint32_t n)
{
    return snprintf(buf, 11, "%"PRIu32, n);
}

size_t i32toa_snprintf(char buf[minimum_length(12)], int32_t n)
{
    return snprintf(buf, 12, "%"PRId32, n);
}

size_t u64toa_snprintf(char buf[minimum_length(21)], uint64_t n)
{
    return snprintf(buf, 21, "%"PRIu64, n);
}

size_t i64toa_snprintf(char buf[minimum_length(22)], int64_t n)
{
    return snprintf(buf, 22, "%"PRId64, n);
}
#endif /* TEST_SNPRINTF */

#ifdef TEST_NAIVE
size_t u32toa_naive(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
    char *p = buf;
    char *q = buf + 10;
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *--q = (char)('0' + quo);
    }
    *p++ = (char)('0' + n);
    while (q < buf + 10)
        *p++ = *q++;
    *p = '\0';
    return p - buf;
}

size_t u64toa_naive(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_naive(buf, n);

    char *p = buf;
    char *q = buf + 20;
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *--q = (char)('0' + quo);
    }
    *p++ = (char)('0' + n);
    while (q < buf + 20)
        *p++ = *q++;
    *p = '\0';
    return p - buf;
}

define_i32toa(naive)
define_i64toa(naive)

#endif /* TEST_NAIVE */

#ifdef TEST_LENGTH_EXPR
size_t u32toa_length_expr(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 8% */
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
    size_t len = (2 + (n > 99) + (n > 999) +
                  (n > 9999) + (n > 99999) + (n > 999999) +
                  (n > 9999999) + (n > 99999999) + (n > 999999999));
#else
    size_t len = (1 + (n > 9) + (n > 99) + (n > 999) +
                  (n > 9999) + (n > 99999) + (n > 999999) +
                  (n > 9999999) + (n > 99999999) + (n > 999999999));
#endif
    char *end = buf + len;
    *end-- = '\0';
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *end-- = (char)('0' + quo);
    }
    *end = (char)('0' + n);
    return len;
}

size_t u64toa_length_expr(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_length_expr(buf, n);
#if 0
    size_t len = 10 + ((n >= 10000000000ULL) +
                       (n >= 100000000000ULL) +
                       (n >= 1000000000000ULL) +
                       (n >= 10000000000000ULL) +
                       (n >= 100000000000000ULL) +
                       (n >= 1000000000000000ULL) +
                       (n >= 10000000000000000ULL) +
                       (n >= 100000000000000000ULL) +
                       (n >= 1000000000000000000ULL) +
                       (n >= 10000000000000000000ULL));
    char *end = buf + len;
    *end-- = '\0';
#else
    uint64_t n10 = 1000000000;
    uint32_t last = n % 10;
    n /= 10;
    size_t len = 10;
    while (n >= n10) {
        n10 *= 10;
        len++;
    }
    char *end = buf + len;
    *end-- = '\0';
    *end-- = (char)('0' + last);
#endif
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *end-- = (char)('0' + quo);
    }
    *end = (char)('0' + n);
    return len;
}

define_i32toa(length_expr)
define_i64toa(length_expr)

#endif /* TEST_LENGTH_EXPR */

#ifdef TEST_LENGTH_LOOP
size_t u32toa_length_loop(char buf[minimum_length(11)], uint32_t n)
{
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
    uint32_t last = n % 10;
    n /= 10;
    uint32_t n10 = 10;
    size_t len = 2;
    while (n >= n10) {
        n10 *= 10;
        len++;
    }
    char *end = buf + len;
    *end-- = '\0';
    *end-- = (char)('0' + last);
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *end-- = (char)('0' + quo);
    }
    *end = (char)('0' + n);
    return len;
}

size_t u64toa_length_loop(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_length_loop(buf, n);

    uint32_t last = n % 10;
    n /= 10;
    uint64_t n10 = 1000000000;
    size_t len = 10;
    while (n >= n10) {
        n10 *= 10;
        len++;
    }
    char *end = buf + len;
    *end-- = '\0';
    *end-- = (char)('0' + last);
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *end-- = (char)('0' + quo);
    }
    *end = (char)('0' + n);
    return len;
}

define_i32toa(length_loop)
define_i64toa(length_loop)

#endif /* TEST_LENGTH_LOOP */

#if defined(TEST_REVERSE) || defined(TEST_DISPATCH)
size_t u32toa_reverse(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
    char *end;
    size_t len = 0;
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        buf[len++] = (char)('0' + quo);
    }
    buf[len++] = (char)('0' + n);
    buf[len] = '\0';
    for (end = buf + len - 1; buf < end;) {
        char c = *buf;
        *buf++ = *end;
        *end-- = c;
    }
    return len;
}

size_t u64toa_reverse(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_reverse(buf, n);

    char *end;
    size_t len = 0;
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        buf[len++] = (char)('0' + quo);
    }
    buf[len++] = (char)('0' + n);
    buf[len] = '\0';
    for (end = buf + len - 1; buf < end;) {
        char c = *buf;
        *buf++ = *end;
        *end-- = c;
    }
    return len;
}

define_i32toa(reverse)
define_i64toa(reverse)

#endif /* TEST_REVERSE */

#ifdef TEST_BLOCKMOV
size_t u32toa_blockmov(char buf[minimum_length(11)], uint32_t n)
{
#ifdef USE_SINGLE_CASE_FAST /* 6% */
    if (n < 10) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
#endif
    char buf1[10+10];
    char *p = buf;
    char *q = buf1 + 10;
    *q = '\0';
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *--q = (char)('0' + quo);
    }
    *p++ = (char)('0' + n);
    memcpy(p, q, 10);
    return (buf1 + 10) - q + 1;
}

size_t u64toa_blockmov(char buf[minimum_length(21)], uint64_t n)
{
    if (likely(n < 0x100000000))
        return u32toa_blockmov(buf, n);

    char buf1[20+20];
    char *p = buf;
    char *q = buf1 + 20;
    *q = '\0';
    while (n >= 10) {
        uint32_t quo = n % 10;
        n /= 10;
        *--q = (char)('0' + quo);
    }
    *p++ = (char)('0' + n);
    memcpy(p, q, 20);
    return (buf1 + 20) - q + 1;
}

define_i32toa(blockmov)
define_i64toa(blockmov)

#endif /* TEST_BLOCKMOV */

/*---- radix conversion variants ----*/

#define define_i32toa_radix(v) \
size_t i32toa_radix_##v(char buf[minimum_length(34)], int32_t n, unsigned base) \
{ \
    if (likely(n >= 0)) \
        return u32toa_radix_##v(buf, n, base); \
    buf[0] = '-'; \
    return 1 + u32toa_radix_##v(buf + 1, -(uint32_t)n, base); \
}

#define define_i64toa_radix(v) \
size_t i64toa_radix_##v(char buf[minimum_length(66)], int64_t n, unsigned base) \
{ \
    if (likely(n >= 0)) \
        return u64toa_radix_##v(buf, n, base); \
    buf[0] = '-'; \
    return 1 + u64toa_radix_##v(buf + 1, -(uint64_t)n, base); \
}

#ifdef TEST_NAIVE
size_t u32toa_radix_naive(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u32toa_naive(buf, n);
#endif
#ifdef USE_SINGLE_CASE
    if (n < base) {
        buf[0] = digits36[n];
        buf[1] = '\0';
        return 1;
    }
#endif
    char buf1[32];
    char *q = buf1 + 32;
    char *p = buf;
    while (n >= base) {
        size_t digit = n % base;
        n /= base;
        *--q = digits36[digit];
    }
    *--q = digits36[n];
    while (q < buf1 + 32) {
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

size_t u64toa_radix_naive(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (likely(n < 0x100000000))
        return u32toa_radix_naive(buf, n, base);
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u64toa_naive(buf, n);
#endif
    char buf1[64];
    char *q = buf1 + 64;
    char *p = buf;
    while (n >= base) {
        size_t digit = n % base;
        n /= base;
        *--q = digits36[digit];
    }
    *--q = digits36[n];
    while (q < buf1 + 64) {
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

define_i32toa_radix(naive)
define_i64toa_radix(naive)

#endif // TEST_NAIVE

#if defined(TEST_REVERSE) || defined(TEST_DISPATCH)
size_t u32toa_radix_reverse(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u32toa_reverse(buf, n);
#endif
#ifdef USE_SINGLE_CASE
    if (n < base) {
        buf[0] = digits36[n];
        buf[1] = '\0';
        return 1;
    }
#endif
    char *end;
    size_t len = 0;
    while (n >= base) {
        uint32_t quo = n % base;
        n /= base;
        buf[len++] = digits36[quo];
    }
    buf[len++] = digits36[n];
    buf[len] = '\0';
    for (end = buf + len - 1; buf < end;) {
        char c = *buf;
        *buf++ = *end;
        *end-- = c;
    }
    return len;
}

size_t u64toa_radix_reverse(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (likely(n < 0x100000000))
        return u32toa_radix_reverse(buf, n, base);
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u64toa_reverse(buf, n);
#endif
    char *end;
    size_t len = 0;
    while (n >= base) {
        uint32_t quo = n % base;
        n /= base;
        buf[len++] = digits36[quo];
    }
    buf[len++] = digits36[n];
    buf[len] = '\0';
    for (end = buf + len - 1; buf < end;) {
        char c = *buf;
        *buf++ = *end;
        *end-- = c;
    }
    return len;
}

define_i32toa_radix(reverse)
define_i64toa_radix(reverse)

#endif // TEST_REVERSE

#ifdef TEST_LENGTH_LOOP

static uint8_t const radix_shift[64] = {
    0, 0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0,
    4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};

size_t u32toa_radix_length(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
    int shift;

#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u32toa_length_loop(buf, n);
#endif
    if (n < base) {
        buf[0] = digits36[n];
        buf[1] = '\0';
        return 1;
    }
    shift = radix_shift[base & 63];
    if (shift) {
        uint32_t mask = (1 << shift) - 1;
        size_t len = (32 - clz32(n) + shift - 1) / shift;
        size_t last = n & mask;
        char *end = buf + len;
        n >>= shift;
        *end-- = '\0';
        *end-- = digits36[last];
        while (n >= base) {
            size_t quo = n & mask;
            n >>= shift;
            *end-- = digits36[quo];
        }
        *end = digits36[n];
        return len;
    } else {
        size_t len = 2;
        size_t last = n % base;
        n /= base;
        uint32_t nbase = base;
        while (n >= nbase) {
            nbase *= base;
            len++;
        }
        char *end = buf + len;
        *end-- = '\0';
        *end-- = digits36[last];
        while (n >= base) {
            size_t quo = n % base;
            n /= base;
            *end-- = digits36[quo];
        }
        *end = digits36[n];
        return len;
    }
}

size_t u64toa_radix_length(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    int shift;

#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u64toa_length_loop(buf, n);
#endif
    shift = radix_shift[base & 63];
    if (shift) {
        if (n < base) {
            buf[0] = digits36[n];
            buf[1] = '\0';
            return 1;
        }
        uint64_t mask = (1 << shift) - 1;
        size_t len = (64 - clz64(n) + shift - 1) / shift;
        size_t last = n & mask;
        char *end = buf + len;
        n >>= shift;
        *end-- = '\0';
        *end-- = digits36[last];
        while (n >= base) {
            size_t quo = n & mask;
            n >>= shift;
            *end-- = digits36[quo];
        }
        *end = digits36[n];
        return len;
    } else {
        if (likely(n < 0x100000000))
            return u32toa_radix_length(buf, n, base);
        size_t last = n % base;
        n /= base;
        uint64_t nbase = base;
        size_t len = 2;
        while (n >= nbase) {
            nbase *= base;
            len++;
        }
        char *end = buf + len;
        *end-- = '\0';
        *end-- = digits36[last];
        while (n >= base) {
            size_t quo = n % base;
            n /= base;
            *end-- = digits36[quo];
        }
        *end = digits36[n];
        return len;
    }
}

define_i32toa_radix(length)
define_i64toa_radix(length)

#endif // TEST_LENGTH_LOOP

#ifdef TEST_DIV_TABLE
static struct {
    uint32_t chunk : 27;
    uint32_t ndig : 5;
    uint32_t mul;
} const div_table32[37] = {
    { 0, 0, 0 }, // 0
    { 1, 1, 1 }, // 1
    { 67108864, 26, 2147483648 }, // 2
    { 129140163, 17, 1431655776 }, // 3
    { 67108864, 13, 1073741824 }, // 4
    { 48828125, 11, 858993464 }, // 5
    { 60466176, 10, 715827888 }, // 6
    { 40353607, 9, 613566760 }, // 7
    { 16777216, 8, 536870912 }, // 8
    { 43046721, 8, 477218592 }, // 9
    { 100000000, 8, 429496732 }, // 10
    { 19487171, 7, 390451574 }, // 11
    { 35831808, 7, 357913944 }, // 12
    { 62748517, 7, 330382100 }, // 13
    { 105413504, 7, 306783380 }, // 14
    { 11390625, 6, 286331154 }, // 15
    { 16777216, 6, 268435456 }, // 16
    { 24137569, 6, 252645136 }, // 17
    { 34012224, 6, 238609296 }, // 18
    { 47045881, 6, 226050912 }, // 19
    { 64000000, 6, 214748366 }, // 20
    { 85766121, 6, 204522253 }, // 21
    { 113379904, 6, 195225787 }, // 22
    { 6436343, 5, 186737709 }, // 23
    { 7962624, 5, 178956972 }, // 24
    { 9765625, 5, 171798692 }, // 25
    { 11881376, 5, 165191050 }, // 26
    { 14348907, 5, 159072864 }, // 27
    { 17210368, 5, 153391690 }, // 28
    { 20511149, 5, 148102321 }, // 29
    { 24300000, 5, 143165577 }, // 30
    { 28629151, 5, 138547333 }, // 31
    { 33554432, 5, 134217728 }, // 32
    { 39135393, 5, 130150525 }, // 33
    { 45435424, 5, 126322568 }, // 34
    { 52521875, 5, 122713352 }, // 35
    { 60466176, 5, 119304648 }, // 36
};

size_t u32toa_radix_div_table(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u32toa_shift(buf, n);
#endif
#ifdef USE_SINGLE_CASE
    if (n < base) {
        buf[0] = digits36[n];
        buf[1] = '\0';
        return 1;
    }
#endif
    char buf1[32];
    char *q = buf1 + 32;
    char *p = buf;
    uint32_t chunk = div_table32[base].chunk;
    uint32_t ndig = div_table32[base].ndig;
    uint32_t mul = div_table32[base].mul;
    while (n >= chunk) {
        uint32_t quo = n / chunk;
        uint32_t n1 = n - quo * chunk;
        n = quo;
        for (uint32_t i = ndig; i-- > 0;) {
            uint32_t quo1 = ((uint64_t)n1 * mul) >> 32;
            size_t digit = n1 - quo1 * base;
            n1 = quo1;
            *--q = digits36[digit];
        }
    }
    while (n >= base) {
        uint32_t quo = ((uint64_t)n * mul) >> 32;
        size_t digit = n - quo * base;
        n = quo;
        *--q = digits36[digit];
    }
    *--q = digits36[n];
    while (q < buf1 + 32) {
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

size_t u64toa_radix_div_table(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (likely(n < 0x100000000))
        return u32toa_radix_div_table(buf, n, base);
#ifdef USE_SPECIAL_RADIX_10
    if (likely(base == 10))
        return u64toa_shift(buf, n);
#endif
    char buf1[64];
    char *q = buf1 + 64;
    char *p = buf;
    uint32_t chunk = div_table32[base].chunk;
    uint32_t ndig = div_table32[base].ndig;
    uint32_t mul = div_table32[base].mul;
    while (n >= chunk) {
        uint64_t quo = n / chunk;
        uint32_t n1 = n - quo * chunk;
        n = quo;
        for (uint32_t i = ndig; i-- > 0;) {
            uint32_t quo1 = ((uint64_t)n1 * mul) >> 32;
            size_t digit = n1 - quo1 * base;
            n1 = quo1;
            *--q = digits36[digit];
        }
    }
    uint32_t n1 = n;
    while (n1 >= base) {
        uint32_t quo1 = ((uint64_t)n1 * mul) >> 32;
        size_t digit = n1 - quo1 * base;
        n1 = quo1;
        *--q = digits36[digit];
    }
    *--q = digits36[n1];
    while (q < buf1 + 64) {
        *p++ = *q++;
    }
    *p = '\0';
    return p - buf;
}

define_i32toa_radix(div_table)
define_i64toa_radix(div_table)

#endif // TEST_DIV_TABLE

#ifdef TEST_DISPATCH

static size_t u64toa_radix_d10(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    return u64toa_shift(buf, n);
}

static size_t u64toa_radix_d2(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (n < 2) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
    size_t len = (64 - clz64(n));
    char *end = buf + len;
    *end-- = '\0';
    while (n >= 2) {
        uint32_t quo = n & 1;
        n >>= 1;
        *end-- = (char)('0' + quo);
    }
    *end-- = (char)('0' + n);
    return len;
}

static size_t u64toa_radix_d8(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (n < 8) {
        buf[0] = (char)('0' + n);
        buf[1] = '\0';
        return 1;
    }
    size_t len = (64 - clz64(n) + 2) / 3;
    char *end = buf + len;
    *end-- = '\0';
    while (n >= 8) {
        uint32_t quo = n & 7;
        n >>= 3;
        *end-- = (char)('0' + quo);
    }
    *end-- = (char)('0' + n);
    return len;
}

static size_t u64toa_radix_d16(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    if (n < 16) {
        buf[0] = digits36[n];
        buf[1] = '\0';
        return 1;
    }
    size_t len = (64 - clz64(n) + 3) / 4;
    char *end = buf + len;
    *end-- = '\0';
    while (n >= 16) {
        uint32_t quo = n & 15;
        n >>= 4;
        *end-- = digits36[quo];
    }
    *end = digits36[n];
    return len;
}

#define u64toa_reverse_base(radix) \
static size_t u64toa_reverse_##radix(char buf[minimum_length(65)], uint64_t n, unsigned base) \
{ \
    char *end; \
    size_t len = 0; \
    while (n >= radix) { \
        size_t quo = n % radix; \
        n /= radix; \
        if (radix > 9) buf[len++] = digits36[quo]; \
        else buf[len++] = (char)('0' + quo); \
    } \
    if (radix > 9) buf[len++] = digits36[n]; \
    else buf[len++] = (char)('0' + n); \
    buf[len] = '\0'; \
    for (end = buf + len - 1; buf < end;) { \
        char c = *buf; \
        *buf++ = *end; \
        *end-- = c; \
    } \
    return len; \
}

u64toa_reverse_base(3)
u64toa_reverse_base(4)
u64toa_reverse_base(5)
u64toa_reverse_base(6)
u64toa_reverse_base(7)
u64toa_reverse_base(9)
u64toa_reverse_base(11)
u64toa_reverse_base(12)
u64toa_reverse_base(13)
u64toa_reverse_base(14)
u64toa_reverse_base(15)
u64toa_reverse_base(17)
u64toa_reverse_base(18)
u64toa_reverse_base(19)
u64toa_reverse_base(20)
u64toa_reverse_base(21)
u64toa_reverse_base(22)
u64toa_reverse_base(23)
u64toa_reverse_base(24)
u64toa_reverse_base(25)
u64toa_reverse_base(26)
u64toa_reverse_base(27)
u64toa_reverse_base(28)
u64toa_reverse_base(29)
u64toa_reverse_base(30)
u64toa_reverse_base(31)
u64toa_reverse_base(32)
u64toa_reverse_base(33)
u64toa_reverse_base(34)
u64toa_reverse_base(35)
u64toa_reverse_base(36)

typedef size_t (*u64toa_radix_func)(char buf[minimum_length(65)], uint64_t n, unsigned base);
static const u64toa_radix_func u64toa_radix_table[37] = {
#if 0
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_d2, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_d8, u64toa_radix_reverse, u64toa_radix_d10, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_d16, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_reverse,
    u64toa_radix_reverse,
#else
    u64toa_radix_reverse, u64toa_radix_reverse, u64toa_radix_d2, u64toa_reverse_3,
    u64toa_reverse_4, u64toa_reverse_5, u64toa_reverse_6, u64toa_reverse_7,
    u64toa_radix_d8, u64toa_reverse_9, u64toa_radix_d10, u64toa_reverse_11,
    u64toa_reverse_12, u64toa_reverse_13, u64toa_reverse_14, u64toa_reverse_15,
    u64toa_radix_d16, u64toa_reverse_17, u64toa_reverse_18, u64toa_reverse_19,
    u64toa_reverse_20, u64toa_reverse_21, u64toa_reverse_22, u64toa_reverse_23,
    u64toa_reverse_24, u64toa_reverse_25, u64toa_reverse_26, u64toa_reverse_27,
    u64toa_reverse_28, u64toa_reverse_29, u64toa_reverse_30, u64toa_reverse_31,
    u64toa_reverse_32, u64toa_reverse_33, u64toa_reverse_34, u64toa_reverse_35,
    u64toa_reverse_36,
#endif
};

size_t u32toa_radix_dispatch(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
    return u64toa_radix_table[base % 37](buf, n, base);
}

size_t u64toa_radix_dispatch(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    return u64toa_radix_table[base % 37](buf, n, base);
}

define_i32toa_radix(dispatch)
define_i64toa_radix(dispatch)

#endif // TEST_DISPATCH

#ifdef TEST_SNPRINTF
size_t u32toa_radix_snprintf(char buf[minimum_length(33)], uint32_t n, unsigned base)
{
    switch (base) {
#ifdef PRIb32
    case 2: return snprintf(buf, 33, "%"PRIb32, n);
#endif
    case 8: return snprintf(buf, 33, "%"PRIo32, n);
    case 10: return snprintf(buf, 33, "%"PRIu32, n);
    case 16: return snprintf(buf, 33, "%"PRIx32, n);
#ifdef TEST_NAIVE
    default: return u32toa_radix_naive(buf, n, base);
#else
    default: return u32toa_radix_reverse(buf, n, base);
#endif
    }
}

size_t u64toa_radix_snprintf(char buf[minimum_length(65)], uint64_t n, unsigned base)
{
    switch (base) {
#ifdef PRIb64
    case 2: return snprintf(buf, 65, "%"PRIb64, n);
#endif
    case 8: return snprintf(buf, 65, "%"PRIo64, n);
    case 10: return snprintf(buf, 65, "%"PRIu64, n);
    case 16: return snprintf(buf, 65, "%"PRIx64, n);
#ifdef TEST_NAIVE
    default: return u64toa_radix_naive(buf, n, base);
#else
    default: return u64toa_radix_reverse(buf, n, base);
#endif
    }
}

define_i32toa_radix(snprintf)
define_i64toa_radix(snprintf)

#endif // TEST_SNPRINTF

/*---- Benchmarking framework ----*/

/* Benchmark various alternatives and bases:
   - u32toa(), u64toa(), i32toa(), i64toa()
   - u32toa_radix(), u64toa_radix(), i32toa_radix(), i64toa_radix()
   - different implementations: naive, ...
   - various sets of values
 */

struct {
    const char *name;
    int enabled;
    size_t (*u32toa)(char buf[minimum_length(11)], uint32_t n);
    size_t (*i32toa)(char buf[minimum_length(12)], int32_t n);
    size_t (*u64toa)(char buf[minimum_length(21)], uint64_t n);
    size_t (*i64toa)(char buf[minimum_length(22)], int64_t n);
} impl[] =
{
#define TESTCASE(v) { #v, 2, u32toa_##v, i32toa_##v, u64toa_##v, i64toa_##v }
#ifdef TEST_SNPRINTF
    TESTCASE(snprintf),
#endif
#ifdef TEST_NAIVE
    TESTCASE(naive),
#endif
#ifdef TEST_BLOCKMOV
    TESTCASE(blockmov),
#endif
#ifdef TEST_REVERSE
    TESTCASE(reverse),
#endif
#ifdef TEST_LENGTH_EXPR
    TESTCASE(length_expr),
#endif
#ifdef TEST_LENGTH_LOOP
    TESTCASE(length_loop),
#endif
#ifdef TEST_SHIFTBUF
    TESTCASE(shift),
#endif
#ifdef TEST_DIGIT_PAIRS
    TESTCASE(pair),
#endif
#ifdef TEST_DIGIT_1PASS
    TESTCASE(pair_1pass),
#endif
#undef TESTCASE
};

struct {
    const char *name;
    int enabled;
    size_t (*u32toa_radix)(char buf[minimum_length(33)], uint32_t n, unsigned base);
    size_t (*i32toa_radix)(char buf[minimum_length(34)], int32_t n, unsigned base);
    size_t (*u64toa_radix)(char buf[minimum_length(65)], uint64_t n, unsigned base);
    size_t (*i64toa_radix)(char buf[minimum_length(66)], int64_t n, unsigned base);
} impl1[] =
{
#define TESTCASE(v) { #v, 2, u32toa_radix_##v, i32toa_radix_##v, u64toa_radix_##v, i64toa_radix_##v }
#ifdef TEST_SNPRINTF
    TESTCASE(snprintf),
#endif
#ifdef TEST_NAIVE
    TESTCASE(naive),
#endif
#ifdef TEST_REVERSE
    TESTCASE(reverse),
#endif
#ifdef TEST_DIV_TABLE
    TESTCASE(div_table),
#endif
#ifdef TEST_LENGTH_LOOP
    TESTCASE(length),
#endif
#ifdef TEST_DISPATCH
    TESTCASE(dispatch),
#endif
#undef TESTCASE
};

static clock_t start_timer(void) {
    clock_t t0, t;
    t0 = clock();
    // wait for next transition
    while ((t = clock()) == t0)
        continue;
    return t;
}

static clock_t stop_timer(clock_t t) {
    return clock() - t;
}

#define TIME(time, iter, s, w, e) {                                     \
        t = start_timer();                                              \
        uint64_t r0 = 0;                                                \
        for (int nn = 0; nn < iter; nn++) {                             \
            r0 = r0 * 1103515245 + 12345;                               \
            uint##w##_t mask, r = r0;                                   \
            for (int kk = 0; kk < 64; kk += w) {                        \
                for (mask = 1; mask != 0; ) {                           \
                    mask += mask;                                       \
                    if (s) {                                            \
                        int##w##_t x = (r & (mask - 1)) - (r & mask);   \
                        e;                                              \
                    } else {                                            \
                        uint##w##_t x = r & (mask - 1);                 \
                        e;                                              \
                    }                                                   \
                }                                                       \
                r ^= (r >> 1);                                          \
            }                                                           \
        }                                                               \
        t = stop_timer(t);                                              \
        if (time == 0 || time > t)                                      \
            time = t;                                                   \
    }

#define CHECK(tab, iter, s, w, e, check) {                              \
        uint64_t r0 = 0;                                                \
        for (int nn = 0; nn < iter; nn++) {                             \
            r0 = r0 * 1103515245 + 12345;                               \
            uint##w##_t mask, r = r0;                                   \
            for (int kk = 0; kk < 64; kk += w) {                        \
                for (mask = 1; mask != 0; ) {                           \
                    mask += mask;                                       \
                    if (s) {                                            \
                        int##w##_t x = (r & (mask - 1)) - (r & mask);   \
                        size_t len = tab.e;                             \
                        errno = 0;                                      \
                        int64_t y = check;                              \
                        if (errno || x != y || len != strlen(buf)) {    \
                            printf("error: %.*s_%s(%lld) base=%d -> %s -> %lld (errno=%d)\n", \
                                   (int)strcspn(#e, "("), #e, tab.name, \
                                   (long long)x, base, buf, (long long)y, errno); \
                            if (nerrors > 20) exit(1); \
                        }                                               \
                    } else {                                            \
                        uint##w##_t x = r & (mask - 1);                 \
                        size_t len = tab.e;                             \
                        errno = 0;                                      \
                        uint64_t y = check;                             \
                        if (errno || x != y || len != strlen(buf)) {    \
                            printf("error: %.*s_%s(%llu) base=%d -> %s -> %llu (errno=%d)\n", \
                                   (int)strcspn(#e, "("), #e, tab.name, \
                                   (unsigned long long)x, base, buf, (unsigned long long)y, errno); \
                            if (nerrors > 20) exit(1); \
                        }                                               \
                    }                                                   \
                }                                                       \
                r ^= (r >> 1);                                          \
            }                                                           \
        }                                                               \
    }

void show_usage(void) {
    printf("usage: test_conv [options] [bases] [filters]\n"
           "  options:\n"
           "    -h  --help     output this help\n"
           "    -t  --terse    only output average stats\n"
           "    -v  --verbose  output stats for all tested bases\n"
           "  bases\n"
           "     bases can be specified individually, as ranges or enumerations\n"
           "     supported bases are 2-36\n"
           "     examples:  10  2,8,16  2-10,16\n"
           "  filters are words that must be contained in variant names\n"
           "     examples:  naive  pri  len  rev\n"
           "  variants:\n"
#ifdef TEST_SNPRINTF
           "    snprintf     use snprintf for supported bases for reference\n"
#endif
#ifdef TEST_NAIVE
           "    naive        naive digit loop and copy loops\n"
#endif
#ifdef TEST_BLOCKMOV
           "    blockmov     same but move all digits together\n"
#endif
#ifdef TEST_REVERSE
           "    reverse      naive digit loop and reverse digit string\n"
#endif
#ifdef TEST_LENGTH_LOOP
           "    length_loop  compute length before digit loop using loop\n"
#endif
#ifdef TEST_LENGTH_EXPR
           "    length_expr  compute length before digit loop using expression\n"
#endif
#ifdef TEST_SHIFTBUF
           "    shift        generate up to 7 digit chunks in a register\n"
#endif
#ifdef TEST_DIGIT_PAIRS
           "    pair         generate 2 decimal digits at a time\n"
#endif
#ifdef TEST_DIGIT_1PASS
           "    pair_1pass   same but as a single left to right pass\n"
#endif
#ifdef TEST_DIV_TABLE
           "    div_table    use multiplier table instead of radix divisions\n"
#endif
#ifdef TEST_DISPATCH
           "    dispatch     use dispatch table to optimal 64-bit radix converters\n"
#endif
           );
}

int main(int argc, char *argv[]) {
    clock_t t;
    clock_t times[countof(impl)][4];
    clock_t times1[countof(impl1)][4][37];
    char buf[100];
    uint64_t bases = 0;
#define set_base(bases, b)  (*(bases) |= (1ULL << (b)))
#define has_base(bases, b)  ((bases) & (1ULL << (b)))
#define single_base(bases)  (!((bases) & ((bases) - 1)))
    int verbose = 0;
    int average = 1;
    int enabled = 3;

    memset(times, 0, sizeof times);
    memset(times1, 0, sizeof times1);

    for (int a = 1; a < argc; a++) {
        char *arg = argv[a];
        if (isdigit((unsigned char)*arg)) {
            while (isdigit((unsigned char)*arg)) {
                int b1 = strtol(arg, &arg, 10);
                set_base(&bases, b1);
                if (*arg == '-') {
                    int b2 = strtol(arg + 1, &arg, 10);
                    while (++b1 <= b2)
                        set_base(&bases, b1);
                }
                if (*arg == ',') {
                    arg++;
                    continue;
                }
            }
            if (*arg) {
                fprintf(stderr, "invalid option syntax: %s\n", argv[a]);
                return 2;
            }
            continue;
        } else if (!strcmp(arg, "-t") || !strcmp(arg, "--terse")) {
            verbose = 0;
            average = 1;
            continue;
        } else if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose")) {
            verbose = 1;
            continue;
        } else if (!strcmp(arg, "-h") || !strcmp(arg, "-?") || !strcmp(arg, "--help")) {
            show_usage();
            return 0;
        } else {
            int found = 0;
            for (size_t i = 0; i < countof(impl); i++) {
                if (strstr(impl[i].name, arg)) {
                    impl[i].enabled = 1;
                    found = 1;
                }
            }
            for (size_t i = 0; i < countof(impl1); i++) {
                if (strstr(impl1[i].name, arg)) {
                    impl1[i].enabled = 1;
                    found = 1;
                }
            }
            if (!found) {
                fprintf(stderr, "no variant for filter: %s\n", argv[a]);
                return 2;
            }
            enabled = 1;
            continue;
        }
    }
    if (!bases)
        bases = -1;
    if (single_base(bases)) {
        average = 0;
        verbose = 1;
    } else {
        average = 1;
    }

    int numvariant = 0;
    int numvariant1 = 0;
    int nerrors = 0;

    /* Checking for correctness */
    if (has_base(bases, 10)) {
        for (size_t i = 0; i < countof(impl); i++) {
            unsigned base = 10;
            if (impl[i].enabled & enabled) {
                CHECK(impl[i], 100000, 0, 32, u32toa(buf, x), strtoull(buf, NULL, 10));
                CHECK(impl[i], 100000, 1, 32, i32toa(buf, x), strtoll(buf, NULL, 10));
                CHECK(impl[i], 100000, 0, 64, u64toa(buf, x), strtoull(buf, NULL, 10));
                CHECK(impl[i], 100000, 1, 64, i64toa(buf, x), strtoll(buf, NULL, 10));
            }
        }
    }
    for (size_t i = 0; i < countof(impl1); i++) {
        if (impl1[i].enabled & enabled) {
            for (unsigned base = 2; base <= 36; base++) {
                if (has_base(bases, base)) {
                    CHECK(impl1[i], 1000, 0, 32, u32toa_radix(buf, x, base), strtoull(buf, NULL, base));
                    CHECK(impl1[i], 1000, 1, 32, i32toa_radix(buf, x, base), strtoll(buf, NULL, base));
                    CHECK(impl1[i], 1000, 0, 64, u64toa_radix(buf, x, base), strtoull(buf, NULL, base));
                    CHECK(impl1[i], 1000, 1, 64, i64toa_radix(buf, x, base), strtoll(buf, NULL, base));
                }
            }
        }
    }
    if (nerrors)
        return 1;

    /* Timing conversions */
    if (has_base(bases, 10)) {
        for (int rep = 0; rep < 100; rep++) {
            for (size_t i = 0; i < countof(impl); i++) {
                if (impl[i].enabled & enabled) {
                    numvariant++;
#ifdef TEST_SNPRINTF
                    if (strstr(impl[i].name, "snprintf")) { // avoid wrapper overhead
                        TIME(times[i][0], 1000, 0, 32, snprintf(buf, 11, "%"PRIu32, x));
                        TIME(times[i][1], 1000, 1, 32, snprintf(buf, 12, "%"PRIi32, x));
                        TIME(times[i][2], 1000, 0, 64, snprintf(buf, 21, "%"PRIu64, x));
                        TIME(times[i][3], 1000, 1, 64, snprintf(buf, 22, "%"PRIi64, x));
                    } else
#endif
                    {
                        TIME(times[i][0], 1000, 0, 32, impl[i].u32toa(buf, x));
                        TIME(times[i][1], 1000, 1, 32, impl[i].i32toa(buf, x));
                        TIME(times[i][2], 1000, 0, 64, impl[i].u64toa(buf, x));
                        TIME(times[i][3], 1000, 1, 64, impl[i].i64toa(buf, x));
                    }
                }
            }
        }
    }
    for (int rep = 0; rep < 10; rep++) {
        for (size_t i = 0; i < countof(impl1); i++) {
            if (impl1[i].enabled & enabled) {
                numvariant1++;
#ifdef TEST_SNPRINTF
                if (strstr(impl[i].name, "snprintf")) { // avoid wrapper overhead
#ifdef PRIb32
                    if (has_base(bases, 2)) {
                        unsigned base = 2;
                        TIME(times1[i][0][base], 1000, 0, 32, snprintf(buf, 33, "%"PRIb32, x));
                        TIME(times1[i][1][base], 1000, 1, 32, impl1[i].i32toa_radix(buf, x, base));
                        TIME(times1[i][2][base], 1000, 0, 64, snprintf(buf, 65, "%"PRIb64, x));
                        TIME(times1[i][3][base], 1000, 1, 64, impl1[i].i64toa_radix(buf, x, base));
                    }
#endif
                    if (has_base(bases, 8)) {
                        unsigned base = 8;
                        TIME(times1[i][0][base], 1000, 0, 32, snprintf(buf, 33, "%"PRIo32, x));
                        TIME(times1[i][1][base], 1000, 1, 32, impl1[i].i32toa_radix(buf, x, base));
                        TIME(times1[i][2][base], 1000, 0, 64, snprintf(buf, 65, "%"PRIo64, x));
                        TIME(times1[i][3][base], 1000, 1, 64, impl1[i].i64toa_radix(buf, x, base));
                    }
                    if (has_base(bases, 10)) {
                        unsigned base = 10;
                        TIME(times1[i][0][base], 1000, 0, 32, snprintf(buf, 33, "%"PRIu32, x));
                        TIME(times1[i][1][base], 1000, 1, 32, snprintf(buf, 34, "%"PRIi32, x));
                        TIME(times1[i][2][base], 1000, 0, 64, snprintf(buf, 64, "%"PRIu64, x));
                        TIME(times1[i][3][base], 1000, 1, 64, snprintf(buf, 65, "%"PRIi64, x));
                    }
                    if (has_base(bases, 16)) {
                        unsigned base = 16;
                        TIME(times1[i][0][base], 1000, 0, 32, snprintf(buf, 33, "%"PRIx32, x));
                        TIME(times1[i][1][base], 1000, 1, 32, impl1[i].i32toa_radix(buf, x, base));
                        TIME(times1[i][2][base], 1000, 0, 64, snprintf(buf, 65, "%"PRIx64, x));
                        TIME(times1[i][3][base], 1000, 1, 64, impl1[i].i64toa_radix(buf, x, base));
                    }
                } else
#endif
                {
                    for (unsigned base = 2; base <= 36; base++) {
                        if (has_base(bases, base)) {
                            TIME(times1[i][0][base], 1000, 0, 32, impl1[i].u32toa_radix(buf, x, base));
                            TIME(times1[i][1][base], 1000, 1, 32, impl1[i].i32toa_radix(buf, x, base));
                            TIME(times1[i][2][base], 1000, 0, 64, impl1[i].u64toa_radix(buf, x, base));
                            TIME(times1[i][3][base], 1000, 1, 64, impl1[i].i64toa_radix(buf, x, base));
                        }
                    }
                }
            }
        }
    }

    if (numvariant) {
        printf("%13s %10s %12s %12s %12s\n",
               "variant", "u32toa", "i32toa", "u64toa", "i64toa");
        for (size_t i = 0; i < countof(impl); i++) {
            if (impl[i].enabled & enabled) {
                printf("%13s", impl[i].name);
                for (int j = 0; j < 4; j++)
                    printf("   %6.2fns  ", times[i][j] * (1e9 / 1000 / 64 / CLOCKS_PER_SEC));
                printf("\n");
            }
        }
    }
    if (numvariant1) {
        printf("%9s rx  %12s %12s %12s %12s\n",
               "variant", "u32toa_radix", "i32toa_radix", "u64toa_radix", "i64toa_radix");
        for (size_t i = 0; i < countof(impl1); i++) {
            int numbases = 0;
            for (unsigned base = 2; base <= 36; base++) {
                if (has_base(bases, base)) {
                    if (times1[i][0][base]) {
                        numbases++;
                        for (int j = 0; j < 4; j++)
                            times1[i][j][1] += times1[i][j][base];
                        if (verbose) {
                            printf("%9s %-3d", impl1[i].name, base);
                            for (int j = 0; j < 4; j++) {
                                printf("   %6.2fns  ", times1[i][j][base] * (1e9 / 1000 / 64 / CLOCKS_PER_SEC));
                            }
                            printf("\n");
                        }
                    }
                }
            }
            if (average && numbases) {
                printf("%9s avg", impl1[i].name);
                for (int j = 0; j < 4; j++) {
                    printf("   %6.2fns  ", times1[i][j][1] * (1e9 / 1000 / 64 / numbases / CLOCKS_PER_SEC));
                }
                printf("\n");
            }
        }
    }
    return 0;
}