#include <blue/core/stream.h>
#include <blue/ds/number.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>

/*** PRIVATE DATA *************************************************************/

enum b_number_flags {
	NUMBER_F_INF = 0x01u,
	NUMBER_F_NAN = 0x02u,
};

struct b_number_p {
	b_number_type n_type;
	enum b_number_flags n_flags;
	union {
		int8_t v_int8;
		int16_t v_int16;
		int32_t v_int32;
		int64_t v_int64;
		float v_float32;
		double v_float64;
		char v_char;
		short v_short;
		int v_int;
		long v_long;
		long long v_longlong;
		float v_float;
		double v_double;
		size_t v_size_t;
	} n_value;
};

typedef int (*number_converter_t)(const struct b_number_p *, void *);

static number_converter_t converters[B_NUMBER_TYPE_COUNT][B_NUMBER_TYPE_COUNT];

/*** PRIVATE FUNCTIONS ********************************************************/

static b_number_type number_get_number_type(const struct b_number_p *number)
{
	return number->n_type;
}

static int number_get_value(
	const struct b_number_p *number, b_number_type type, void *value_ptr)
{
	b_number_type srb_type = number->n_type;
	b_number_type dest_type = type;

	number_converter_t converter = converters[srb_type][dest_type];
	if (!converter) {
		return -1;
	}

	return converter(number, value_ptr);
}

static bool number_is_integer(const struct b_number_p *number)
{
	switch (number->n_type) {
	case B_NUMBER_INT8:
	case B_NUMBER_INT16:
	case B_NUMBER_INT32:
	case B_NUMBER_INT64:
	case B_NUMBER_SIZE_T:
	case B_NUMBER_CHAR:
	case B_NUMBER_SHORT:
	case B_NUMBER_INT:
	case B_NUMBER_LONG:
	case B_NUMBER_LONGLONG:
	case B_NUMBER_HANDLE:
		return true;
	default:
		return false;
	}
}

static bool number_is_float(const struct b_number_p *number)
{
	switch (number->n_type) {
	case B_NUMBER_FLOAT:
	case B_NUMBER_DOUBLE:
	case B_NUMBER_FLOAT32:
	case B_NUMBER_FLOAT64:
		return true;
	default:
		return false;
	}
}

static bool number_is_inf(const struct b_number_p *number)
{
	return (number->n_flags & NUMBER_F_INF) != 0;
}

static bool number_is_inf_positive(const struct b_number_p *number)
{
	if (!(number->n_flags & NUMBER_F_INF)) {
		return false;
	}

	switch (number->n_type) {
	case B_NUMBER_INT8:
		return number->n_value.v_int8 >= 0;
	case B_NUMBER_INT16:
		return number->n_value.v_int16 >= 0;
	case B_NUMBER_INT32:
		return number->n_value.v_int32 >= 0;
	case B_NUMBER_INT64:
		return number->n_value.v_int64 >= 0;
	case B_NUMBER_FLOAT32:
		return number->n_value.v_float32 >= 0;
	case B_NUMBER_FLOAT64:
		return number->n_value.v_float64 >= 0;
	case B_NUMBER_CHAR:
		return number->n_value.v_char >= 0;
	case B_NUMBER_SHORT:
		return number->n_value.v_short >= 0;
	case B_NUMBER_INT:
		return number->n_value.v_int >= 0;
	case B_NUMBER_LONG:
		return number->n_value.v_long >= 0;
	case B_NUMBER_LONGLONG:
		return number->n_value.v_longlong >= 0;
	case B_NUMBER_FLOAT:
		return number->n_value.v_float >= 0;
	case B_NUMBER_DOUBLE:
		return number->n_value.v_double >= 0;
	case B_NUMBER_SIZE_T:
		return number->n_value.v_size_t >= 0;
	default:
		return true;
	}
}

static bool number_is_inf_negative(const struct b_number_p *number)
{
	if (!(number->n_flags & NUMBER_F_INF)) {
		return false;
	}

	switch (number->n_type) {
	case B_NUMBER_INT8:
		return number->n_value.v_int8 < 0;
	case B_NUMBER_INT16:
		return number->n_value.v_int16 < 0;
	case B_NUMBER_INT32:
		return number->n_value.v_int32 < 0;
	case B_NUMBER_INT64:
		return number->n_value.v_int64 < 0;
	case B_NUMBER_FLOAT32:
		return number->n_value.v_float32 < 0;
	case B_NUMBER_FLOAT64:
		return number->n_value.v_float64 < 0;
	case B_NUMBER_CHAR:
		return number->n_value.v_char < 0;
	case B_NUMBER_SHORT:
		return number->n_value.v_short < 0;
	case B_NUMBER_INT:
		return number->n_value.v_int < 0;
	case B_NUMBER_LONG:
		return number->n_value.v_long < 0;
	case B_NUMBER_LONGLONG:
		return number->n_value.v_longlong < 0;
	case B_NUMBER_FLOAT:
		return number->n_value.v_float < 0;
	case B_NUMBER_DOUBLE:
		return number->n_value.v_double < 0;
	case B_NUMBER_SIZE_T:
		return number->n_value.v_size_t < 0;
	default:
		return false;
	}
}

static bool number_is_nan(const struct b_number_p *number)
{
	return (number->n_flags & NUMBER_F_NAN) != 0;
}

