#ifdef __LINUX_TEST__
	#define PROGMEM
	#define pgm_read_dword(x) (*(x))
	#define pgm_read_word(x)  (*(x))
	#define pgm_read_byte(x)  (*(x))
#else
	#include <avr/pgmspace.h>
#endif

static const char letters[] PROGMEM =
	"0123456789"
	"abcdefghijklmnopqrstuvwxyz";


struct digits {
	unsigned long l[5];
	unsigned      d[6];
};

static const struct digits digits8 PROGMEM = {
	.l = {
		1073741824,
		134217728,
		16777216,
		2097152,
		262144,
	},
	.d = {
		32768,
		4096,
		512,
		64,
		8,
		1,
	}
};

static const struct digits digits10 PROGMEM = {
	.l = {
		1000000000,
		100000000,
		10000000,
		1000000,
		100000,
	},
	.d = {
		10000,
		1000,
		100,
		10,
		1,
	}
};

static const struct digits digits16 PROGMEM = {
	.l = {
		268435456,
		16777216,
		1048576,
		65536,
	},
	.d = {
		4096,
		256,
		16,
		1,
	}
};

static const struct digits digits32 PROGMEM = {
	.l = {
		1073741824,
		33554432,
		1048576,
	},
	.d = {
		32768,
		1024,
		32,
		1,
	}
};

static const struct digits digits36 PROGMEM = {
	.l = {
		2176782336,
		60466176,
		1679616,
	},
	.d = {
		46656,
		1296,
		36,
		1,
	}
};




char *	my_ultoa(unsigned long __val, char *__s, int base) {

	/* optimizing stack overhead */
	union {
		unsigned long l;
		struct {
			unsigned d;
			unsigned dv;
		};
	} check;
	const struct digits *d;
	unsigned char i, j = 0, k;

	switch(base) {
		case 8:
			d = &digits8;
			break;

		case 16:
			d = &digits16;
			break;

		case 32:
			d = &digits32;
			break;

		case 36:
			d = &digits36;
			break;

		default:
			d = &digits10;
			break;
	}

	if (__val >= (1L << 16)) {
		for (i = 0; i < sizeof(d->l) / sizeof(unsigned long); i++) {
			check.l = pgm_read_dword(d->l + i);
			if (!check.l)
				break;

			for (k = 0; check.l <= __val; k++)
				__val -= check.l;

			if (k || j)
				__s[j++] = pgm_read_byte(letters + k);
		}
	}

	check.dv = __val;

	for(i = 0; i < sizeof(d->d) / sizeof(unsigned); i++) {
		check.d = pgm_read_word(d->d + i);
		if (!check.d)
			break;

		for (k = 0; check.d <= check.dv; k++)
			check.dv -= check.d;

		if (k || j)
			__s[j++] = pgm_read_byte(letters + k);
	}

	if (!j)
		__s[j++] = '0';

	__s[j] = 0;
	return __s;
}

char * my_utoa(unsigned __val, char *__s, int base) {
	return my_ultoa(__val, __s, base);
}


char * my_ltoa (long __val, char *__s, int base) {
	if (__val >= 0)
		return my_ultoa(__val, __s, base);
	__s[0] = '-';
	return my_ultoa(-__val, __s + 1, base) - 1;
}

char * my_itoa (int __val, char *__s, int base) {
	if (__val >= 0)
		return my_utoa(__val, __s, base);
	__s[0] = '-';
	return my_utoa(-__val, __s + 1, base) - 1;
}