diff --git a/include/linux/kernel.h b/include/linux/kernel.h
new file mode 100644
index 0000000000000000000000000000000000000000..f7ddbda71c3827f82813e9c208c13c91a3b142a7
--- /dev/null
+++ b/include/linux/kernel.h
@@ -0,0 +1,7 @@
+#ifndef _KERNEL_H
+#define _KERNEL_H
+
+int printk(const char* fmt, ...);
+
+#endif
+
diff --git a/include/stdarg.h b/include/stdarg.h
new file mode 100644
index 0000000000000000000000000000000000000000..ebb37ccc2b12ba032eed3d9ffd8adb2573629ad9
--- /dev/null
+++ b/include/stdarg.h
@@ -0,0 +1,29 @@
+#ifndef _STDARG_H
+#define _STDARG_H
+
+typedef char *va_list;
+
+/* Amount of space required in an argument list for an arg of type TYPE.
+ *    TYPE may alternatively be an expression whose type is used.  */
+
+#define __va_rounded_size(TYPE)  \
+      (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int))
+
+#ifndef __sparc__
+#define va_start(AP, LASTARG)                       \
+     (AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
+#else
+#define va_start(AP, LASTARG)                       \
+     (__builtin_saveregs (),                        \
+        AP = ((char *) &(LASTARG) + __va_rounded_size (LASTARG)))
+#endif
+
+void va_end (va_list);      /* Defined in gnulib */
+#define va_end(AP)
+
+#define va_arg(AP, TYPE)                        \
+     (AP += __va_rounded_size (TYPE),                   \
+        *((TYPE *) (AP - __va_rounded_size (TYPE))))
+
+#endif /* _STDARG_H */
+
diff --git a/include/stddef.h b/include/stddef.h
new file mode 100644
index 0000000000000000000000000000000000000000..c340e05fb2b43243450038c8b8ca792552b59952
--- /dev/null
+++ b/include/stddef.h
@@ -0,0 +1,19 @@
+#ifndef _STDDEF_H
+#define _STDDEF_H
+
+#ifndef _PTRDIFF_T
+#define _PTRDIFF_T
+typedef long ptrdiff_t;
+#endif
+
+#ifndef _SIZE_T
+#define _SIZE_T
+typedef unsigned long size_t;
+#endif
+
+#undef NULL
+#define NULL ((void *)0)
+
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
diff --git a/include/string.h b/include/string.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ebb2025ee55a9cada7368f385fe3836785468e4
--- /dev/null
+++ b/include/string.h
@@ -0,0 +1,402 @@
+#ifndef _STRING_H_
+#define _STRING_H_
+
+#ifndef NULL
+#define NULL ((void *) 0)
+#endif
+
+#ifndef _SIZE_T
+#define _SIZE_T
+typedef unsigned int size_t;
+#endif
+
+extern char * strerror(int errno);
+
+/*
+ * This string-include defines all string functions as inline
+ * functions. Use gcc. It also assumes ds=es=data space, this should be
+ * normal. Most of the string-functions are rather heavily hand-optimized,
+ * see especially strtok,strstr,str[c]spn. They should work, but are not
+ * very easy to understand. Everything is done entirely within the register
+ * set, making the functions fast and clean. String instructions have been
+ * used through-out, making for "slightly" unclear code :-)
+ *
+ *      (C) 1991 Linus Torvalds
+ */
+ 
+extern inline char * strcpy(char * dest,const char *src)
+{
+__asm__("cld\n"
+    "1:\tlodsb\n\t"
+    "stosb\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b"
+    ::"S" (src),"D" (dest):"si","di","ax");
+return dest;
+}
+
+extern inline char * strncpy(char * dest,const char *src,int count)
+{
+__asm__("cld\n"
+    "1:\tdecl %2\n\t"
+    "js 2f\n\t"
+    "lodsb\n\t"
+    "stosb\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b\n\t"
+    "rep\n\t"
+    "stosb\n"
+    "2:"
+    ::"S" (src),"D" (dest),"c" (count):"si","di","ax","cx");
+return dest;
+}
+
+extern inline char * strcat(char * dest,const char * src)
+{
+__asm__("cld\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "decl %1\n"
+    "1:\tlodsb\n\t"
+    "stosb\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b"
+    ::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff):"si","di","ax","cx");
+return dest;
+}
+
+extern inline char * strncat(char * dest,const char * src,int count)
+{
+__asm__("cld\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "decl %1\n\t"
+    "movl %4,%3\n"
+    "1:\tdecl %3\n\t"
+    "js 2f\n\t"
+    "lodsb\n\t"
+    "stosb\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b\n"
+    "2:\txorl %2,%2\n\t"
+    "stosb"
+    ::"S" (src),"D" (dest),"a" (0),"c" (0xffffffff),"g" (count)
+    :"si","di","ax","cx");
+return dest;
+}
+
+extern inline int strcmp(const char * cs,const char * ct)
+{
+register int __res __asm__("ax");
+__asm__("cld\n"
+    "1:\tlodsb\n\t"
+    "scasb\n\t"
+    "jne 2f\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b\n\t"
+    "xorl %%eax,%%eax\n\t"
+    "jmp 3f\n"
+    "2:\tmovl $1,%%eax\n\t"
+    "jl 3f\n\t"
+    "negl %%eax\n"
+    "3:"
+    :"=a" (__res):"D" (cs),"S" (ct):"si","di");
+return __res;
+}
+
+extern inline int strncmp(const char * cs,const char * ct,int count)
+{
+register int __res __asm__("ax");
+__asm__("cld\n"
+    "1:\tdecl %3\n\t"
+    "js 2f\n\t"
+    "lodsb\n\t"
+    "scasb\n\t"
+    "jne 3f\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b\n"
+    "2:\txorl %%eax,%%eax\n\t"
+    "jmp 4f\n"
+    "3:\tmovl $1,%%eax\n\t"
+    "jl 4f\n\t"
+    "negl %%eax\n"
+    "4:"
+    :"=a" (__res):"D" (cs),"S" (ct),"c" (count):"si","di","cx");
+return __res;
+}
+
+extern inline char * strchr(const char * s,char c)
+{
+register char * __res __asm__("ax");
+__asm__("cld\n\t"
+    "movb %%al,%%ah\n"
+    "1:\tlodsb\n\t"
+    "cmpb %%ah,%%al\n\t"
+    "je 2f\n\t"
+    "testb %%al,%%al\n\t"
+    "jne 1b\n\t"
+    "movl $1,%1\n"
+    "2:\tmovl %1,%0\n\t"
+    "decl %0"
+    :"=a" (__res):"S" (s),"0" (c):"si");
+return __res;
+}
+
+extern inline char * strrchr(const char * s,char c)
+{
+register char * __res __asm__("dx");
+__asm__("cld\n\t"
+    "movb %%al,%%ah\n"
+    "1:\tlodsb\n\t"
+    "cmpb %%ah,%%al\n\t"
+    "jne 2f\n\t"
+    "movl %%esi,%0\n\t"
+    "decl %0\n"
+    "2:\ttestb %%al,%%al\n\t"
+    "jne 1b"
+    :"=d" (__res):"0" (0),"S" (s),"a" (c):"ax","si");
+return __res;
+}
+
+extern inline int strspn(const char * cs, const char * ct)
+{
+register char * __res __asm__("si");
+__asm__("cld\n\t"
+    "movl %4,%%edi\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "notl %%ecx\n\t"
+    "decl %%ecx\n\t"
+    "movl %%ecx,%%edx\n"
+    "1:\tlodsb\n\t"
+    "testb %%al,%%al\n\t"
+    "je 2f\n\t"
+    "movl %4,%%edi\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "je 1b\n"
+    "2:\tdecl %0"
+    :"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
+    :"ax","cx","dx","di");
+return __res-cs;
+}
+
+extern inline int strcspn(const char * cs, const char * ct)
+{
+register char * __res __asm__("si");
+__asm__("cld\n\t"
+    "movl %4,%%edi\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "notl %%ecx\n\t"
+    "decl %%ecx\n\t"
+    "movl %%ecx,%%edx\n"
+    "1:\tlodsb\n\t"
+    "testb %%al,%%al\n\t"
+    "je 2f\n\t"
+    "movl %4,%%edi\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "jne 1b\n"
+    "2:\tdecl %0"
+    :"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
+    :"ax","cx","dx","di");
+return __res-cs;
+}
+
+extern inline char * strpbrk(const char * cs,const char * ct)
+{
+register char * __res __asm__("si");
+__asm__("cld\n\t"
+    "movl %4,%%edi\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "notl %%ecx\n\t"
+    "decl %%ecx\n\t"
+    "movl %%ecx,%%edx\n"
+    "1:\tlodsb\n\t"
+    "testb %%al,%%al\n\t"
+    "je 2f\n\t"
+    "movl %4,%%edi\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "jne 1b\n\t"
+    "decl %0\n\t"
+    "jmp 3f\n"
+    "2:\txorl %0,%0\n"
+    "3:"
+    :"=S" (__res):"a" (0),"c" (0xffffffff),"0" (cs),"g" (ct)
+    :"ax","cx","dx","di");
+return __res;
+}
+
+extern inline char * strstr(const char * cs,const char * ct)
+{
+register char * __res __asm__("ax");
+__asm__("cld\n\t" \
+    "movl %4,%%edi\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "notl %%ecx\n\t"
+    "decl %%ecx\n\t"    /* NOTE! This also sets Z if searchstring='' */
+    "movl %%ecx,%%edx\n"
+    "1:\tmovl %4,%%edi\n\t"
+    "movl %%esi,%%eax\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repe\n\t"
+    "cmpsb\n\t"
+    "je 2f\n\t"     /* also works for empty string, see above */
+    "xchgl %%eax,%%esi\n\t"
+    "incl %%esi\n\t"
+    "cmpb $0,-1(%%eax)\n\t"
+    "jne 1b\n\t"
+    "xorl %%eax,%%eax\n\t"
+    "2:"
+    :"=a" (__res):"0" (0),"c" (0xffffffff),"S" (cs),"g" (ct)
+    :"cx","dx","di","si");
+return __res;
+}
+
+inline int strlen(const char * s)
+{
+    int i = 0;
+    char* p = s;
+    while (*p) p++;
+    return p - s;
+}
+
+extern char * ___strtok;
+
+extern inline char * strtok(char * s,const char * ct)
+{
+register char * __res __asm__("si");
+__asm__("testl %1,%1\n\t"
+    "jne 1f\n\t"
+    "testl %0,%0\n\t"
+    "je 8f\n\t"
+    "movl %0,%1\n"
+    "1:\txorl %0,%0\n\t"
+    "movl $-1,%%ecx\n\t"
+    "xorl %%eax,%%eax\n\t"
+    "cld\n\t"
+    "movl %4,%%edi\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "notl %%ecx\n\t"
+    "decl %%ecx\n\t"
+    "je 7f\n\t"         /* empty delimeter-string */
+    "movl %%ecx,%%edx\n"
+    "2:\tlodsb\n\t"
+    "testb %%al,%%al\n\t"
+    "je 7f\n\t"
+    "movl %4,%%edi\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "je 2b\n\t"
+    "decl %1\n\t"
+    "cmpb $0,(%1)\n\t"
+    "je 7f\n\t"
+    "movl %1,%0\n"
+    "3:\tlodsb\n\t"
+    "testb %%al,%%al\n\t"
+    "je 5f\n\t"
+    "movl %4,%%edi\n\t"
+    "movl %%edx,%%ecx\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "jne 3b\n\t"
+    "decl %1\n\t"
+    "cmpb $0,(%1)\n\t"
+    "je 5f\n\t"
+    "movb $0,(%1)\n\t"
+    "incl %1\n\t"
+    "jmp 6f\n"
+    "5:\txorl %1,%1\n"
+    "6:\tcmpb $0,(%0)\n\t"
+    "jne 7f\n\t"
+    "xorl %0,%0\n"
+    "7:\ttestl %0,%0\n\t"
+    "jne 8f\n\t"
+    "movl %0,%1\n"
+    "8:"
+    :"=b" (__res),"=S" (___strtok)
+    :"0" (___strtok),"1" (s),"g" (ct)
+    :"ax","cx","dx","di");
+return __res;
+}
+
+extern inline void * memcpy(void * dest,const void * src, int n)
+{
+__asm__("cld\n\t"
+    "rep\n\t"
+    "movsb"
+    ::"c" (n),"S" (src),"D" (dest)
+    :"cx","si","di");
+return dest;
+}
+
+extern inline void * memmove(void * dest,const void * src, int n)
+{
+if (dest<src)
+__asm__("cld\n\t"
+    "rep\n\t"
+    "movsb"
+    ::"c" (n),"S" (src),"D" (dest)
+    :"cx","si","di");
+else
+__asm__("std\n\t"
+    "rep\n\t"
+    "movsb"
+    ::"c" (n),"S" (src+n-1),"D" (dest+n-1)
+    :"cx","si","di");
+return dest;
+}
+
+extern inline int memcmp(const void * cs,const void * ct,int count)
+{
+register int __res __asm__("ax");
+__asm__("cld\n\t"
+    "repe\n\t"
+    "cmpsb\n\t"
+    "je 1f\n\t"
+    "movl $1,%%eax\n\t"
+    "jl 1f\n\t"
+    "negl %%eax\n"
+    "1:"
+    :"=a" (__res):"0" (0),"D" (cs),"S" (ct),"c" (count)
+    :"si","di","cx");
+return __res;
+}
+
+extern inline void * memchr(const void * cs,char c,int count)
+{
+register void * __res __asm__("di");
+if (!count)
+    return NULL;
+__asm__("cld\n\t"
+    "repne\n\t"
+    "scasb\n\t"
+    "je 1f\n\t"
+    "movl $1,%0\n"
+    "1:\tdecl %0"
+    :"=D" (__res):"a" (c),"D" (cs),"c" (count)
+    :"cx");
+return __res;
+}
+
+extern inline void * memset(void * s,char c,int count)
+{
+__asm__("cld\n\t"
+    "rep\n\t"
+    "stosb"
+    ::"a" (c),"D" (s),"c" (count)
+    :"cx","di");
+return s;
+}
+
+#endif
+
diff --git a/kernel/Makefile b/kernel/Makefile
index 0c8dcf1b67de423d4c2cdc1bbb3aad3ba11ee3a3..8c0019b622d73657c71d8f8a5f6c857e7099c698 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -1,8 +1,8 @@
 GCC := gcc