static bool number_is_nan_positive(const struct b_number_p *number)
{
	if (!(number->n_flags & NUMBER_F_NAN)) {
		return false;
	}

	switch (number->n_type) {
	case B_NUMBER_INT8:
		return number->n_value.v_int8 >= 0;
	case B_NUMBER_INT16:
		return number->n_value.v_int16 >= 0;
	case B_NUMBER_INT32:
		return number->n_value.v_int32 >= 0;
	case B_NUMBER_INT64:
		return number->n_value.v_int64 >= 0;
	case B_NUMBER_FLOAT32:
		return number->n_value.v_float32 >= 0;
	case B_NUMBER_FLOAT64:
		return number->n_value.v_float64 >= 0;
	case B_NUMBER_CHAR:
		return number->n_value.v_char >= 0;
	case B_NUMBER_SHORT:
		return number->n_value.v_short >= 0;
	case B_NUMBER_INT:
		return number->n_value.v_int >= 0;
	case B_NUMBER_LONG:
		return number->n_value.v_long >= 0;
	case B_NUMBER_LONGLONG:
		return number->n_value.v_longlong >= 0;
	case B_NUMBER_FLOAT:
		return number->n_value.v_float >= 0;
	case B_NUMBER_DOUBLE:
		return number->n_value.v_double >= 0;
	case B_NUMBER_SIZE_T:
		return number->n_value.v_size_t >= 0;
	default:
		return true;
	}
}

static bool number_is_nan_negative(const struct b_number_p *number)
{
	if (!(number->n_flags & NUMBER_F_NAN)) {
		return false;
	}

	switch (number->n_type) {
	case B_NUMBER_INT8:
		return number->n_value.v_int8 < 0;
	case B_NUMBER_INT16:
		return number->n_value.v_int16 < 0;
	case B_NUMBER_INT32:
		return number->n_value.v_int32 < 0;
	case B_NUMBER_INT64:
		return number->n_value.v_int64 < 0;
	case B_NUMBER_FLOAT32:
		return number->n_value.v_float32 < 0;
	case B_NUMBER_FLOAT64:
		return number->n_value.v_float64 < 0;
	case B_NUMBER_CHAR:
		return number->n_value.v_char < 0;
	case B_NUMBER_SHORT:
		return number->n_value.v_short < 0;
	case B_NUMBER_INT:
		return number->n_value.v_int < 0;
	case B_NUMBER_LONG:
		return number->n_value.v_long < 0;
	case B_NUMBER_LONGLONG:
		return number->n_value.v_longlong < 0;
	case B_NUMBER_FLOAT:
		return number->n_value.v_float < 0;
	case B_NUMBER_DOUBLE:
		return number->n_value.v_double < 0;
	case B_NUMBER_SIZE_T:
		return number->n_value.v_size_t < 0;
	default:
		return false;
	}
}

static void number_set_inf_positive(struct b_number_p *number, bool v)
{
	if (!v) {
		number->n_flags &= ~NUMBER_F_INF;
		return;
	}

	number->n_flags &= ~NUMBER_F_NAN;
	number->n_flags |= NUMBER_F_INF;

	switch (number->n_type) {
	case B_NUMBER_INT8:
		number->n_value.v_int8 = 0;
		break;
	case B_NUMBER_INT16:
		number->n_value.v_int16 = 0;
		break;
	case B_NUMBER_INT32:
		number->n_value.v_int32 = 0;
		break;
	case B_NUMBER_INT64:
		number->n_value.v_int64 = 0;
		break;
	case B_NUMBER_FLOAT32:
		number->n_value.v_float32 = 0;
		break;
	case B_NUMBER_FLOAT64:
		number->n_value.v_float64 = 0;
		break;
	case B_NUMBER_CHAR:
		number->n_value.v_char = 0;
		break;
	case B_NUMBER_SHORT:
		number->n_value.v_short = 0;
		break;
	case B_NUMBER_INT:
		number->n_value.v_int = 0;
		break;
	case B_NUMBER_LONG:
		number->n_value.v_long = 0;
		break;
	case B_NUMBER_LONGLONG:
		number->n_value.v_longlong = 0;
		break;
	case B_NUMBER_FLOAT:
		number->n_value.v_float = 0;
		break;
	case B_NUMBER_DOUBLE:
		number->n_value.v_double = 0;
		break;
	case B_NUMBER_SIZE_T:
		number->n_value.v_size_t = 0;
		break;
	default:
		break;
	}
}

static void number_set_inf_negative(struct b_number_p *number, bool v)
{
	if (!v) {
		number->n_flags &= ~NUMBER_F_INF;
		return;
	}

	number->n_flags &= ~NUMBER_F_NAN;
	number->n_flags |= NUMBER_F_INF;

	switch (number->n_type) {
	case B_NUMBER_INT8:
		number->n_value.v_int8 = -1;
		break;
	case B_NUMBER_INT16:
		number->n_value.v_int16 = -1;
		break;
	case B_NUMBER_INT32:
		number->n_value.v_int32 = -1;
		break;
	case B_NUMBER_INT64:
		number->n_value.v_int64 = -1;
		break;
	case B_NUMBER_FLOAT32:
		number->n_value.v_float32 = -1;
		break;
	case B_NUMBER_FLOAT64:
		number->n_value.v_float64 = -1;
		break;
	case B_NUMBER_CHAR:
		number->n_value.v_char = -1;
		break;
	case B_NUMBER_SHORT:
		number->n_value.v_short = -1;
		break;
	case B_NUMBER_INT:
		number->n_value.v_int = -1;
		break;
	case B_NUMBER_LONG:
		number->n_value.v_long = -1;
		break;
	case B_NUMBER_LONGLONG:
		number->n_value.v_longlong = -1;
		break;
	case B_NUMBER_FLOAT:
		number->n_value.v_float = -1;
		break;
	case B_NUMBER_DOUBLE:
		number->n_value.v_double = -1;
		break;
	case B_NUMBER_SIZE_T:
		number->n_value.v_size_t = -1;
		break;
	default:
		break;
	}
}

