diff --git a/Autoarr/StringBuilder.c b/Autoarr/StringBuilder.c
index 1eb729e..6a12265 100644
--- a/Autoarr/StringBuilder.c
+++ b/Autoarr/StringBuilder.c
@@ -25,6 +25,7 @@ void StringBuilder_append_int64(StringBuilder* b, int64 a){
     uint8 i=0;
     if(a==0){
         Autoarr_add(b,'0');
+        return;
     }
     else if(a<0){
         Autoarr_add(b,'-');
@@ -44,6 +45,7 @@ void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
     uint8 i=0;
     if(a==0){
         Autoarr_add(b,'0');
+        return;
     }
     char buf[24];
     while(a!=0){
@@ -51,13 +53,17 @@ void StringBuilder_append_uint64(StringBuilder* b, uint64 a){
         a/=10;
     }
     string rev=string_reverse((string){buf,i});
+    printf("\e[95mrev:%s\n",string_cpToCptr(rev));
     StringBuilder_append_string(b,rev);
     free(rev.ptr);
 }
 
 void StringBuilder_append_double(StringBuilder* b, double a){
     char buf[32];
-    sprintf(buf,"%lf",a);
+    IFWIN(
+        sprintf_s(buf,32,"%lf",a),
+        sprintf(buf,"%lf",a)
+    );
     StringBuilder_append_cptr(b,buf);
 }
 
diff --git a/DtsodParser/DtsodV24.h b/DtsodParser/DtsodV24.h
index cf0c090..26a116c 100644
--- a/DtsodParser/DtsodV24.h
+++ b/DtsodParser/DtsodV24.h
@@ -7,7 +7,7 @@ extern "C" {
 #include "../Hashtable/Hashtable.h"
 
 //parses text to binary values
-Hashtable* DtsodV24_deserialize(char* text);
+Maybe DtsodV24_deserialize(char* text);
 
 //creates text representation of dtsod
 char* DtsodV24_serialize(Hashtable* dtsod);
diff --git a/DtsodParser/DtsodV24_deserialize.c b/DtsodParser/DtsodV24_deserialize.c
index 8018192..56c2e9c 100644
--- a/DtsodParser/DtsodV24_deserialize.c
+++ b/DtsodParser/DtsodV24_deserialize.c
@@ -6,16 +6,15 @@
 #define STRB_BC 64
 #define STRB_BL 1024
 
-void __throw_wrongchar(char* file, int line, char* fname, char _c, char* _text) {
+Maybe ERROR_WRONGCHAR(char c, char* text){
     char errBuf[]="unexpected <c> at:\n  \""
         "00000000000000000000000000000000\"";
-    errBuf[12]=_c;
-    for (uint8 i=0; i < 32; i++)
-        errBuf[i + 22]=*(_text - 16 + i);
-    printf("\n\e[91m[%s:%d %s] throwed error: %s\n", file, line, fname, errBuf);
-    exit(128);
-};
-#define throw_wrongchar(C) __throw_wrongchar(__FILE__,__LINE__,__func__,C, text)
+    errBuf[12]=c;
+    for(uint8 i=22; i<32; i++)
+        errBuf[i]=*(text - 16 + i);
+    safethrow(cptr_copy(errBuf));
+}
+#define safethrow_wrongchar(C) return ERROR_WRONGCHAR(C, text)
 
 
 typedef struct DeserializeSharedData{
@@ -29,14 +28,15 @@ typedef struct DeserializeSharedData{
 #define readingList shared->sh_readingList
 #define calledRecursively shared->sh_calledRecursively
 
-void __SkipComment(DeserializeSharedData* shared) {
+Maybe __SkipComment(DeserializeSharedData* shared) {
     char c;
     while ((c=*++text) != '\n')
-        if (!c) throw(ERR_ENDOFSTR);
-};
+        if (!c) safethrow(ERR_ENDOFSTR);
+    return MaybeNull;
+}
 #define SkipComment() __SkipComment(shared)
 
-string __ReadName(DeserializeSharedData* shared){
+Maybe __ReadName(DeserializeSharedData* shared){
     char c;
     string nameStr={text,0};
     text--;
@@ -44,30 +44,30 @@ string __ReadName(DeserializeSharedData* shared){
         case ' ':  case '\t':
         case '\r': case '\n':
             if(nameStr.length!=0)
-                throw_wrongchar(c);
+                safethrow_wrongchar(c);
             nameStr.ptr++;
             break;
         case '=':  case ';':
         case '\'': case '"':
         case '[':  case ']':
         case '{':
-            throw_wrongchar(c);
+            safethrow_wrongchar(c);
             break;
         case '#':
-            SkipComment();
+            try(SkipComment(),_);
             if(nameStr.length!=0)
-                throw_wrongchar(c);
+                safethrow_wrongchar(c);
             nameStr.ptr=text+1; //skips '\n'
             break;
         case '}':
-            if(!calledRecursively) throw_wrongchar(c);
+            if(!calledRecursively) safethrow_wrongchar(c);
             if((*++text)!=';')
-                throw_wrongchar(c);
+                safethrow_wrongchar(c);
         case ':':
-            return nameStr;
+            return SUCCESS(UniPtr(CharPtr,string_cpToCptr(nameStr)));
         case '$':
             if(nameStr.length!=0)
-                throw_wrongchar(c);
+                safethrow_wrongchar(c);
             nameStr.ptr++;
             partOfDollarList=true;
             break;
@@ -76,17 +76,17 @@ string __ReadName(DeserializeSharedData* shared){
             break;
     }
 
-    if(nameStr.length>0) throw(ERR_ENDOFSTR);
-    return nameStr;
-};
+    if(nameStr.length>0) safethrow(ERR_ENDOFSTR);
+    return SUCCESS(UniPtr(CharPtr,NULL));
+}
 #define ReadName() __ReadName(shared)
 
-Hashtable* __deserialize(char** _text, bool _calledRecursively);
-Unitype __ReadValue(DeserializeSharedData* shared);
+Maybe __deserialize(char** _text, bool _calledRecursively);
+Maybe __ReadValue(DeserializeSharedData* shared);
 #define ReadValue() __ReadValue(shared)
 
 //returns part of <text> without quotes
-char* __ReadString(DeserializeSharedData* shared){
+Maybe __ReadString(DeserializeSharedData* shared){
     char c;
     bool prevIsBackslash=false;
     StringBuilder _b=StringBuilder_create(STRB_BC,STRB_BL);
@@ -101,7 +101,7 @@ char* __ReadString(DeserializeSharedData* shared){
             else {
                 char* str=StringBuilder_build(b);
                 Autoarr_clear(b);
-                return str;
+                return SUCCESS(UniPtr(CharPtr,str));
             }
         } 
         else {
@@ -109,24 +109,24 @@ char* __ReadString(DeserializeSharedData* shared){
             StringBuilder_append_char(b,c);
         }
     }
-    throw(ERR_ENDOFSTR);
-    return NULL;
-};
+    safethrow(ERR_ENDOFSTR);
+}
 #define ReadString() __ReadString(shared)
 
-Autoarr(Unitype)* __ReadList(DeserializeSharedData* shared){
+Maybe __ReadList(DeserializeSharedData* shared){
     Autoarr(Unitype)* list=malloc(sizeof(Autoarr(Unitype)));
     *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
     readingList=true;
     while (true){
-        Autoarr_add(list,ReadValue());
+        try(ReadValue(), val)
+            Autoarr_add(list,val.value);
         if (!readingList) break;
     }
-    return list;
+    return SUCCESS(UniPtr(AutoarrUnitypePtr,list));
 };
 #define ReadList() __ReadList(shared)
 
-Unitype __ParseValue(DeserializeSharedData* shared, string str){
+Maybe __ParseValue(DeserializeSharedData* shared, string str){
     //printf("\e[94m<\e[96m%s\e[94m>\n",string_cpToCptr(str));
     const string nullStr={"null",4};
     const string trueStr={"true",4};
@@ -134,18 +134,18 @@ Unitype __ParseValue(DeserializeSharedData* shared, string str){
     switch(*str.ptr){
         case 'n':
             if(string_compare(str,nullStr))
-                return UniNull;
-            else throw_wrongchar(*str.ptr);
+                return SUCCESS(UniNull);
+            else safethrow_wrongchar(*str.ptr);
             break;
         case 't':
             if(string_compare(str,trueStr))
-                return UniTrue;
-            else throw_wrongchar(*str.ptr);
+                return SUCCESS(UniTrue);
+            else safethrow_wrongchar(*str.ptr);
             break;
         case 'f':
             if(string_compare(str,falseStr))
-                return UniFalse;
-            else throw_wrongchar(*str.ptr);
+                return SUCCESS(UniFalse);
+            else safethrow_wrongchar(*str.ptr);
             break;
         default: 
             switch(str.ptr[str.length-1]){
@@ -153,14 +153,14 @@ Unitype __ParseValue(DeserializeSharedData* shared, string str){
                         char* _c=string_cpToCptr(str);
                         Unitype rez=Uni(Float64,strtod(_c,NULL));
                         free(_c);
-                        return rez;
+                        return SUCCESS(rez);
                     }
                 case 'u': {
                         uint64 lu=0;
                         char* _c=string_cpToCptr(str);
                         sscanf(_c,"%lu",&lu);
                         free(_c);
-                        return Uni(UInt64,lu);
+                        return SUCCESS(Uni(UInt64,lu));
                     }
                 case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9': {
@@ -168,22 +168,24 @@ Unitype __ParseValue(DeserializeSharedData* shared, string str){
                         char* _c=string_cpToCptr(str);
                         if(sscanf(_c,"%li",&li)!=1){
                             char err[64];
-                            sprintf(err,"can't parse to int: <%s>",_c);
-                            throw(err);
+                            IFWIN(
+                                sprintf_s(err,64,"can't parse to int: <%s>",_c),
+                                sprintf(err,"can't parse to int: <%s>",_c)
+                            );
+                            safethrow(err);
                         }
                         free(_c);
-                        return Uni(Int64,li);
+                        return SUCCESS(Uni(Int64,li));
                     }
                 default:
-                    throw_wrongchar(str.ptr[str.length-1]);
+                    safethrow_wrongchar(str.ptr[str.length-1]);
             }
     }
-    throw(ERR_ENDOFSTR);
-    return UniNull;
+    safethrow(ERR_ENDOFSTR);
 };
 #define ParseValue(str) __ParseValue(shared, str)
 
-Unitype __ReadValue(DeserializeSharedData* shared){
+Maybe __ReadValue(DeserializeSharedData* shared){
     char c;
     string valueStr={text+1,0};
     Unitype value;
@@ -191,57 +193,60 @@ Unitype __ReadValue(DeserializeSharedData* shared){
         case ' ':  case '\t':
         case '\r': case '\n':
             if(valueStr.length!=0)
-                throw_wrongchar(c);
+                safethrow_wrongchar(c);
             valueStr.ptr++;
             break;
         case '=': case ':': 
         case '}': case '$':
-            throw_wrongchar(c);
+            safethrow_wrongchar(c);
             break;
         case '#':;
             char _c=c;
-            SkipComment();
+            try(SkipComment(),_);
             if(valueStr.length!=0)
-                throw_wrongchar(_c);
+                safethrow_wrongchar(_c);
             valueStr.ptr=text+1; //skips '\n'
             break;
         case '"':
-            if(valueStr.length!=0) throw_wrongchar(c);
-            value=UniPtr(CharPtr,ReadString());
+            if(valueStr.length!=0) safethrow_wrongchar(c);
+            try(ReadString(),maybeString)
+                value=maybeString.value;
             break;
         case '\'':
-            if(valueStr.length!=0) throw_wrongchar(c);
+            if(valueStr.length!=0) safethrow_wrongchar(c);
             char valueChar=*++text;
-            if (*++text != '\'') throw("after <'> should be char");
+            if (*++text != '\'') safethrow("after <'> should be char");
             value=Uni(Char,valueChar);
             break;
         case '[':
-            if(valueStr.length!=0) throw_wrongchar(c);
-            value=UniPtr(AutoarrUnitypePtr,ReadList());
+            if(valueStr.length!=0) safethrow_wrongchar(c);
+            try(ReadList(),maybeList)
+                value=maybeList.value;
         case ']':
             readingList=false;
             break;
         case '{':
-            if(valueStr.length!=0) throw_wrongchar(c);
+            if(valueStr.length!=0) safethrow_wrongchar(c);
             ++text; //skips '{' 
-            value=UniPtr(HashtablePtr, __deserialize(&text,true));
-            return value;
+            try(__deserialize(&text,true), val)
+                return SUCCESS(val.value);
         case ';':
         case ',':
-            if(valueStr.length!=0)
-                value=ParseValue(valueStr);
-            return value;
+            if(valueStr.length!=0){
+                try(ParseValue(valueStr),maybeParsed)
+                    value=maybeParsed.value;
+            }
+            return SUCCESS(value);
         default:
             valueStr.length++;
             break;
     }
 
-    throw(ERR_ENDOFSTR);
-    return UniNull;
-};
+    safethrow(ERR_ENDOFSTR);
+}
 
 
-Hashtable* __deserialize(char** _text, bool _calledRecursively) {
+Maybe __deserialize(char** _text, bool _calledRecursively) {
     DeserializeSharedData _shared={
         .sh_text=*_text,
         .sh_partOfDollarList=false,
@@ -254,31 +259,31 @@ Hashtable* __deserialize(char** _text, bool _calledRecursively) {
     
     text--;
     while((c=*++text)){
-        string name=ReadName();
-        if(name.length==0) //end of file or '}' in recursive call 
+        try(ReadName(), maybeName)
+        if(!maybeName.value.VoidPtr) //end of file or '}' in recursive call 
             goto END;
-        char* nameCPtr=string_cpToCptr(name);
-        Unitype value=ReadValue();
-        if(partOfDollarList){
-            Autoarr(Unitype)* list;
-            Unitype lu;
-            if(Hashtable_try_get(dict,nameCPtr, &lu)){
-                list=(Autoarr(Unitype)*)lu.VoidPtr;
+        char* nameCPtr=maybeName.value.VoidPtr;
+        try(ReadValue(), val)
+            if(partOfDollarList){
+                Autoarr(Unitype)* list;
+                Unitype lu;
+                if(Hashtable_try_get(dict,nameCPtr, &lu)){
+                    list=(Autoarr(Unitype)*)lu.VoidPtr;
+                }
+                else{
+                    list=malloc(sizeof(Autoarr(Unitype)));
+                    *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
+                    Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
+                }
+                Autoarr_add(list,val.value);
             }
-            else{
-                list=malloc(sizeof(Autoarr(Unitype)));
-                *list=Autoarr_create(Unitype,ARR_BC,ARR_BL);
-                Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
-            }
-            Autoarr_add(list,value);
-        }
-        else Hashtable_add(dict,nameCPtr,value);
+        else Hashtable_add(dict,nameCPtr,val.value);
     }
     END:
     *_text=text;
-    return dict;
+    return SUCCESS(UniPtr(HashtablePtr,dict));
 }
 
-Hashtable* DtsodV24_deserialize(char* _text) {
+Maybe DtsodV24_deserialize(char* _text) {
     return __deserialize(&_text, false);
 }
diff --git a/DtsodParser/DtsodV24_exported.c b/DtsodParser/DtsodV24_exported.c
index 3ea291f..3ba9f31 100644
--- a/DtsodParser/DtsodV24_exported.c
+++ b/DtsodParser/DtsodV24_exported.c
@@ -11,8 +11,10 @@ extern "C" {
 #include "DtsodV24.h"
 
 //parses text to binary values
-EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output){
-    *output=DtsodV24_deserialize(text);
+EXPORT void CALL kerep_DtsodV24_deserialize(char* text, Hashtable** output, char** errmsg){
+    Maybe r=DtsodV24_deserialize(text);
+    *errmsg= r.errmsg ? r.errmsg : NULL;
+    *output=r.value.VoidPtr;
 }
 
 //creates text representation of dtsod
diff --git a/base/base.h b/base/base.h
index 906b6ed..ad651e6 100644
--- a/base/base.h
+++ b/base/base.h
@@ -14,7 +14,7 @@ extern "C" {
     #define optime(opname,repeats,codeblock) ({\
         struct timespec start, stop;\
         clock_gettime(CLOCK_REALTIME, &start);\
-        for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\
+        for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
             (codeblock);\
         clock_gettime(CLOCK_REALTIME, &stop);\
         double t=(double)(stop.tv_sec-start.tv_sec+(double)(stop.tv_nsec-start.tv_nsec)/1000000000)/repeats;\
@@ -23,7 +23,7 @@ extern "C" {
 #else //
     #define optime(opname,repeats,codeblock) ({\
         clock_t start=clock();\
-        for(uint64 ___OPREP=0;___OPREP<repeats;___OPREP++)\
+        for(uint64 ___OPREP=0;___OPREP<(uint64)repeats;___OPREP++)\
             (codeblock);\
         clock_t stop=clock();\
         double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\
diff --git a/base/errors.c b/base/errors.c
index a1ef3c1..d10d5d1 100644
--- a/base/errors.c
+++ b/base/errors.c
@@ -18,14 +18,22 @@ char* errname(err_t err){
 #define ERRMSG_MAXLENGTH 1024
 
 char* __genErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
-    char* rezult=malloc(ERRMSG_MAXLENGTH);
-    sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg);
+    size_t bufsize=ERRMSG_MAXLENGTH;
+    char* rezult=malloc(bufsize);
+    IFWIN(
+        sprintf_s(rezult,bufsize,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg),
+        sprintf(rezult,"[%s:%d] %s() throwed error: %s",srcfile,line,funcname,errmsg)
+    );
     return rezult;
 }
 
 char* __extendErrMsg(const char* errmsg, const char* srcfile, int line, const char* funcname){
-    char* rezult=malloc(cptr_length(errmsg)+ERRMSG_MAXLENGTH);
-    sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname);
+    size_t bufsize=cptr_length(errmsg)+ERRMSG_MAXLENGTH;
+    char* rezult=malloc(bufsize);
+    IFWIN(
+        sprintf_s(rezult,bufsize,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname),
+        sprintf(rezult,"%s\n \\___[%s:%d] %s()",errmsg,srcfile,line,funcname)
+    );
     free(errmsg);
     return rezult;
 }
diff --git a/base/errors.h b/base/errors.h
index 708f801..88f63b0 100644
--- a/base/errors.h
+++ b/base/errors.h
@@ -26,10 +26,6 @@ static const Maybe MaybeNull={.value.type=Null, .value.VoidPtr=NULL,.errmsg=NULL
 void Maybe_free(Maybe e);
 void printMaybe(Maybe e);
 
-#define throwNext(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
-        _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
-        return _rezult;\
-    }else 
 
 #define SUCCESS(REZLT) (Maybe){.errmsg=NULL, .value=REZLT}
 
@@ -50,6 +46,17 @@ char* __unknownErr( );
 #define throw(E) __EXIT(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__)))
 #define safethrow(E) __RETURN_EXCEPTION(((char*)__genErrMsg((__stringify_err(E)), __FILE__,__LINE__,__func__)))
 
+
+#define try(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
+        _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
+        return _rezult;\
+    }else 
+
+#define tryLast(_funcCall, _rezult) Maybe _rezult=_funcCall; if(_rezult.errmsg){\
+        _rezult.errmsg=__extendErrMsg(_rezult.errmsg, __FILE__,__LINE__,__func__);\
+        __EXIT(_rezult.errmsg);\
+    }else 
+
 #if __cplusplus
 }
 #endif
\ No newline at end of file
diff --git a/base/types.c b/base/types.c
index 95c2dd7..28f33b4 100644
--- a/base/types.c
+++ b/base/types.c
@@ -115,21 +115,34 @@ void Unitype_free(Unitype u){
     }
 }
 
+#define SPRINT_BUFSIZE 64
 void sprintuni(char* buf,Unitype v){
-    switch (v.type) {
-        case Null: sprintf(buf, "{Null}");break;
-        case Float64: sprintf(buf, "{%s : %lf}",my_type_name(v.type),v.Float64);break;
-        case Char: sprintf(buf, "{%s : '%c'}",my_type_name(v.type),v.Char);break;
-        case Bool:
-        case UInt64: sprintf(buf, "{%s : %lu}",my_type_name(v.type),v.UInt64);break;
-        case Int64: sprintf(buf, "{%s : %ld}",my_type_name(v.type),v.Int64);break;
-        case CharPtr: sprintf(buf, "{%s : \"%s\"}",my_type_name(v.type),(char*)v.VoidPtr);break;
-        default: sprintf(buf, "{%s : %p}",my_type_name(v.type),v.VoidPtr);break;
-    }
+    IFWIN(
+        switch (v.type) {
+            case Null: sprintf_s(buf, SPRINT_BUFSIZE, "{Null}");break;
+            case Float64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
+            case Char: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : '%c'}", my_type_name(v.type),v.Char);break;
+            case Bool:
+            case UInt64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %lu}", my_type_name(v.type),v.UInt64);break;
+            case Int64: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %ld}", my_type_name(v.type),v.Int64);break;
+            case CharPtr: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);break;
+            default: sprintf_s(buf, SPRINT_BUFSIZE, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break;
+        },
+        switch (v.type) {
+            case Null: sprintf(buf, "{Null}");break;
+            case Float64: sprintf(buf, "{%s : %lf}", my_type_name(v.type),v.Float64);break;
+            case Char: sprintf(buf, "{%s : '%c'}", my_type_name(v.type),v.Char);break;
+            case Bool:
+            case UInt64: sprintf(buf, "{%s : %lu}", my_type_name(v.type),v.UInt64);break;
+            case Int64: sprintf(buf, "{%s : %ld}", my_type_name(v.type),v.Int64);break;
+            case CharPtr: sprintf(buf, "{%s : \"%s\"}", my_type_name(v.type),(char*)v.VoidPtr);break;
+            default: sprintf(buf, "{%s : %p}", my_type_name(v.type),v.VoidPtr);break;
+        }
+    );
 }
 
 void printuni(Unitype v){
-    char* s=malloc(64);
+    char* s=malloc(SPRINT_BUFSIZE);
     sprintuni(s,v);
     fputs(s, stdout);
     free(s);
diff --git a/tests/main.c b/tests/main.c
index a91c53e..4b3149d 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -1,12 +1,12 @@
 #include "tests.h"
 
 void test_all(){
-    test_searchtree();
     test_autoarr();
-    test_hashtable();
     test_string();
-    test_dtsod();
     test_safethrow();
+    test_searchtree();
+    test_hashtable();
+    test_dtsod();
     printf("\e[96m---------------------------------------\e[0m\n");
 }
 
diff --git a/tests/test_dtsod.c b/tests/test_dtsod.c
index 6b4ae69..239768a 100644
--- a/tests/test_dtsod.c
+++ b/tests/test_dtsod.c
@@ -33,18 +33,21 @@ void test_dtsod(){
     optime(__func__,1,({
         printf("\e[96m-------------[test_dtsod]-------------\n");
         Hashtable* dtsod;
-        char* s=cptr_copy(text);
 
-        optime("deserialize",1,(dtsod=DtsodV24_deserialize(s)));
-        free(s);
+        optime("deserialize",1,({
+            tryLast(DtsodV24_deserialize(text),r) 
+                dtsod=r.value.VoidPtr;
+        }));
         print_dtsod(dtsod);
 
+        char* s;
         optime("serialize",1,(s=DtsodV24_serialize(dtsod)));
         Hashtable_free(dtsod);
         printf("\e[92m%s",s);
 
         optime("reserialize",10,({
-            dtsod=DtsodV24_deserialize(s);
+            tryLast(DtsodV24_deserialize(s),r) 
+                dtsod=r.value.VoidPtr;
             free(s);
             s=DtsodV24_serialize(dtsod);
             Hashtable_free(dtsod);
diff --git a/tests/test_hashtable.c b/tests/test_hashtable.c
index 6a6f5c3..70e7944 100644
--- a/tests/test_hashtable.c
+++ b/tests/test_hashtable.c
@@ -39,7 +39,10 @@ void printrowgraph(Hashtable* ht){
 void fill(Hashtable* ht){
     for(uint32 i=0;i<100000;i++){
         char* key=malloc(12);
-        sprintf(key,"key__%u",i);
+        IFWIN(
+            sprintf_s(key,12,"key_%u",i),
+            sprintf(key,"key_%u",i)
+        );
         Hashtable_add(ht,key,Uni(UInt64,i));
     }
 }
@@ -48,7 +51,10 @@ Unitype gett(Hashtable* ht){
     char* key=malloc(12);
     Unitype u;
     for(uint32 i=0;i<100000;i++){
-        sprintf(key,"key__%u",i);
+        IFWIN(
+            sprintf_s(key,12,"key_%u",i),
+            sprintf(key,"key_%u",i)
+        );
         u=Hashtable_get(ht,key);
     }
     free(key);
diff --git a/tests/test_safethrow.c b/tests/test_safethrow.c
index 17dff57..78c6a1c 100644
--- a/tests/test_safethrow.c
+++ b/tests/test_safethrow.c
@@ -14,19 +14,19 @@ Maybe throw_errcode(){
 
 Maybe test_maybe(){
     printf("\e[94mdont_throw returns \e[92m");
-    throwNext(dont_throw(),rez0)
+    tryLast(dont_throw(),rez0)
         printMaybe(rez0);
     printf("\n");
-    throwNext(throw_error(),rez1)
+    try(throw_error(),rez1)
         printMaybe(rez1);
     throw("test_maybe failed");
     return MaybeNull;
 }
 
 
-Maybe c(){ throwNext(throw_errcode(),_) return MaybeNull; }
-Maybe b(){ throwNext(c(),_) return MaybeNull; }
-Maybe a(){ throwNext(b(),_) return MaybeNull; }
+Maybe c(){ try(throw_errcode(),_) return MaybeNull; }
+Maybe b(){ try(c(),_) return MaybeNull; }
+Maybe a(){ try(b(),_) return MaybeNull; }
 
 void test_safethrow(){
     printf("\e[96m-----------[test_safethrow]-----------\n");