-CCFLAG := -I../include -nostdinc -Wall -fomit-frame-pointer -c -m32
+CCFLAG := -I../include -nostdinc -Wall -fomit-frame-pointer -fno-stack-protector -c -m32
 LDFLAG := -Ttext 0x0 -s --oformat binary -m elf_i386
 INCDIR := ../include
-OBJS   := head.o main.o sched.o chr_drv/chr_drv.a
+OBJS   := head.o main.o sched.o printk.o vsprintf.o chr_drv/chr_drv.a
 
 system: $(OBJS)
 	$(LD) $(LDFLAG) -e startup_32 -o $@ $^
@@ -16,6 +16,12 @@ main.o : main.c
 sched.o : sched.c
 	$(GCC) $(CCFLAG) -o $@ $<
 
+printk.o : printk.c
+	$(GCC) $(CCFLAG) -o $@ $<
+
+vsprintf.o : vsprintf.c
+	$(GCC) $(CCFLAG) -o $@ $<
+
 chr_drv/chr_drv.a: chr_drv/*.c
 	cd chr_drv; make chr_drv.a; cd ..
 
diff --git a/kernel/chr_drv/console.c b/kernel/chr_drv/console.c
index 11dfbf2185351c24bb2c47195db2d955ed209eb8..3f6c592da23c178d7254fbd106c15d296aa44c62 100644
--- a/kernel/chr_drv/console.c
+++ b/kernel/chr_drv/console.c
@@ -111,7 +111,6 @@ void con_init() {
 
     gotoxy(ORIG_X, ORIG_Y);
     set_cursor();
-    con_write("hello", 5);
 }
 
 void con_write(const char* buf, int nr) {
diff --git a/kernel/main.c b/kernel/main.c
index 2de940e7718d0a71a501a2e33cc6e305c6dd9f6d..bc683a9a76a00cf95ad398f5fcdf7d5b58a82e34 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -1,6 +1,7 @@
 #define __LIBRARY__
 
 #include <linux/tty.h>
+#include <linux/kernel.h>
 
 void main(void) 
 {
@@ -15,6 +16,7 @@ void main(void)
     //__asm__("int $0x80\n\r"::);
 
     tty_init();
+    printk("hello %d", 28);
 
     __asm__ __volatile__(
             "loop:\n\r"
diff --git a/kernel/printk.c b/kernel/printk.c
new file mode 100644
index 0000000000000000000000000000000000000000..8b247b77505ae4cd9bb57bf4377835c81b6ed8e7
--- /dev/null
+++ b/kernel/printk.c
@@ -0,0 +1,31 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <linux/kernel.h>
+
+static char buf[1024];
+
+extern int vsprintf(char* buf, const char* fmt, va_list args);
+
+int printk(const char* fmt, ...) {
+    va_list args;
+    int i;
+
+    va_start(args, fmt);
+    i = vsprintf(buf, fmt, args);
+    va_end(args);
+
+    __asm__("pushw %%fs\n\t"
+            "pushw %%ds\n\t"
+            "popw  %%fs\n\t"
+            "pushl %0\n\t"
+            "pushl $buf\n\t"
+            "pushl $0\n\t"
+            "call  tty_write\n\t"
+            "addl  $8, %%esp\n\t"
+            "popl  %0\n\t"
+            "popw  %%fs"
+            ::"r"(i):"ax", "cx", "dx");
+
+    return i;
+}
+
diff --git a/kernel/vsprintf.c b/kernel/vsprintf.c
new file mode 100644
index 0000000000000000000000000000000000000000..35b2057b8df94988c9ee41d9c93463c071f9a1b2
--- /dev/null
+++ b/kernel/vsprintf.c
@@ -0,0 +1,243 @@
+#include <stdarg.h>
+#include <string.h>
+
+#define is_digit(c) ((c) >= '0' && (c) <= '9')
+
+static int skip_atoi(const char **s) {
+    int i=0;
+
+    while (is_digit(**s)) {
+        i = i*10 + *((*s)++) - '0';
+    }
+
+    return i;
+}
+
+#define ZEROPAD 1       /* pad with zero */
+#define SIGN    2       /* unsigned/signed long */
+#define PLUS    4       /* show plus */
+#define SPACE   8       /* space if plus */
+#define LEFT    16      /* left justified */
+#define SPECIAL 32      /* 0x */
+#define SMALL   64      /* use 'abcdef' instead of 'ABCDEF' */
+
+#define do_div(n,base) ({ \
+        int __res; \
+        __asm__("divl %4":"=a" (n),"=d" (__res):"0" (n),"1" (0),"r" (base)); \
+        __res; })
+
+static char * number(char * str, int num, int base, int size, int precision
+    ,int type) {
+    char c,sign,tmp[36];
+    const char *digits="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    int i;
+
+    if (type&SMALL) digits="0123456789abcdefghijklmnopqrstuvwxyz";
+    if (type&LEFT) type &= ~ZEROPAD;
+    if (base<2 || base>36)
+        return 0;
+
+    c = (type & ZEROPAD) ? '0' : ' ' ;
+    if (type&SIGN && num<0) {
+        sign = '-';
+        num = -num;
+    }
+    else {
+        sign=(type&PLUS) ? '+' : ((type&SPACE) ? ' ' : 0);
+    }
+
+    if (sign) size--;
+    if (type&SPECIAL) {
+        if (base==16) size -= 2;
+        else if (base==8) size--;
+    }
+
+    if (num==0)
+        tmp[i++]='0';
+    else {
+        while (num!=0) {
+            tmp[i++]=digits[do_div(num,base)];
+        }
+    }
+
+    if (i>precision) precision=i;
+    size -= precision;
+
+    if (!(type&(ZEROPAD+LEFT))) {
+        while(size-->0)
+            *str++ = ' ';
+    }
+
+    if (sign)
+        *str++ = sign;
+
+    if (type&SPECIAL) {
+        if (base==8)
+            *str++ = '0'; 
+        else if (base==16) {
+            *str++ = '0';
+            *str++ = digits[33];
+        }
+    }
+
+    if (!(type&LEFT)) {
+        while(size-->0)
+            *str++ = c;
+    }
+   
+    while(i<precision--)
+        *str++ = '0';
+
+    while(i-->0)
+        *str++ = tmp[i];
+
+    while(size-->0)
+        *str++ = ' ';
+
+    return str;
+}
+
+int vsprintf(char *buf, const char *fmt, va_list args) {
+    int len;
+    int i;
+    char * str;
+    char *s;
+    int *ip;
+
+    int flags;      /* flags to number() */
+    int field_width;    /* width of output field */
+    int precision;      /* min. # of digits for integers; max
+                           number of chars for from string */
+    int qualifier;      /* 'h', 'l', or 'L' for integer fields */
+
+    for (str = buf; *fmt; fmt++) {
+        if (*fmt != '%') {
+            *str++ = *fmt;
+            continue;
+        } 
+        
+        /* process flags */
+        flags = 0;
+        repeat:
+            ++fmt;      /* this also skips first '%' */
+            switch (*fmt) {
+                case '-': flags |= LEFT; goto repeat;
+                case '+': flags |= PLUS; goto repeat;
+                case ' ': flags |= SPACE; goto repeat;
+                case '#': flags |= SPECIAL; goto repeat;
+                case '0': flags |= ZEROPAD; goto repeat;
+            }
+
+        /* get field width */
+        field_width = -1;
+        if (is_digit(*fmt)) {
+            field_width = skip_atoi(&fmt);
+        }
+        else if (*fmt == '*') {
+            field_width = va_arg(args, int);
+            if (field_width < 0) {
+                field_width = -field_width;
+                flags |= LEFT;
+            }
+        }
+
+        /* get the precision */
+        precision = -1;
+        if (*fmt == '.') {
+            ++fmt;  
+            if (is_digit(*fmt))
+                precision = skip_atoi(&fmt);
+            else if (*fmt == '*') {
+                /* it's the next argument */
+                precision = va_arg(args, int);
+            }
+           
+            if (precision < 0)
+                precision = 0;
+        }
+
+        /* get the conversion qualifier */
+        qualifier = -1;
+        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
+            qualifier = *fmt;
+            ++fmt;
+        } 
+        
+        switch (*fmt) {
+            case 'c':
+                if (!(flags & LEFT))
+                    while (--field_width > 0)
+                        *str++ = ' ';
+                *str++ = (unsigned char) va_arg(args, int);
+                while (--field_width > 0)
+                    *str++ = ' ';
+                break; 
+            case 's':
+                s = va_arg(args, char *);
+                len = strlen(s);
+               
+                if (precision < 0)
+                    precision = len;
+                else if (len > precision)
+                    len = precision; 
+                
+                if (!(flags & LEFT))
+                    while (len < field_width--)
+                        *str++ = ' ';
+                for (i = 0; i < len; ++i)
+                    *str++ = *s++;
+                while (len < field_width--)
+                    *str++ = ' ';
+                break; 
+            
+            case 'o':
+                str = number(str, va_arg(args, unsigned long), 8,
+                        field_width, precision, flags);
+                break; 
+            
+            case 'p':
+                if (field_width == -1) {
+                    field_width = 8;
+                    flags |= ZEROPAD;
+                }
+                str = number(str,
+                        (unsigned long) va_arg(args, void *), 16,
+                        field_width, precision, flags);
+                break; 
+            
+            case 'x':
+                flags |= SMALL;
+            case 'X':
+                str = number(str, va_arg(args, unsigned long), 16,
+                        field_width, precision, flags);
+                break; 
+            
+            case 'd':
+            case 'i':
+                flags |= SIGN;
+            case 'u':
+                str = number(str, va_arg(args, unsigned long), 10,
+                        field_width, precision, flags);
+                break; 
+            
+            case 'n':
+                ip = va_arg(args, int *);
+                *ip = (str - buf);
+                break; 
+            
+            default:
+                if (*fmt != '%')
+                    *str++ = '%';
+               
+                if (*fmt)
+                    *str++ = *fmt;
+                else
+                    --fmt;
+                break;
+        }
+    }
+
+    *str = '\0';
+    return str-buf;
+}
+