static void number_set_nan_positive(struct b_number_p *number, bool v)
{
	if (!v) {
		number->n_flags &= ~NUMBER_F_NAN;
		return;
	}

	number->n_flags &= ~NUMBER_F_INF;
	number->n_flags |= NUMBER_F_NAN;

	switch (number->n_type) {
	case B_NUMBER_INT8:
		number->n_value.v_int8 = 0;
		break;
	case B_NUMBER_INT16:
		number->n_value.v_int16 = 0;
		break;
	case B_NUMBER_INT32:
		number->n_value.v_int32 = 0;
		break;
	case B_NUMBER_INT64:
		number->n_value.v_int64 = 0;
		break;
	case B_NUMBER_FLOAT32:
		number->n_value.v_float32 = 0;
		break;
	case B_NUMBER_FLOAT64:
		number->n_value.v_float64 = 0;
		break;
	case B_NUMBER_CHAR:
		number->n_value.v_char = 0;
		break;
	case B_NUMBER_SHORT:
		number->n_value.v_short = 0;
		break;
	case B_NUMBER_INT:
		number->n_value.v_int = 0;
		break;
	case B_NUMBER_LONG:
		number->n_value.v_long = 0;
		break;
	case B_NUMBER_LONGLONG:
		number->n_value.v_longlong = 0;
		break;
	case B_NUMBER_FLOAT:
		number->n_value.v_float = 0;
		break;
	case B_NUMBER_DOUBLE:
		number->n_value.v_double = 0;
		break;
	case B_NUMBER_SIZE_T:
		number->n_value.v_size_t = 0;
		break;
	default:
		break;
	}
}

static void number_set_nan_negative(struct b_number_p *number, bool v)
{
	if (!v) {
		number->n_flags &= ~NUMBER_F_NAN;
		return;
	}

	number->n_flags &= ~NUMBER_F_INF;
	number->n_flags |= NUMBER_F_NAN;

	switch (number->n_type) {
	case B_NUMBER_INT8:
		number->n_value.v_int8 = -1;
		break;
	case B_NUMBER_INT16:
		number->n_value.v_int16 = -1;
		break;
	case B_NUMBER_INT32:
		number->n_value.v_int32 = -1;
		break;
	case B_NUMBER_INT64:
		number->n_value.v_int64 = -1;
		break;
	case B_NUMBER_FLOAT32:
		number->n_value.v_float32 = -1;
		break;
	case B_NUMBER_FLOAT64:
		number->n_value.v_float64 = -1;
		break;
	case B_NUMBER_CHAR:
		number->n_value.v_char = -1;
		break;
	case B_NUMBER_SHORT:
		number->n_value.v_short = -1;
		break;
	case B_NUMBER_INT:
		number->n_value.v_int = -1;
		break;
	case B_NUMBER_LONG:
		number->n_value.v_long = -1;
		break;
	case B_NUMBER_LONGLONG:
		number->n_value.v_longlong = -1;
		break;
	case B_NUMBER_FLOAT:
		number->n_value.v_float = -1;
		break;
	case B_NUMBER_DOUBLE:
		number->n_value.v_double = -1;
		break;
	case B_NUMBER_SIZE_T:
		number->n_value.v_size_t = -1;
		break;
	default:
		break;
	}
}

static size_t number_data_size(const struct b_number_p *number)
{
	switch (number->n_type) {
	case B_NUMBER_INT8:
		return sizeof number->n_value.v_int8;
	case B_NUMBER_INT16:
		return sizeof number->n_value.v_int16;
	case B_NUMBER_INT32:
		return sizeof number->n_value.v_int32;
	case B_NUMBER_INT64:
		return sizeof number->n_value.v_int64;
	case B_NUMBER_FLOAT32:
		return sizeof number->n_value.v_float32;
	case B_NUMBER_FLOAT64:
		return sizeof number->n_value.v_float64;
	case B_NUMBER_CHAR:
		return sizeof number->n_value.v_char;
	case B_NUMBER_SHORT:
		return sizeof number->n_value.v_short;
	case B_NUMBER_INT:
		return sizeof number->n_value.v_int;
	case B_NUMBER_LONG:
		return sizeof number->n_value.v_long;
	case B_NUMBER_LONGLONG:
		return sizeof number->n_value.v_longlong;
	case B_NUMBER_FLOAT:
		return sizeof number->n_value.v_float;
	case B_NUMBER_DOUBLE:
		return sizeof number->n_value.v_double;
	case B_NUMBER_SIZE_T:
		return sizeof number->n_value.v_size_t;
	default:
		return 0;
	}
}

static void print_inf(const struct b_number_p *n, b_stream *out)
{
	switch (n->n_type) {
	case B_NUMBER_INT8:
		b_stream_write_string(out, n->n_value.v_int8 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT16:
		b_stream_write_string(out, n->n_value.v_int16 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT32:
		b_stream_write_string(out, n->n_value.v_int32 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT64:
		b_stream_write_string(out, n->n_value.v_int64 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT32:
		b_stream_write_string(
			out, n->n_value.v_float32 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT64:
		b_stream_write_string(
			out, n->n_value.v_float64 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_CHAR:
		b_stream_write_string(out, n->n_value.v_char < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_SHORT:
		b_stream_write_string(out, n->n_value.v_short < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT:
		b_stream_write_string(out, n->n_value.v_int < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_LONG:
		b_stream_write_string(out, n->n_value.v_long < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_LONGLONG:
		b_stream_write_string(
			out, n->n_value.v_longlong < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT:
		b_stream_write_string(out, n->n_value.v_float < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_DOUBLE:
		b_stream_write_string(out, n->n_value.v_double < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_SIZE_T:
		b_stream_write_string(out, n->n_value.v_size_t < 0 ? "-" : "", NULL);
		break;
	default:
		break;
	}

	b_stream_write_string(out, "INF", NULL);
}

static void print_nan(const struct b_number_p *n, b_stream *out)
{
	switch (n->n_type) {
	case B_NUMBER_INT8:
		b_stream_write_string(out, n->n_value.v_int8 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT16:
		b_stream_write_string(out, n->n_value.v_int16 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT32:
		b_stream_write_string(out, n->n_value.v_int32 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT64:
		b_stream_write_string(out, n->n_value.v_int64 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT32:
		b_stream_write_string(
			out, n->n_value.v_float32 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT64:
		b_stream_write_string(
			out, n->n_value.v_float64 < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_CHAR:
		b_stream_write_string(out, n->n_value.v_char < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_SHORT:
		b_stream_write_string(out, n->n_value.v_short < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_INT:
		b_stream_write_string(out, n->n_value.v_int < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_LONG:
		b_stream_write_string(out, n->n_value.v_long < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_LONGLONG:
		b_stream_write_string(
			out, n->n_value.v_longlong < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_FLOAT:
		b_stream_write_string(out, n->n_value.v_float < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_DOUBLE:
		b_stream_write_string(out, n->n_value.v_double < 0 ? "-" : "", NULL);
		break;
	case B_NUMBER_SIZE_T:
		b_stream_write_string(out, n->n_value.v_size_t < 0 ? "-" : "", NULL);
		break;
	default:
		break;
	}

	b_stream_write_string(out, "NaN", NULL);
}

/*** PUBLIC FUNCTIONS *********************************************************/

b_number *b_number_create(b_number_type type, void *value_ptr)
{
	b_number *n = b_object_create(B_TYPE_NUMBER);
	if (!n) {
		return NULL;
	}

	struct b_number_p *p = b_object_get_private(n, B_TYPE_NUMBER);

	p->n_type = type;

	if (!value_ptr) {
		return n;
	}

	switch (p->n_type) {
	case B_NUMBER_INT8:
		memcpy(&p->n_value.v_int8, value_ptr, sizeof p->n_value.v_int8);
		break;
	case B_NUMBER_INT16:
		memcpy(&p->n_value.v_int16, value_ptr, sizeof p->n_value.v_int16);
		break;
	case B_NUMBER_INT32:
		memcpy(&p->n_value.v_int32, value_ptr, sizeof p->n_value.v_int32);
		break;
	case B_NUMBER_INT64:
		memcpy(&p->n_value.v_int64, value_ptr, sizeof p->n_value.v_int64);
		break;
	case B_NUMBER_FLOAT32:
		memcpy(&p->n_value.v_float32, value_ptr,
		       sizeof p->n_value.v_float32);
		break;
	case B_NUMBER_FLOAT64:
		memcpy(&p->n_value.v_float64, value_ptr,
		       sizeof p->n_value.v_float64);
		break;
	case B_NUMBER_CHAR:
		memcpy(&p->n_value.v_char, value_ptr, sizeof p->n_value.v_char);
		break;
	case B_NUMBER_SHORT:
		memcpy(&p->n_value.v_short, value_ptr, sizeof p->n_value.v_short);
		break;
	case B_NUMBER_INT:
		memcpy(&p->n_value.v_int, value_ptr, sizeof p->n_value.v_int);
		break;
	case B_NUMBER_LONG:
		memcpy(&p->n_value.v_long, value_ptr, sizeof p->n_value.v_long);
		break;
	case B_NUMBER_LONGLONG:
		memcpy(&p->n_value.v_longlong, value_ptr,
		       sizeof p->n_value.v_longlong);
		break;
	case B_NUMBER_FLOAT:
		memcpy(&p->n_value.v_float, value_ptr, sizeof p->n_value.v_float);
		break;
	case B_NUMBER_DOUBLE:
		memcpy(&p->n_value.v_double, value_ptr, sizeof p->n_value.v_double);
		break;
	case B_NUMBER_SIZE_T:
		memcpy(&p->n_value.v_size_t, value_ptr, sizeof p->n_value.v_size_t);
		break;
	default:
		break;
	}

	return n;
}

b_number_type b_number_get_number_type(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_get_number_type, number);
}

int b_number_get_value(const b_number *number, b_number_type type, void *value_ptr)
{
	B_CLASS_DISPATCH_STATIC(
		B_TYPE_NUMBER, number_get_value, number, type, value_ptr);
}

bool b_number_is_integer(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_integer, number);
}

bool b_number_is_float(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_float, number);
}

bool b_number_is_inf(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf, number);
}

bool b_number_is_inf_positive(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf_positive, number);
}

bool b_number_is_inf_negative(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_inf_negative, number);
}

bool b_number_is_nan(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan, number);
}

bool b_number_is_nan_positive(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan_positive, number);
}

bool b_number_is_nan_negative(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_is_nan_negative, number);
}

void b_number_set_inf_positive(b_number *number, bool v)
{
	B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_inf_positive, number, v);
}

void b_number_set_inf_negative(b_number *number, bool v)
{
	B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_inf_negative, number, v);
}

void b_number_set_nan_positive(b_number *number, bool v)
{
	B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_nan_positive, number, v);
}

void b_number_set_nan_negative(b_number *number, bool v)
{
	B_CLASS_DISPATCH_STATIC(B_TYPE_NUMBER, number_set_nan_negative, number, v);
}

size_t b_number_data_size(const b_number *number)
{
	B_CLASS_DISPATCH_STATIC_0(B_TYPE_NUMBER, number_data_size, number);
}

/*** VIRTUAL FUNCTIONS ********************************************************/

static void number_init(b_object *obj, void *priv)
{
	struct b_number_p *number = priv;
}

static void number_fini(b_object *obj, void *priv)
{
	struct b_number_p *number = priv;
}

static void number_to_string(const b_object *obj, b_stream *out)
{
	struct b_number_p *number = b_object_get_private(obj, B_TYPE_NUMBER);

	if (number->n_flags & NUMBER_F_INF) {
		print_inf(number, out);
		return;
	}

	if (number->n_flags & NUMBER_F_NAN) {
		print_nan(number, out);
		return;
	}

	switch (number->n_type) {
	case B_NUMBER_INT8:
		b_stream_write_fmt(out, NULL, "%" PRIu8, number->n_value.v_int8);
		break;
	case B_NUMBER_INT16:
		b_stream_write_fmt(out, NULL, "%" PRIu16, number->n_value.v_int16);
		break;
	case B_NUMBER_INT32:
		b_stream_write_fmt(out, NULL, "%" PRIu32, number->n_value.v_int32);
		break;
	case B_NUMBER_INT64:
		b_stream_write_fmt(out, NULL, "%" PRIu64, number->n_value.v_int64);
		break;
	case B_NUMBER_FLOAT32:
		b_stream_write_fmt(out, NULL, "%f", number->n_value.v_float32);
		break;
	case B_NUMBER_FLOAT64:
		b_stream_write_fmt(out, NULL, "%lf", number->n_value.v_float64);
		break;
	case B_NUMBER_CHAR:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_char);
		break;
	case B_NUMBER_SHORT:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_short);
		break;
	case B_NUMBER_INT:
		b_stream_write_fmt(out, NULL, "%d", number->n_value.v_int);
		break;
	case B_NUMBER_LONG:
		b_stream_write_fmt(out, NULL, "%ld", number->n_value.v_long);
		break;
	case B_NUMBER_LONGLONG:
		b_stream_write_fmt(out, NULL, "%lld", number->n_value.v_longlong);
		break;
	case B_NUMBER_FLOAT:
		b_stream_write_fmt(out, NULL, "%f", number->n_value.v_float);
		break;
	case B_NUMBER_DOUBLE:
		b_stream_write_fmt(out, NULL, "%lf", number->n_value.v_double);
		break;
	case B_NUMBER_SIZE_T:
		b_stream_write_fmt(out, NULL, "%zu", number->n_value.v_size_t);
		break;
	case B_NUMBER_HANDLE:
		b_stream_write_fmt(
			out, NULL, "%016" PRIx64, number->n_value.v_size_t);
		break;
	default:
		break;
	}
}

/*** CLASS DEFINITION *********************************************************/

B_TYPE_CLASS_DEFINITION_BEGIN(b_number)
	B_TYPE_CLASS_INTERFACE_BEGIN(b_object, B_TYPE_OBJECT)
		B_INTERFACE_ENTRY(to_string) = number_to_string;
	B_TYPE_CLASS_INTERFACE_END(b_object, B_TYPE_OBJECT)
B_TYPE_CLASS_DEFINITION_END(b_number)

B_TYPE_DEFINITION_BEGIN(b_number)
	B_TYPE_ID(0xa713b0ea, 0x240f, 0x4bc5, 0xbe73, 0xbc3e56401bd3);
	B_TYPE_CLASS(b_number_class);
	B_TYPE_INSTANCE_PRIVATE(struct b_number_p);
	B_TYPE_INSTANCE_INIT(number_init);
	B_TYPE_INSTANCE_FINI(number_fini);
B_TYPE_DEFINITION_END(b_number)

/*** MISC FUNCTIONS ***********************************************************/

/* ++++++++++++++++++ int8 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int8_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = (int64_t)number->n_value.v_int8;
	return 0;
}

static int int8_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int8;
	return 0;
}

static int int8_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_int8;
	return 0;
}

static int int8_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = (long)number->n_value.v_int8;
	return 0;
}

static int int8_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = (long long)number->n_value.v_int8;
	return 0;
}

static int int8_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int8;
	return 0;
}

static int int8_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = (size_t)number->n_value.v_int8;
	return 0;
}

/* ++++++++++++++++++ int16 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int16_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int16;
	return 0;
}

static int int16_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int16;
	return 0;
}

static int int16_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int16;
	return 0;
}

static int int16_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int16;
	return 0;
}

/* ++++++++++++++++++ int32 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int32_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int32;
	return 0;
}

static int int32_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int32;
	return 0;
}

static int int32_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int32;
	return 0;
}

static int int32_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int32;
	return 0;
}

static int int32_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int32;
	return 0;
}

static int int32_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int32;
	return 0;
}

static int int32_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int32;
	return 0;
}

static int int32_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int32;
	return 0;
}

/* ++++++++++++++++++ int64 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int64_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_int64;
	return 0;
}

static int int64_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int64;
	return 0;
}

static int int64_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = (double)number->n_value.v_int64;
	return 0;
}

static int int64_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_int64;
	return 0;
}

static int int64_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_int64;
	return 0;
}

static int int64_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_int64;
	return 0;
}

static int int64_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int64;
	return 0;
}

static int int64_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = (float)number->n_value.v_int64;
	return 0;
}

static int int64_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = (double)number->n_value.v_int64;
	return 0;
}

static int int64_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int64;
	return 0;
}

/* ++++++++++++++++++ float32 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float32_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = (int8_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = (int16_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = (int32_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = (int64_t)number->n_value.v_float32;
	return 0;
}

static int float32_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = (char)number->n_value.v_float32;
	return 0;
}

static int float32_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = (short)number->n_value.v_float32;
	return 0;
}

static int float32_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = (int)number->n_value.v_float32;
	return 0;
}

static int float32_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float32;
	return 0;
}

static int float32_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float32;
	return 0;
}

/* ++++++++++++++++++ float64 -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float64_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float64;
	return 0;
}

static int float64_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float64;
	return 0;
}

/* ++++++++++++++++++ char -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int char_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_char;
	return 0;
}

static int char_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_char;
	return 0;
}

/* ++++++++++++++++++ short -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int short_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_short;
	return 0;
}

static int short_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_short;
	return 0;
}

/* ++++++++++++++++++ int -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int int_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_int;
	return 0;
}

static int int_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_int;
	return 0;
}

/* ++++++++++++++++++ long -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int long_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_long;
	return 0;
}

static int long_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_long;
	return 0;
}

/* ++++++++++++++++++ longlong -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int longlong_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_longlong;
	return 0;
}

static int longlong_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_longlong;
	return 0;
}

/* ++++++++++++++++++ float -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int float_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_float;
	return 0;
}

static int float_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_float;
	return 0;
}

/* ++++++++++++++++++ double -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int double_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_double;
	return 0;
}

static int double_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_double;
	return 0;
}

/* ++++++++++++++++++ size_t -> xyz CONVERTER CALLBACKS ++++++++++++++++++ */

static int size_t_to_int8(const struct b_number_p *number, void *value_ptr)
{
	*(int8_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int16(const struct b_number_p *number, void *value_ptr)
{
	*(int16_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int32(const struct b_number_p *number, void *value_ptr)
{
	*(int32_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int64(const struct b_number_p *number, void *value_ptr)
{
	*(int64_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float32(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float64(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_char(const struct b_number_p *number, void *value_ptr)
{
	*(char *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_short(const struct b_number_p *number, void *value_ptr)
{
	*(short *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_int(const struct b_number_p *number, void *value_ptr)
{
	*(int *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_long(const struct b_number_p *number, void *value_ptr)
{
	*(long *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_longlong(const struct b_number_p *number, void *value_ptr)
{
	*(long long *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_float(const struct b_number_p *number, void *value_ptr)
{
	*(float *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_double(const struct b_number_p *number, void *value_ptr)
{
	*(double *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static int size_t_to_size_t(const struct b_number_p *number, void *value_ptr)
{
	*(size_t *)value_ptr = number->n_value.v_size_t;
	return 0;
}

static number_converter_t converters[B_NUMBER_TYPE_COUNT][B_NUMBER_TYPE_COUNT] = {
	/* int8_t -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT8] = {
		[B_NUMBER_INT8]     = int8_to_int8,
		[B_NUMBER_INT16]    = int8_to_int16,
		[B_NUMBER_INT32]    = int8_to_int32,
		[B_NUMBER_INT64]    = int8_to_int64,
		[B_NUMBER_FLOAT32]  = int8_to_float32,
		[B_NUMBER_FLOAT64]  = int8_to_float64,
		[B_NUMBER_CHAR]     = int8_to_char,
		[B_NUMBER_SHORT]    = int8_to_short,
		[B_NUMBER_INT]      = int8_to_int,
		[B_NUMBER_LONG]     = int8_to_long,
		[B_NUMBER_LONGLONG] = int8_to_longlong,
		[B_NUMBER_FLOAT]    = int8_to_float,
		[B_NUMBER_DOUBLE]   = int8_to_double,
		[B_NUMBER_SIZE_T]   = int8_to_size_t,
	},
	/* int16 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT16] = {
		[B_NUMBER_INT8]     = int16_to_int8,
		[B_NUMBER_INT16]    = int16_to_int16,
		[B_NUMBER_INT32]    = int16_to_int32,
		[B_NUMBER_INT64]    = int16_to_int64,
		[B_NUMBER_FLOAT32]  = int16_to_float32,
		[B_NUMBER_FLOAT64]  = int16_to_float64,
		[B_NUMBER_CHAR]     = int16_to_char,
		[B_NUMBER_SHORT]    = int16_to_short,
		[B_NUMBER_INT]      = int16_to_int,
		[B_NUMBER_LONG]     = int16_to_long,
		[B_NUMBER_LONGLONG] = int16_to_longlong,
		[B_NUMBER_FLOAT]    = int16_to_float,
		[B_NUMBER_DOUBLE]   = int16_to_double,
		[B_NUMBER_SIZE_T]   = int16_to_size_t,
	},
	/* int32 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT32] = {
		[B_NUMBER_INT8]     = int32_to_int8,
		[B_NUMBER_INT16]    = int32_to_int16,
		[B_NUMBER_INT32]    = int32_to_int32,
		[B_NUMBER_INT64]    = int32_to_int64,
		[B_NUMBER_FLOAT32]  = int32_to_float32,
		[B_NUMBER_FLOAT64]  = int32_to_float64,
		[B_NUMBER_CHAR]     = int32_to_char,
		[B_NUMBER_SHORT]    = int32_to_short,
		[B_NUMBER_INT]      = int32_to_int,
		[B_NUMBER_LONG]     = int32_to_long,
		[B_NUMBER_LONGLONG] = int32_to_longlong,
		[B_NUMBER_FLOAT]    = int32_to_float,
		[B_NUMBER_DOUBLE]   = int32_to_double,
		[B_NUMBER_SIZE_T]   = int32_to_size_t,
	},
	/* int64 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT64] = {
		[B_NUMBER_INT8]     = int64_to_int8,
		[B_NUMBER_INT16]    = int64_to_int16,
		[B_NUMBER_INT32]    = int64_to_int32,
		[B_NUMBER_INT64]    = int64_to_int64,
		[B_NUMBER_FLOAT32]  = int64_to_float32,
		[B_NUMBER_FLOAT64]  = int64_to_float64,
		[B_NUMBER_CHAR]     = int64_to_char,
		[B_NUMBER_SHORT]    = int64_to_short,
		[B_NUMBER_INT]      = int64_to_int,
		[B_NUMBER_LONG]     = int64_to_long,
		[B_NUMBER_LONGLONG] = int64_to_longlong,
		[B_NUMBER_FLOAT]    = int64_to_float,
		[B_NUMBER_DOUBLE]   = int64_to_double,
		[B_NUMBER_SIZE_T]   = int64_to_size_t,
	},
	/* float32 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT32] = {
		[B_NUMBER_INT8]     = float32_to_int8,
		[B_NUMBER_INT16]    = float32_to_int16,
		[B_NUMBER_INT32]    = float32_to_int32,
		[B_NUMBER_INT64]    = float32_to_int64,
		[B_NUMBER_FLOAT32]  = float32_to_float32,
		[B_NUMBER_FLOAT64]  = float32_to_float64,
		[B_NUMBER_CHAR]     = float32_to_char,
		[B_NUMBER_SHORT]    = float32_to_short,
		[B_NUMBER_INT]      = float32_to_int,
		[B_NUMBER_LONG]     = float32_to_long,
		[B_NUMBER_LONGLONG] = float32_to_longlong,
		[B_NUMBER_FLOAT]    = float32_to_float,
		[B_NUMBER_DOUBLE]   = float32_to_double,
		[B_NUMBER_SIZE_T]   = float32_to_size_t,
	},
	/* float64 -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT64] = {
		[B_NUMBER_INT8]     = float64_to_int8,
		[B_NUMBER_INT16]    = float64_to_int16,
		[B_NUMBER_INT32]    = float64_to_int32,
		[B_NUMBER_INT64]    = float64_to_int64,
		[B_NUMBER_FLOAT32]  = float64_to_float32,
		[B_NUMBER_FLOAT64]  = float64_to_float64,
		[B_NUMBER_CHAR]     = float64_to_char,
		[B_NUMBER_SHORT]    = float64_to_short,
		[B_NUMBER_INT]      = float64_to_int,
		[B_NUMBER_LONG]     = float64_to_long,
		[B_NUMBER_LONGLONG] = float64_to_longlong,
		[B_NUMBER_FLOAT]    = float64_to_float,
		[B_NUMBER_DOUBLE]   = float64_to_double,
		[B_NUMBER_SIZE_T]   = float64_to_size_t,
	},
	/* char > xyz CONVERTER CALLBACKS */
	[B_NUMBER_CHAR] = {
		[B_NUMBER_INT8]     = char_to_int8,
		[B_NUMBER_INT16]    = char_to_int16,
		[B_NUMBER_INT32]    = char_to_int32,
		[B_NUMBER_INT64]    = char_to_int64,
		[B_NUMBER_FLOAT32]  = char_to_float32,
		[B_NUMBER_FLOAT64]  = char_to_float64,
		[B_NUMBER_CHAR]     = char_to_char,
		[B_NUMBER_SHORT]    = char_to_short,
		[B_NUMBER_INT]      = char_to_int,
		[B_NUMBER_LONG]     = char_to_long,
		[B_NUMBER_LONGLONG] = char_to_longlong,
		[B_NUMBER_FLOAT]    = char_to_float,
		[B_NUMBER_DOUBLE]   = char_to_double,
		[B_NUMBER_SIZE_T]   = char_to_size_t,
	},
	/* short -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_SHORT] = {
		[B_NUMBER_INT8]     = short_to_int8,
		[B_NUMBER_INT16]    = short_to_int16,
		[B_NUMBER_INT32]    = short_to_int32,
		[B_NUMBER_INT64]    = short_to_int64,
		[B_NUMBER_FLOAT32]  = short_to_float32,
		[B_NUMBER_FLOAT64]  = short_to_float64,
		[B_NUMBER_CHAR]     = short_to_char,
		[B_NUMBER_SHORT]    = short_to_short,
		[B_NUMBER_INT]      = short_to_int,
		[B_NUMBER_LONG]     = short_to_long,
		[B_NUMBER_LONGLONG] = short_to_longlong,
		[B_NUMBER_FLOAT]    = short_to_float,
		[B_NUMBER_DOUBLE]   = short_to_double,
		[B_NUMBER_SIZE_T]   = short_to_size_t,
	},
	/* int -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_INT] = {
		[B_NUMBER_INT8]     = int_to_int8,
		[B_NUMBER_INT16]    = int_to_int16,
		[B_NUMBER_INT32]    = int_to_int32,
		[B_NUMBER_INT64]    = int_to_int64,
		[B_NUMBER_FLOAT32]  = int_to_float32,
		[B_NUMBER_FLOAT64]  = int_to_float64,
		[B_NUMBER_CHAR]     = int_to_char,
		[B_NUMBER_SHORT]    = int_to_short,
		[B_NUMBER_INT]      = int_to_int,
		[B_NUMBER_LONG]     = int_to_long,
		[B_NUMBER_LONGLONG] = int_to_longlong,
		[B_NUMBER_FLOAT]    = int_to_float,
		[B_NUMBER_DOUBLE]   = int_to_double,
		[B_NUMBER_SIZE_T]   = int_to_size_t,
	},
	/* long -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_LONG] = {
		[B_NUMBER_INT8]     = long_to_int8,
		[B_NUMBER_INT16]    = long_to_int16,
		[B_NUMBER_INT32]    = long_to_int32,
		[B_NUMBER_INT64]    = long_to_int64,
		[B_NUMBER_FLOAT32]  = long_to_float32,
		[B_NUMBER_FLOAT64]  = long_to_float64,
		[B_NUMBER_CHAR]     = long_to_char,
		[B_NUMBER_SHORT]    = long_to_short,
		[B_NUMBER_INT]      = long_to_int,
		[B_NUMBER_LONG]     = long_to_long,
		[B_NUMBER_LONGLONG] = long_to_longlong,
		[B_NUMBER_FLOAT]    = long_to_float,
		[B_NUMBER_DOUBLE]   = long_to_double,
		[B_NUMBER_SIZE_T]   = long_to_size_t,
	},
	/* longlong -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_LONGLONG] = {
		[B_NUMBER_INT8]     = longlong_to_int8,
		[B_NUMBER_INT16]    = longlong_to_int16,
		[B_NUMBER_INT32]    = longlong_to_int32,
		[B_NUMBER_INT64]    = longlong_to_int64,
		[B_NUMBER_FLOAT32]  = longlong_to_float32,
		[B_NUMBER_FLOAT64]  = longlong_to_float64,
		[B_NUMBER_CHAR]     = longlong_to_char,
		[B_NUMBER_SHORT]    = longlong_to_short,
		[B_NUMBER_INT]      = longlong_to_int,
		[B_NUMBER_LONG]     = longlong_to_long,
		[B_NUMBER_LONGLONG] = longlong_to_longlong,
		[B_NUMBER_FLOAT]    = longlong_to_float,
		[B_NUMBER_DOUBLE]   = longlong_to_double,
		[B_NUMBER_SIZE_T]   = longlong_to_size_t,
	},
	/* float -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_FLOAT] = {
		[B_NUMBER_INT8]     = float_to_int8,
		[B_NUMBER_INT16]    = float_to_int16,
		[B_NUMBER_INT32]    = float_to_int32,
		[B_NUMBER_INT64]    = float_to_int64,
		[B_NUMBER_FLOAT32]  = float_to_float32,
		[B_NUMBER_FLOAT64]  = float_to_float64,
		[B_NUMBER_CHAR]     = float_to_char,
		[B_NUMBER_SHORT]    = float_to_short,
		[B_NUMBER_INT]      = float_to_int,
		[B_NUMBER_LONG]     = float_to_long,
		[B_NUMBER_LONGLONG] = float_to_longlong,
		[B_NUMBER_FLOAT]    = float_to_float,
		[B_NUMBER_DOUBLE]   = float_to_double,
		[B_NUMBER_SIZE_T]   = float_to_size_t,
	},
	/* double -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_DOUBLE] = {
		[B_NUMBER_INT8]     = double_to_int8,
		[B_NUMBER_INT16]    = double_to_int16,
		[B_NUMBER_INT32]    = double_to_int32,
		[B_NUMBER_INT64]    = double_to_int64,
		[B_NUMBER_FLOAT32]  = double_to_float32,
		[B_NUMBER_FLOAT64]  = double_to_float64,
		[B_NUMBER_CHAR]     = double_to_char,
		[B_NUMBER_SHORT]    = double_to_short,
		[B_NUMBER_INT]      = double_to_int,
		[B_NUMBER_LONG]     = double_to_long,
		[B_NUMBER_LONGLONG] = double_to_longlong,
		[B_NUMBER_FLOAT]    = double_to_float,
		[B_NUMBER_DOUBLE]   = double_to_double,
		[B_NUMBER_SIZE_T]   = double_to_size_t,
	},
	/* size_t -> xyz CONVERTER CALLBACKS */
	[B_NUMBER_SIZE_T] = {
		[B_NUMBER_INT8]     = size_t_to_int8,
		[B_NUMBER_INT16]    = size_t_to_int16,
		[B_NUMBER_INT32]    = size_t_to_int32,
		[B_NUMBER_INT64]    = size_t_to_int64,
		[B_NUMBER_FLOAT32]  = size_t_to_float32,
		[B_NUMBER_FLOAT64]  = size_t_to_float64,
		[B_NUMBER_CHAR]     = size_t_to_char,
		[B_NUMBER_SHORT]    = size_t_to_short,
		[B_NUMBER_INT]      = size_t_to_int,
		[B_NUMBER_LONG]     = size_t_to_long,
		[B_NUMBER_LONGLONG] = size_t_to_longlong,
		[B_NUMBER_FLOAT]    = size_t_to_float,
		[B_NUMBER_DOUBLE]   = size_t_to_double,
		[B_NUMBER_SIZE_T]   = size_t_to_size_t,
	},
};