Build for Windows and many fixes

Now memory is used more wisely.
Now for threads can register any number of Trees.
Fixed all leaks when creating a large number of Trees.
Fixed cmake file. Now build normally in Linux.
Fixed many problem with string preprocessing.
Now, is not afraid of binary files and other trash.
Any fixes to improve stability.

33 files changed, 1265 insertions, 696 deletions

diff --git a/Changes b/Changes
index 44b8007..90c8fcf 100644
--- a/Changes
+++ b/Changes
@@ -1,3 +1,13 @@
+0.31	Mon Mar 28 2016 16:15:03 GMT+0300
+	Build for Windows
+	Now memory is used more wisely.
+	Now for threads can register any number of Trees.
+	Fixed all leaks when creating a large number of Trees.
+	Fixed cmake file. Now build normally in Linux.
+	Fixed many problem with string preprocessing.
+	Now, is not afraid of binary files and other trash.
+	Any fixes to improve stability.
+
 0.27	Wed Mar 23 2016 11:37:03 GMT+0300
 	  Added a forgotten file due to which nothing has worked
 	  Added example clear_text.pl
diff --git a/MANIFEST b/MANIFEST
index b0fe754..5460731 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -61,6 +61,8 @@ source/myhtml/utils/mcsync.h
 source/myhtml/utils/mctree.c
 source/myhtml/utils/mctree.h
 source/myhtml/utils/resources.h
+source/myhtml/utils/mcsimple.h
+source/myhtml/utils/mcsimple.c
 source/myhtml/utils.c
 source/myhtml/utils.h
 
diff --git a/Makefile.PL b/Makefile.PL
index 96652cf..b254a0a 100755
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,5 +1,6 @@
 use strict;
 use utf8;
+use Config;
 
 use FindBin;
 use ExtUtils::MakeMaker;
@@ -14,6 +15,6 @@ WriteMakefile(
     LICENSE        => 'Apache 2.0',
     LINKTYPE       => 'dynamic',
     LIBS           => ["-lpthread"],
-	CCFLAGS        => "--std=c99",
+	CCFLAGS        => " --std=c99 ". $Config{ccflags},
 	INC            => "-I$myhtml_source_dir",
 );
diff --git a/MyHTML.pm b/MyHTML.pm
index 3d55643..0671557 100755
--- a/MyHTML.pm
+++ b/MyHTML.pm
@@ -22,7 +22,7 @@ use strict;
 use vars qw($AUTOLOAD $VERSION $ABSTRACT @ISA @EXPORT);
 
 BEGIN {
-	$VERSION = 0.27;
+	$VERSION = 0.31;
 	$ABSTRACT = "Fast HTML Parser using Threads with no outside dependencies";
 	
 	@ISA = qw(Exporter DynaLoader);
diff --git a/MyHTML.xs b/MyHTML.xs
index 0db18c9..5ad0e5b 100755
--- a/MyHTML.xs
+++ b/MyHTML.xs
@@ -16,10 +16,6 @@
  Author: lex.borisov@gmail.com (Alexander Borisov)
 */
 
-#include "EXTERN.h"
-#include "perl.h"
-#include "XSUB.h"
-
 #include "source/myhtml/charef.c"
 #include "source/myhtml/encoding.c"
 #include "source/myhtml/encoding_detect.c"
@@ -42,8 +38,13 @@
 #include "source/myhtml/utils/mcobject_async.c"
 #include "source/myhtml/utils/mcsync.c"
 #include "source/myhtml/utils/mctree.c"
+#include "source/myhtml/utils/mcsimple.c"
 #include "source/myhtml/utils.c"
 
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
 typedef myhtml_t * HTML__MyHTML;
 typedef myhtml_tree_t * HTML__MyHTML__Tree;
 typedef myhtml_tree_node_t * HTML__MyHTML__Tree__Node;
diff --git a/README b/README
index 12422f1..5a6ff68 100644
--- a/README
+++ b/README
@@ -5,7 +5,7 @@ DESCRIPTION
 
 Fast HTML Parser using Threads with no outside dependencies
 
-This Parser based on MyHTML library  (it includes version 0.5.3)
+This Parser based on MyHTML library  (it includes version 0.6.1)
 
 See https://github.com/lexborisov/myhtml 
 
diff --git a/README.md b/README.md
index 7b73a1f..2c48e7d 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ HTML::MyHTML is a fast HTML Parser using Threads with no outside dependencies
 
 # DESCRIPTION
 
-This Parser based on [MyHTML library] (it includes version 0.5.3)
+This Parser based on [MyHTML library] (it includes version 0.6.1)
 
 - Asynchronous Parsing, Build Tree and Indexation
 - Fully conformant with the [HTML5 specification]
diff --git a/source/myhtml/api.h b/source/myhtml/api.h
index 7174738..1a5c22f 100644
--- a/source/myhtml/api.h
+++ b/source/myhtml/api.h
@@ -33,8 +33,8 @@
  */
 
 #define MyHTML_VERSION_MAJOR 0
-#define MyHTML_VERSION_MINOR 5
-#define MyHTML_VERSION_PATCH 3
+#define MyHTML_VERSION_MINOR 6
+#define MyHTML_VERSION_PATCH 1
 
 #include <stdbool.h>
 #include <stddef.h>
diff --git a/source/myhtml/def.h b/source/myhtml/def.h
index 87d04fa..aadccb2 100644
--- a/source/myhtml/def.h
+++ b/source/myhtml/def.h
@@ -24,18 +24,6 @@
 extern "C" {
 #endif
 
-// trash
-#define myhtml_else_if_html_end_tag(__else__)                         \
-__else__ if(html[html_offset] == '>') {                               \
-    mh_queue_get(mh_queue_current(), tag_length) =                    \
-    (html_offset - mh_queue_get(mh_queue_current(), tag_begin)) + 1;  \
-                                                                      \
-    mh_state_set(myhtml_tree) = MyHTML_TOKENIZER_STATE_DATA;          \
-    myhtml_queue_node_add(myhtml, mh_queue_current(), myhtml_tree);   \
-    mh_queue_current() = myhtml_queue_get_free_id(myhtml);            \
-    break;                                                            \
-}
-
 #define myhtml_parser_skip_whitespace()                                                      \
 if(myhtml_whithspace(html[html_offset], ==, ||)) {                                           \
     while (html_offset < html_size && (myhtml_whithspace(html[html_offset], ==, ||))) {      \
@@ -43,12 +31,6 @@ if(myhtml_whithspace(html[html_offset], ==, ||)) {
     }                                                                                        \
 }
 
-#define myhtml_parser_check_size_tag_name()                       \
-if(mh_queue_get(qnode_idx, tagname_begin) == html_offset) {       \
-    state = MyHTML_TOKENIZER_STATE_DATA;                          \
-    break;                                                        \
-}
-
 #define myhtml_parser_queue_set_attr(__tree__, __qnode__)                                       \
     if(__qnode__->token->attr_first == NULL) {                                                  \
         __qnode__->token->attr_first = myhtml_tree_token_attr_current(__tree__);                \
diff --git a/source/myhtml/myhtml.c b/source/myhtml/myhtml.c
index 04bad25..40346ac 100644
--- a/source/myhtml/myhtml.c
+++ b/source/myhtml/myhtml.c
@@ -187,8 +187,6 @@ myhtml_status_t myhtml_parse(myhtml_tree_t* tree, myhtml_encoding_t encoding, co
 {
     if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     myhtml_encoding_set(tree, encoding);
@@ -201,11 +199,8 @@ myhtml_status_t myhtml_parse(myhtml_tree_t* tree, myhtml_encoding_t encoding, co
 
 myhtml_status_t myhtml_parse_fragment(myhtml_tree_t* tree, myhtml_encoding_t encoding, const char* html, size_t html_size, myhtml_tag_id_t tag_id, enum myhtml_namespace my_namespace)
 {
-    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END)
-    {
+    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     if(tag_id == 0)
@@ -227,8 +222,6 @@ myhtml_status_t myhtml_parse_single(myhtml_tree_t* tree, myhtml_encoding_t encod
 {
     if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     tree->flags |= MyHTML_TREE_FLAGS_SINGLE_MODE;
@@ -243,11 +236,8 @@ myhtml_status_t myhtml_parse_single(myhtml_tree_t* tree, myhtml_encoding_t encod
 
 myhtml_status_t myhtml_parse_fragment_single(myhtml_tree_t* tree, myhtml_encoding_t encoding, const char* html, size_t html_size, myhtml_tag_id_t tag_id, enum myhtml_namespace my_namespace)
 {
-    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END)
-    {
+    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     if(tag_id == 0)
@@ -269,11 +259,8 @@ myhtml_status_t myhtml_parse_fragment_single(myhtml_tree_t* tree, myhtml_encodin
 
 myhtml_status_t myhtml_parse_chunk(myhtml_tree_t* tree, const char* html, size_t html_size)
 {
-    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END)
-    {
+    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     myhtml_tokenizer_chunk(tree, html, html_size);
@@ -283,11 +270,8 @@ myhtml_status_t myhtml_parse_chunk(myhtml_tree_t* tree, const char* html, size_t
 
 myhtml_status_t myhtml_parse_chunk_fragment(myhtml_tree_t* tree, const char* html, size_t html_size, myhtml_tag_id_t tag_id, enum myhtml_namespace my_namespace)
 {
-    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END)
-    {
+    if(tree->flags & MyHTML_TREE_FLAGS_PARSE_END) {
         myhtml_tree_clean(tree);
-        mythread_queue_clean(tree->queue);
-        mythread_clean(tree->myhtml->thread);
     }
     
     if(tag_id == 0)
@@ -588,7 +572,7 @@ myhtml_string_t * myhtml_node_text_set_with_charef(myhtml_tree_t* tree, myhtml_t
             node->token->my_str_tm.length = 0;
     }
     
-    myhtml_string_char_ref_chunk_t str_chunk = {0, 0, 0, {0}, 0, encoding};
+    myhtml_string_char_ref_chunk_t str_chunk = {0, 0, 0, {0}, false, encoding};
     myhtml_encoding_result_clean(&str_chunk.res);
     
     myhtml_string_append_charef(&str_chunk, &node->token->my_str_tm, text, length);
@@ -991,6 +975,39 @@ const char * myhtml_tree_incomming_buf_make_data(myhtml_tree_t *tree, mythread_q
     return tree->temp_tag_name.data;
 }
 
+/* queue */
+void myhtml_queue_add(myhtml_tree_t *tree, const char *html, size_t begin, mythread_queue_node_t *qnode)
+{
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+    
+    if(tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) {
+        myhtml_parser_worker(0, tree->current_qnode);
+        while(myhtml_rules_tree_dispatcher(tree, tree->current_qnode->token)){};
+        
+        tree->current_qnode = mythread_queue_node_malloc_limit(tree->myhtml->thread, tree->queue, html, (tree->global_offset + begin), 4, NULL);
+    }
+    else {
+        tree->current_qnode = mythread_queue_node_malloc_round(tree->myhtml->thread, tree->queue_entry, html, (tree->global_offset + begin), NULL);
+    }
+
+#else
+    
+    myhtml_parser_worker(0, tree->current_qnode);
+    while(myhtml_rules_tree_dispatcher(tree, tree->current_qnode->token)){};
+    
+    tree->current_qnode = mythread_queue_node_malloc_limit(tree->myhtml->thread, tree->queue, html, (tree->global_offset + begin), 4, NULL);
+    
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
+    
+    tree->current_qnode->tree = tree;
+    tree->current_qnode->prev = qnode;
+    
+    if(qnode)
+        myhtml_tokenizer_calc_current_namespace(tree, qnode);
+    
+    myhtml_token_node_malloc(tree->token, tree->current_qnode->token, tree->token->mcasync_token_id);
+}
+
 bool myhtml_utils_strcmp(const char* ab, const char* to_lowercase, size_t size)
 {
     size_t i = 0;
diff --git a/source/myhtml/myhtml.h b/source/myhtml/myhtml.h
index e7e1d3d..e42368d 100644
--- a/source/myhtml/myhtml.h
+++ b/source/myhtml/myhtml.h
@@ -39,53 +39,11 @@ extern "C" {
 #include "myhtml/charef.h"
 #include "myhtml/encoding.h"
 
-#define mh_thread_get(__idx__, __attr__) myhtml_thread_get(myhtml->thread, __idx__, __attr__)
-#define mh_thread_set(__idx__, __attr__) myhtml_thread_set(myhtml->thread, __idx__, __attr__)
-
-#define mh_thread_post(__idx__) sem_post(myhtml_thread_get(myhtml->thread, __idx__, sem))
-#define mh_thread_wait(__idx__) sem_wait(myhtml_thread_get(myhtml->thread, __idx__, sem))
-#define mh_thread_done(__idx__, __param__) myhtml_thread_set(myhtml->thread, __idx__, opt) = __param__;
-
-#define mh_tree_get(__attr__) myhtml_tree_get(tree, __attr__)
-#define mh_tree_set(__attr__) myhtml_tree_set(tree, __attr__)
-
-#define mh_queue_current() mh_tree_get(queue)
-
-#define mh_state_get(__tree__) myhtml_tree_get(__tree__, state)
-#define mh_state_set(__tree__) myhtml_tree_set(__tree__, state)
-
-#define mh_tags_get(__idx__, __attr__) myhtml_tag_get(tree->myhtml->tags, __idx__, __attr__)
+    
+#define mh_queue_current() tree->queue
+#define myhtml_tokenizer_state_set(__tree__) myhtml_tree_set(__tree__, state)
 
-#define mh_queue_last(__attr__) myhtml->queue->nodes[myhtml_queue_node_current(myhtml->queue)].__attr__
 #define mh_queue_get(__idx__, __attr__) myhtml->queue->nodes[__idx__].__attr__
-#define mh_queue_set(__idx__, __attr__) mh_queue_get(__idx__, __attr__)
-#define mh_queue_current_get(__attr__) mh_queue_get(mh_queue_current(), __attr__)
-#define mh_queue_current_set(__attr__) mh_queue_current_get(__attr__)
-
-#define mh_queue_add(__tree__, __html__, __begin__, __current__)       \
-    if(__tree__->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) { \
-        myhtml_parser_worker(0, __tree__->current_qnode); \
-        while(myhtml_rules_tree_dispatcher(__tree__, __tree__->current_qnode->token)){}; \
-    } \
-    __tree__->current_qnode = mythread_queue_node_malloc(__tree__->queue, __html__, (__tree__->global_offset + __begin__), NULL); \
-    __tree__->current_qnode->tree = __tree__; \
-    __tree__->current_qnode->prev = __current__; \
-    if(__current__) \
-        myhtml_tokenizer_calc_current_namespace(__tree__, __current__); \
-    myhtml_token_node_malloc(__tree__->token, __tree__->current_qnode->token, __tree__->token->mcasync_token_id)
-
-#define mh_token_get(__idx__, __attr__) tree->token->nodes[__idx__].__attr__
-#define mh_token_set(__idx__, __attr__) mh_token_get(__idx__, __attr__)
-
-#define mh_tree_token_current(__attr__) mh_token_get(myhtml_tree_token_current(tree), __attr__)
-#define mh_tree_token_attr_current(__attr__) mh_token_get(myhtml_tree_token_attr_current(tree), __attr__)
-
-#define mh_token_attr_get(__idx__, __attr__) tree->token->attr[__idx__].__attr__
-#define mh_token_attr_set(__idx__, __attr__) mh_token_attr_get(__idx__, __attr__)
-#define mh_token_attr_current(__idx__) mh_token_get(__idx__, attr_last)
-
-#define mh_queue_token_get(__idx__, __attr__) mh_token_get(mh_queue_get(__idx__, token), __attr__)
-#define mh_queue_token_set(__idx__, __attr__) mh_queue_token_get(__idx__, __attr__)
 
 // space, tab, LF, FF, CR
 #define myhtml_whithspace(__char__, __action__, __logic__)    \
@@ -214,6 +172,9 @@ const char * myhtml_tree_incomming_buf_make_data(myhtml_tree_t *tree, mythread_q
 bool myhtml_utils_strcmp(const char* ab, const char* to_lowercase, size_t size);
 bool myhtml_is_html_node(myhtml_tree_node_t *node, myhtml_tag_id_t tag_id);
 
+// queue
+void myhtml_queue_add(myhtml_tree_t *tree, const char *html, size_t begin, mythread_queue_node_t *qnode);
+
 /** 
  * Platform-specific hdef performance clock queries.
  * Implemented in perf.c
diff --git a/source/myhtml/myosi.h b/source/myhtml/myosi.h
index db9a4da..0f72973 100644
--- a/source/myhtml/myosi.h
+++ b/source/myhtml/myosi.h
@@ -27,6 +27,7 @@
 #include <stdint.h>
 #include <stdarg.h>
 
+
 #if defined(_WIN32) || defined(_WIN64)
 #define IS_OS_WINDOWS
 #include <windows.h>
@@ -128,12 +129,15 @@ typedef struct myhtml_string myhtml_string_t;
 
 // thread
 enum mythread_thread_opt {
-    MyTHREAD_OPT_UNDEF = 0,
-    MyTHREAD_OPT_WAIT  = 1,
-    MyTHREAD_OPT_QUIT  = 2
+    MyTHREAD_OPT_UNDEF = 0x00,
+    MyTHREAD_OPT_WAIT  = 0x01,
+    MyTHREAD_OPT_QUIT  = 0x02,
+    MyTHREAD_OPT_STOP  = 0x04
 }
 typedef mythread_thread_opt_t;
 
+typedef struct mythread_queue_list_entry mythread_queue_list_entry_t;
+typedef struct mythread_queue_thread_param mythread_queue_thread_param_t;
 typedef struct mythread_queue_list mythread_queue_list_t;
 typedef struct mythread_queue_node mythread_queue_node_t;
 typedef struct mythread_queue mythread_queue_t;
diff --git a/source/myhtml/mystring.c b/source/myhtml/mystring.c
index c30d22f..bb71442 100644
--- a/source/myhtml/mystring.c
+++ b/source/myhtml/mystring.c
@@ -182,7 +182,7 @@ size_t _myhtml_string_append_char_references_state_0(myhtml_string_char_ref_chun
         if(buff[offset] == '&')
         {
             if(chunk->encoding == MyHTML_ENCODING_UTF_8) {
-                myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+                myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
             }
             else {
                 myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(str, &chunk->res, &buff[tmp_offset], (offset - tmp_offset), chunk->encoding);
@@ -202,7 +202,7 @@ size_t _myhtml_string_append_char_references_state_0(myhtml_string_char_ref_chun
     }
     
     if(chunk->encoding == MyHTML_ENCODING_UTF_8)
-        myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+        myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
     else
         myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(str, &chunk->res, &buff[tmp_offset], (offset - tmp_offset), chunk->encoding);
     
@@ -265,7 +265,7 @@ size_t _myhtml_string_append_char_references_state_2(myhtml_string_char_ref_chun
                (buff[offset] == '=' || myhtml_string_alphanumeric_character[ (unsigned char)buff[offset] ] != 0xff))
             {
                 if(chunk->encoding == MyHTML_ENCODING_UTF_8)
-                    myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+                    myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
                 else
                     myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(str, &chunk->res, &buff[tmp_offset], (offset - tmp_offset), chunk->encoding);
                 
@@ -285,7 +285,7 @@ size_t _myhtml_string_append_char_references_state_2(myhtml_string_char_ref_chun
         }
         else {
             if(chunk->encoding == MyHTML_ENCODING_UTF_8)
-                myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+                myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
             else
                 myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(str, &chunk->res, &buff[tmp_offset], (offset - tmp_offset), chunk->encoding);
         }
@@ -294,7 +294,7 @@ size_t _myhtml_string_append_char_references_state_2(myhtml_string_char_ref_chun
     }
     else {
         if(chunk->encoding == MyHTML_ENCODING_UTF_8)
-            myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+            myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
         else
             myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(str, &chunk->res, &buff[tmp_offset], (offset - tmp_offset), chunk->encoding);
     }
@@ -347,7 +347,7 @@ size_t _myhtml_string_append_char_references_state_4(myhtml_string_char_ref_chun
         {
             chunk->state = 0;
             
-            myhtml_string_append_with_preprocessing(str, (const char*)&buff[tmp_offset], (offset - tmp_offset));
+            myhtml_string_append_with_preprocessing(str, (const char*)&buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
             
             if((str->length - (chunk->begin + 2)) == 0) {
                 return offset;
@@ -367,7 +367,7 @@ size_t _myhtml_string_append_char_references_state_4(myhtml_string_char_ref_chun
         offset++;
     }
     
-    myhtml_string_append_with_preprocessing(str, (const char*)&buff[tmp_offset], (offset - tmp_offset));
+    myhtml_string_append_with_preprocessing(str, (const char*)&buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
     
     return offset;
 }
@@ -388,7 +388,7 @@ size_t _myhtml_string_append_char_references_state_5(myhtml_string_char_ref_chun
             }
             
             chunk->state = 0;
-            myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (tmp_set_to - tmp_offset));
+            myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (tmp_set_to - tmp_offset), chunk->emit_null_char);
             
             if((str->length - (chunk->begin + 3)) == 0) {
                 return offset;
@@ -415,7 +415,7 @@ size_t _myhtml_string_append_char_references_state_5(myhtml_string_char_ref_chun
         chunk->l_data = 0xFFFFFF;
     }
     
-    myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset));
+    myhtml_string_append_with_preprocessing(str, &buff[tmp_offset], (offset - tmp_offset), chunk->emit_null_char);
     
     return offset;
 }
@@ -489,7 +489,7 @@ void myhtml_string_append(myhtml_string_t* str, const char* buff, size_t length)
     str->data[str->length] = '\0';
 }
 
-void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* buff, size_t length)
+void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* buff, size_t length, bool emit_null_chars)
 {
     MyHTML_STRING_REALLOC_IF_NEED(str, (length + 1), 32);
     
@@ -506,7 +506,7 @@ void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* b
                 i++;
             }
         }
-        else if(u_buff[i] == 0x00)
+        else if(u_buff[i] == 0x00 && emit_null_chars == false)
         {
             MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
             
@@ -523,6 +523,13 @@ void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* b
         }
         
         str->length++;
+        
+        if(str->length >= str->size) {
+            MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            
+            if((unsigned char *)str->data != data)
+                data = (unsigned char*)str->data;
+        }
     }
     
     str->data[str->length] = '\0';
@@ -562,6 +569,13 @@ void myhtml_string_append_lowercase_with_preprocessing(myhtml_string_t* str, con
         }
         
         str->length++;
+        
+        if(str->length >= str->size) {
+            MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            
+            if((unsigned char *)str->data != data)
+                data = (unsigned char*)str->data;
+        }
     }
     
     str->data[str->length] = '\0';
@@ -613,6 +627,10 @@ void myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(myhtml_
             }
             
             str->length += len;
+            
+            if(str->length >= str->size) {
+                MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            }
         }
     }
     
@@ -635,7 +653,7 @@ void myhtml_string_append_chunk_with_convert_encoding(myhtml_string_t* str, myht
     for (size_t i = 0; i < length; i++)
     {
         if(func(u_buff[i], res) == MyHTML_ENCODING_STATUS_OK) {
-            MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            MyHTML_STRING_REALLOC_IF_NEED(str, 5, 32);
             str->length += myhtml_encoding_codepoint_to_ascii_utf_8(res->result, &str->data[str->length]);
         }
     }
@@ -736,6 +754,42 @@ size_t myhtml_string_raw_set_replacement_character(myhtml_string_t* target, size
     return 3;
 }
 
+void myhtml_string_append_with_replacement_null_characters_only(myhtml_string_t* str, const char* buff, size_t length)
+{
+    unsigned char *data = (unsigned char*)str->data;
+    const unsigned char *u_buff = (unsigned char*)buff;
+    
+    for (size_t i = 0; i < length; i++)
+    {
+        if(u_buff[i] == 0x00)
+        {
+            MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            
+            if((unsigned char *)str->data != data)
+                data = (unsigned char*)str->data;
+            
+            // Unicode Character 'REPLACEMENT CHARACTER' (U+FFFD)
+            data[str->length] = 0xEF; str->length++;
+            data[str->length] = 0xBF; str->length++;
+            data[str->length] = 0xBD;
+        }
+        else {
+            data[str->length] = u_buff[i];
+        }
+        
+        if(str->length >= str->size) {
+            MyHTML_STRING_REALLOC_IF_NEED(str, 4, 32);
+            
+            if((unsigned char *)str->data != data)
+                data = (unsigned char*)str->data;
+        }
+        
+        str->length++;
+    }
+    
+    str->data[str->length] = '\0';
+}
+
 void myhtml_string_stay_only_whitespace(myhtml_string_t* target)
 {
     char *data = target->data;
diff --git a/source/myhtml/mystring.h b/source/myhtml/mystring.h
index 0542181..338618b 100644
--- a/source/myhtml/mystring.h
+++ b/source/myhtml/mystring.h
@@ -77,7 +77,9 @@ struct myhtml_string_char_ref_chunk {
     long l_data;
     
     charef_entry_result_t charef_res;
+    
     bool is_attributes;
+    bool emit_null_char;
     
     myhtml_encoding_t encoding;
     myhtml_encoding_result_t res;
@@ -129,8 +131,9 @@ void myhtml_string_append_with_convert_encoding_with_preprocessing(myhtml_string
 void myhtml_string_append_chunk_with_convert_encoding_with_preprocessing(myhtml_string_t* str, myhtml_encoding_result_t* res,
                                                                          const char* buff, size_t length,
                                                                          myhtml_encoding_t encoding);
-    
-void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* buff, size_t length);
+void myhtml_string_append_with_replacement_null_characters_only(myhtml_string_t* str, const char* buff, size_t length);
+
+void myhtml_string_append_with_preprocessing(myhtml_string_t* str, const char* buff, size_t length, bool emit_null_chars);
 void myhtml_string_append_lowercase_with_preprocessing(myhtml_string_t* str, const char* buff, size_t length);
 size_t myhtml_string_raw_set_replacement_character(myhtml_string_t* target, size_t position);
 
diff --git a/source/myhtml/parser.c b/source/myhtml/parser.c
index 8ee2e35..5f8a68c 100644
--- a/source/myhtml/parser.c
+++ b/source/myhtml/parser.c
@@ -63,7 +63,7 @@ void myhtml_parser_drop_first_newline(myhtml_tree_t *tree, size_t *begin, size_t
     }
 }
 
-size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length)
+size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length, myhtml_string_char_ref_chunk_t *str_chunk)
 {
     myhtml_incoming_buf_t *inc_buf = myhtml_parser_find_first_buf(tree, begin);
     
@@ -73,7 +73,7 @@ size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, cons
     if((current_buf_offset + length) <= inc_buf->size)
     {
         if(tree->encoding == MyHTML_ENCODING_UTF_8)
-            myhtml_string_append_with_preprocessing(string, &inc_buf->data[current_buf_offset], length);
+            myhtml_string_append_with_preprocessing(string, &inc_buf->data[current_buf_offset], length, str_chunk->emit_null_char);
         else
             myhtml_string_append_with_convert_encoding(string,
                                                        &inc_buf->data[current_buf_offset],
@@ -88,7 +88,7 @@ size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, cons
     myhtml_encoding_result_clean(&res);
     
     if(tree->encoding == MyHTML_ENCODING_UTF_8)
-        myhtml_string_append_with_preprocessing(string, &inc_buf->data[current_buf_offset], buf_next_offset);
+        myhtml_string_append_with_preprocessing(string, &inc_buf->data[current_buf_offset], buf_next_offset, str_chunk->emit_null_char);
     else
         myhtml_string_append_chunk_with_convert_encoding(string, &res, &inc_buf->data[current_buf_offset],
                                                          buf_next_offset, tree->encoding);
@@ -100,11 +100,11 @@ size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, cons
         while (inc_buf && length)
         {
             if(length > inc_buf->size) {
-                myhtml_string_append_with_preprocessing(string, inc_buf->data, inc_buf->size);
+                myhtml_string_append_with_preprocessing(string, inc_buf->data, inc_buf->size, str_chunk->emit_null_char);
                 length -= inc_buf->size;
             }
             else {
-                myhtml_string_append_with_preprocessing(string, inc_buf->data, length);
+                myhtml_string_append_with_preprocessing(string, inc_buf->data, length, str_chunk->emit_null_char);
                 break;
             }
             
@@ -132,12 +132,10 @@ size_t myhtml_parser_add_text(myhtml_tree_t *tree, myhtml_string_t* string, cons
     return (string->length - save_str_len);
 }
 
-size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length)
+size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length, myhtml_string_char_ref_chunk_t *str_chunk)
 {
     myhtml_incoming_buf_t *inc_buf = myhtml_parser_find_first_buf(tree, begin);
-    
-    myhtml_encoding_result_t str_res;
-    myhtml_encoding_result_clean(&str_res);
+    myhtml_encoding_result_clean(&str_chunk->res);
     
     size_t current_buf_offset = begin - inc_buf->offset;
     size_t save_str_len = string->length;
@@ -147,7 +145,7 @@ size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* st
         if(tree->encoding == MyHTML_ENCODING_UTF_8)
             myhtml_string_append_lowercase_with_preprocessing(string, &inc_buf->data[current_buf_offset], length);
         else
-            myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_res, &inc_buf->data[current_buf_offset], length, tree->encoding);
+            myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_chunk->res, &inc_buf->data[current_buf_offset], length, tree->encoding);
         
         return (string->length - save_str_len);
     }
@@ -157,7 +155,7 @@ size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* st
     if(tree->encoding == MyHTML_ENCODING_UTF_8)
         myhtml_string_append_lowercase_with_preprocessing(string, &inc_buf->data[current_buf_offset], buf_next_offset);
     else
-        myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_res, &inc_buf->data[current_buf_offset], buf_next_offset, tree->encoding);
+        myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_chunk->res, &inc_buf->data[current_buf_offset], buf_next_offset, tree->encoding);
     
     length = length - buf_next_offset;
     inc_buf = inc_buf->next;
@@ -181,11 +179,11 @@ size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* st
         while (inc_buf && length)
         {
             if(length > inc_buf->size) {
-                myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_res, inc_buf->data, inc_buf->size, tree->encoding);
+                myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_chunk->res, inc_buf->data, inc_buf->size, tree->encoding);
                 length -= inc_buf->size;
             }
             else {
-                myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_res, inc_buf->data, length, tree->encoding);
+                myhtml_string_append_chunk_lowercase_ascii_with_convert_encoding(string, &str_chunk->res, inc_buf->data, length, tree->encoding);
                 break;
             }
             
@@ -196,26 +194,24 @@ size_t myhtml_parser_add_text_lowercase(myhtml_tree_t *tree, myhtml_string_t* st
     return (string->length - save_str_len);
 }
 
-size_t myhtml_parser_add_text_with_charef(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length, bool is_attibutes)
+size_t myhtml_parser_add_text_with_charef(myhtml_tree_t *tree, myhtml_string_t* string, const char *text, size_t begin, size_t length, myhtml_string_char_ref_chunk_t *str_chunk)
 {
     myhtml_incoming_buf_t *inc_buf = myhtml_parser_find_first_buf(tree, begin);
-    
-    myhtml_string_char_ref_chunk_t str_chunk = {0, 0, 0, {0}, is_attibutes, tree->encoding};
-    myhtml_encoding_result_clean(&str_chunk.res);
+    myhtml_encoding_result_clean(&str_chunk->res);
     
     size_t current_buf_offset = begin - inc_buf->offset;
     size_t save_str_len = string->length;
     
     if((current_buf_offset + length) <= inc_buf->size)
     {
-        myhtml_string_append_charef(&str_chunk, string, &inc_buf->data[current_buf_offset], length);
-        myhtml_string_append_charef_end(&str_chunk, string);
+        myhtml_string_append_charef(str_chunk, string, &inc_buf->data[current_buf_offset], length);
+        myhtml_string_append_charef_end(str_chunk, string);
         return (string->length - save_str_len);
     }
     
     size_t buf_next_offset = inc_buf->size - current_buf_offset;
     
-    myhtml_string_append_charef(&str_chunk, string, &inc_buf->data[current_buf_offset], buf_next_offset);
+    myhtml_string_append_charef(str_chunk, string, &inc_buf->data[current_buf_offset], buf_next_offset);
     
     length = length - buf_next_offset;
     inc_buf = inc_buf->next;
@@ -223,18 +219,18 @@ size_t myhtml_parser_add_text_with_charef(myhtml_tree_t *tree, myhtml_string_t*
     while (inc_buf && length)
     {
         if(length > inc_buf->size) {
-            myhtml_string_append_charef(&str_chunk, string, inc_buf->data, inc_buf->size);
+            myhtml_string_append_charef(str_chunk, string, inc_buf->data, inc_buf->size);
             length -= inc_buf->size;
         }
         else {
-            myhtml_string_append_charef(&str_chunk, string, inc_buf->data, length);
+            myhtml_string_append_charef(str_chunk, string, inc_buf->data, length);
             break;
         }
         
         inc_buf = inc_buf->next;
     }
     
-    myhtml_string_append_charef_end(&str_chunk, string);
+    myhtml_string_append_charef_end(str_chunk, string);
     return (string->length - save_str_len);
 }
 
@@ -254,22 +250,18 @@ void myhtml_parser_worker(mythread_id_t thread_id, mythread_queue_node_t *qnode)
         token->attr_first = NULL;
         token->attr_last  = NULL;
         
-        // for NULL token; NULL Token contains only one char == \0
-        // The further processing may be changed (in rules processing) to 'REPLACEMENT CHARACTER' (U+FFFD)
-        if(token->type & MyHTML_TOKEN_TYPE_NULL) {
-            token->length = 1;
+        myhtml_string_char_ref_chunk_t str_chunk = {0, 0, 0, {0}, false, false, qnode->tree->encoding};
+        
+        if(token->type & MyHTML_TOKEN_TYPE_DATA) {
+            str_chunk.emit_null_char = true;
             
-            token->my_str_tm.length = 1;
-            token->my_str_tm.data[0] = '\0';
+            token->length = myhtml_parser_add_text_with_charef(qnode->tree, &token->my_str_tm, qnode->text, qnode->begin, qnode->length, &str_chunk);
         }
-        else if(token->type & MyHTML_TOKEN_TYPE_DATA ||
-           token->type & MyHTML_TOKEN_TYPE_RCDATA ||
-           token->type & MyHTML_TOKEN_TYPE_CDATA)
-        {
-            token->length = myhtml_parser_add_text_with_charef(qnode->tree, &token->my_str_tm, qnode->text, qnode->begin, qnode->length, false);
+        else if(token->type & MyHTML_TOKEN_TYPE_RCDATA || token->type & MyHTML_TOKEN_TYPE_CDATA) {
+            token->length = myhtml_parser_add_text_with_charef(qnode->tree, &token->my_str_tm, qnode->text, qnode->begin, qnode->length, &str_chunk);
         }
         else
-            token->length = myhtml_parser_add_text(qnode->tree, &token->my_str_tm, qnode->text, qnode->begin, qnode->length);
+            token->length = myhtml_parser_add_text(qnode->tree, &token->my_str_tm, qnode->text, qnode->begin, qnode->length, &str_chunk);
     }
     else if(token->attr_first)
     {
@@ -283,6 +275,7 @@ void myhtml_parser_worker(mythread_id_t thread_id, mythread_queue_node_t *qnode)
         token->length = 0;
         
         myhtml_token_attr_t* attr = token->attr_first;
+        myhtml_string_char_ref_chunk_t str_chunk = {0, 0, 0, {0}, false, false, qnode->tree->encoding};
         
         while(attr)
         {
@@ -293,7 +286,10 @@ void myhtml_parser_worker(mythread_id_t thread_id, mythread_queue_node_t *qnode)
                 size_t begin = attr->name_begin;
                 attr->name_begin = attr->entry.length;
                 
-                attr->name_length = myhtml_parser_add_text_lowercase(qnode->tree, &attr->entry, qnode->text, begin, attr->name_length);
+                attr->name_length = myhtml_parser_add_text_lowercase(qnode->tree, &attr->entry, qnode->text, begin, attr->name_length, &str_chunk);
+            }
+            else {
+                attr->name_begin = 0;
             }
             
             if(attr->value_length)
@@ -301,7 +297,12 @@ void myhtml_parser_worker(mythread_id_t thread_id, mythread_queue_node_t *qnode)
                 size_t begin = attr->value_begin;
                 attr->value_begin = attr->entry.length;
                 
-                attr->value_length = myhtml_parser_add_text_with_charef(qnode->tree, &attr->entry, qnode->text, begin, attr->value_length, true);
+                str_chunk.is_attributes = true;
+                
+                attr->value_length = myhtml_parser_add_text_with_charef(qnode->tree, &attr->entry, qnode->text, begin, attr->value_length, &str_chunk);
+            }
+            else {
+                attr->value_begin = 0;
             }
             
             attr->my_namespace = MyHTML_NAMESPACE_HTML;
diff --git a/source/myhtml/rules.c b/source/myhtml/rules.c
index 36e0ca4..a7f0772 100644
--- a/source/myhtml/rules.c
+++ b/source/myhtml/rules.c
@@ -57,6 +57,38 @@ myhtml_token_node_t * myhtml_insertion_fix_split_for_text_begin_ws(myhtml_tree_t
     return new_token;
 }
 
+//
+void myhtml_insertion_fix_for_null_char_drop_all(myhtml_tree_t* tree, myhtml_token_node_t* token)
+{
+    myhtml_token_node_wait_for_done(token);
+    
+    myhtml_string_t *str = &token->my_str_tm;
+    size_t len = str->length;
+    size_t offset = 0;
+    
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (str->data[i] == '\0')
+        {
+            size_t next_non_null = i;
+            while ((next_non_null < len) && str->data[next_non_null] == '\0') {++next_non_null;}
+            
+            str->length = str->length - (next_non_null - i);
+            
+            size_t next_null = next_non_null;
+            while ((next_null < len) && str->data[next_null] != '\0') {++next_null;}
+            
+            memmove(&str->data[(i - offset)], &str->data[next_non_null], (next_null - next_non_null));
+            
+            i = next_null - 1;
+            
+            offset++;
+        }
+    }
+    
+    token->length = str->length;
+}
+
 bool myhtml_insertion_mode_initial(myhtml_tree_t* tree, myhtml_token_node_t* token)
 {
     switch (token->tag_ctx_idx)
@@ -619,7 +651,7 @@ bool myhtml_insertion_mode_in_body_other_end_tag(myhtml_tree_t* tree, myhtml_tok
         }
         
         const myhtml_tag_context_t *tag_ctx = myhtml_tag_get_by_id(tree->tags, node->tag_idx);
-        if(tag_ctx->cats[node->my_namespace] & MyHTML_TAG_CATEGORIES_SPECIAL) {
+        if(tag_ctx->cats[ node->my_namespace ] & MyHTML_TAG_CATEGORIES_SPECIAL) {
             break;
         }
     }
@@ -1007,14 +1039,24 @@ bool myhtml_insertion_mode_in_body(myhtml_tree_t* tree, myhtml_token_node_t* tok
         {
             case MyHTML_TAG__TEXT:
             {
-                if(token->type & MyHTML_TOKEN_TYPE_NULL)
-                    break;
-                
-                myhtml_tree_active_formatting_reconstruction(tree);
-                myhtml_tree_node_insert_text(tree, token);
-                
-                if((token->type & MyHTML_TOKEN_TYPE_WHITESPACE) == 0)
-                    tree->flags ^= (tree->flags & MyHTML_TREE_FLAGS_FRAMESET_OK);
+                if(token->type & MyHTML_TOKEN_TYPE_NULL) {
+                    myhtml_insertion_fix_for_null_char_drop_all(tree, token);
+                    
+                    if(token->my_str_tm.length) {
+                        myhtml_tree_active_formatting_reconstruction(tree);
+                        myhtml_tree_node_insert_text(tree, token);
+                        
+                        if((token->type & MyHTML_TOKEN_TYPE_WHITESPACE) == 0)
+                            tree->flags ^= (tree->flags & MyHTML_TREE_FLAGS_FRAMESET_OK);
+                    }
+                }
+                else {
+                    myhtml_tree_active_formatting_reconstruction(tree);
+                    myhtml_tree_node_insert_text(tree, token);
+                    
+                    if((token->type & MyHTML_TOKEN_TYPE_WHITESPACE) == 0)
+                        tree->flags ^= (tree->flags & MyHTML_TREE_FLAGS_FRAMESET_OK);
+                }
                 
                 break;
             }
@@ -2052,10 +2094,14 @@ bool myhtml_insertion_mode_in_table_text(myhtml_tree_t* tree, myhtml_token_node_
     // skip NULL, we replaced earlier
     if(token->tag_ctx_idx == MyHTML_TAG__TEXT)
     {
-        if(token->type & MyHTML_TOKEN_TYPE_NULL)
-            return false;
-        
-        myhtml_tree_token_list_append(tree->token_list, token);
+        if(token->type & MyHTML_TOKEN_TYPE_NULL) {
+            myhtml_insertion_fix_for_null_char_drop_all(tree, token);
+            
+            if(token->my_str_tm.length)
+                myhtml_tree_token_list_append(tree->token_list, token);
+        }
+        else
+            myhtml_tree_token_list_append(tree->token_list, token);
     }
     else {
         myhtml_tree_token_list_t* token_list = tree->token_list;
@@ -2714,10 +2760,15 @@ bool myhtml_insertion_mode_in_select(myhtml_tree_t* tree, myhtml_token_node_t* t
         switch (token->tag_ctx_idx)
         {
             case MyHTML_TAG__TEXT: {
-                if(token->type & MyHTML_TOKEN_TYPE_NULL)
-                    break;
+                if(token->type & MyHTML_TOKEN_TYPE_NULL) {
+                    myhtml_insertion_fix_for_null_char_drop_all(tree, token);
+                    
+                    if(token->my_str_tm.length)
+                        myhtml_tree_node_insert_text(tree, token);
+                }
+                else
+                    myhtml_tree_node_insert_text(tree, token);
                 
-                myhtml_tree_node_insert_text(tree, token);
                 break;
             }
                 
@@ -3384,7 +3435,7 @@ bool myhtml_insertion_mode_in_foreign_content(myhtml_tree_t* tree, myhtml_token_
             {
                 if(token->type & MyHTML_TOKEN_TYPE_NULL) {
                     myhtml_token_node_wait_for_done(token);
-                    myhtml_token_set_replacement_character_for_null_token(token);
+                    myhtml_token_set_replacement_character_for_null_token(tree, token);
                 }
                 
                 myhtml_tree_node_insert_text(tree, token);
diff --git a/source/myhtml/tag.c b/source/myhtml/tag.c
index 89b5576..8c77eba 100755
--- a/source/myhtml/tag.c
+++ b/source/myhtml/tag.c
@@ -26,18 +26,21 @@ myhtml_tag_t * myhtml_tag_create(void)
 
 myhtml_status_t myhtml_tag_init(myhtml_tree_t *tree, myhtml_tag_t *tags)
 {
-    tags->context_size = MyHTML_TAG_LAST_ENTRY + 128;
-    tags->context = (myhtml_tag_context_t*)mymalloc(sizeof(myhtml_tag_context_t) * tags->context_size);
+    tags->mcsimple_context = mcsimple_create();
     
-    if(tags->context == NULL)
+    if(tags->mcsimple_context == NULL)
         return MyHTML_STATUS_TAGS_ERROR_MEMORY_ALLOCATION;
     
+    mcsimple_init(tags->mcsimple_context, 128, 1024, sizeof(myhtml_tag_context_t));
+    
     tags->mchar_node = mchar_async_node_add(tree->myhtml->mchar);
     tags->tree       = mctree_create(32);
     
     tags->mchar      = tree->myhtml->mchar;
     tags->tag_index  = tree->myhtml->tag_index;
     
+    tags->tags_count = MyHTML_TAG_LAST_ENTRY;
+    
     myhtml_tag_clean(tags);
     
     return MyHTML_STATUS_OK;
@@ -45,11 +48,11 @@ myhtml_status_t myhtml_tag_init(myhtml_tree_t *tree, myhtml_tag_t *tags)
 
 void myhtml_tag_clean(myhtml_tag_t* tags)
 {
-    tags->context_length = 0;
-    myhtml_tag_context_clean(tags, tags->context_length);
-    myhtml_tag_context_add(tags);
+    tags->tags_count = MyHTML_TAG_LAST_ENTRY;
     
+    mcsimple_clean(tags->mcsimple_context);
     mchar_async_node_clean(tags->mchar, tags->mchar_node);
+    mctree_clean(tags->tree);
 }
 
 myhtml_tag_t * myhtml_tag_destroy(myhtml_tag_t* tags)
@@ -57,10 +60,8 @@ myhtml_tag_t * myhtml_tag_destroy(myhtml_tag_t* tags)
     if(tags == NULL)
         return NULL;
     
-    if(tags->context)
-        free(tags->context);
-    
     tags->tree = mctree_destroy(tags->tree);
+    tags->mcsimple_context = mcsimple_destroy(tags->mcsimple_context, true);
     
     mchar_async_node_delete(tags->mchar, tags->mchar_node);
     
@@ -82,7 +83,7 @@ myhtml_status_t myhtml_tag_index_init(myhtml_tag_t* tags, myhtml_tag_index_t* id
     if(mcstatus != MCOBJECT_ASYNC_STATUS_OK)
         return MyHTML_STATUS_TAGS_ERROR_MCOBJECT_CREATE;
     
-    idx_tags->tags_size = tags->context_size;
+    idx_tags->tags_size = tags->tags_count + 128;
     idx_tags->tags_length = 0;
     idx_tags->tags = (myhtml_tag_index_entry_t*)calloc(idx_tags->tags_size, sizeof(myhtml_tag_index_entry_t));
     
@@ -95,7 +96,7 @@ myhtml_status_t myhtml_tag_index_init(myhtml_tag_t* tags, myhtml_tag_index_t* id
 void myhtml_tag_index_clean(myhtml_tag_t* tags, myhtml_tag_index_t* index_tags)
 {
     mcobject_async_node_clean(tags->tag_index, tags->mcobject_node);
-    memset(index_tags->tags, 0, sizeof(myhtml_tag_index_entry_t) * tags->context_length);
+    memset(index_tags->tags, 0, sizeof(myhtml_tag_index_entry_t) * index_tags->tags_size);
 }
 
 myhtml_tag_index_t * myhtml_tag_index_destroy(myhtml_tag_t* tags, myhtml_tag_index_t* index_tags)
@@ -118,7 +119,7 @@ myhtml_tag_index_t * myhtml_tag_index_destroy(myhtml_tag_t* tags, myhtml_tag_ind
 void myhtml_tag_index_check_size(myhtml_tag_t* tags, myhtml_tag_index_t* index_tags, myhtml_tag_id_t tag_id)
 {
     if(tag_id >= index_tags->tags_size) {
-        size_t new_size = tags->context_size + MyHTML_TAG_LAST_ENTRY;
+        size_t new_size = tag_id + 128;
         
         myhtml_tag_index_entry_t *index_entries = (myhtml_tag_index_entry_t*)myrealloc(index_tags->tags,
                                                                              sizeof(myhtml_tag_index_entry_t) *
@@ -246,35 +247,37 @@ myhtml_tag_id_t myhtml_tag_add(myhtml_tag_t* tags, const char* key, size_t key_s
     }
     
     // add tags
-    myhtml_tag_id_t new_ctx_id = myhtml_tag_context_get_free_id(tags);
     
-    mctree_insert(tags->tree, cache, key_size, (void *)new_ctx_id, NULL);
+    myhtml_tag_context_t *tag_ctx = mcsimple_malloc(tags->mcsimple_context);
+    
+    mctree_insert(tags->tree, cache, key_size, (void *)tag_ctx, NULL);
     
-    tags->context[new_ctx_id].id          = new_ctx_id + MyHTML_TAG_LAST_ENTRY;
-    tags->context[new_ctx_id].name        = cache;
-    tags->context[new_ctx_id].name_length = key_size;
-    tags->context[new_ctx_id].data_parser = data_parser;
+    tag_ctx->id          = tags->tags_count;
+    tag_ctx->name        = cache;
+    tag_ctx->name_length = key_size;
+    tag_ctx->data_parser = data_parser;
     
-    memset(tags->context[new_ctx_id].cats, 0,
-           sizeof(enum myhtml_tag_categories) *
-           MyHTML_NAMESPACE_LAST_ENTRY);
+    tags->tags_count++;
     
-    myhtml_tag_context_add(tags);
+    memset(tag_ctx->cats, 0, sizeof(enum myhtml_tag_categories) * MyHTML_NAMESPACE_LAST_ENTRY);
     
-    return tags->context[new_ctx_id].id;
+    return tag_ctx->id;
 }
 
 void myhtml_tag_set_category(myhtml_tag_t* tags, myhtml_tag_id_t tag_idx,
                                        enum myhtml_namespace my_namespace, enum myhtml_tag_categories cats)
 {
-    tags->context[(tag_idx - MyHTML_TAG_LAST_ENTRY)].cats[my_namespace] = cats;
+    if(tag_idx < MyHTML_TAG_LAST_ENTRY)
+        return;
+    
+    myhtml_tag_context_t *tag_ctx = mcsimple_get_by_absolute_position(tags->mcsimple_context, (tag_idx - MyHTML_TAG_LAST_ENTRY));
+    tag_ctx->cats[my_namespace] = cats;
 }
 
 const myhtml_tag_context_t * myhtml_tag_get_by_id(myhtml_tag_t* tags, myhtml_tag_id_t tag_id)
 {
-    if(tag_id > MyHTML_TAG_LAST_ENTRY) {
-        tag_id -= MyHTML_TAG_LAST_ENTRY;
-        return &tags->context[tag_id];
+    if(tag_id >= MyHTML_TAG_LAST_ENTRY) {
+        return mcsimple_get_by_absolute_position(tags->mcsimple_context, (tag_id - MyHTML_TAG_LAST_ENTRY));
     }
     
     return myhtml_tag_static_get_by_id(tag_id);
@@ -288,12 +291,8 @@ const myhtml_tag_context_t * myhtml_tag_get_by_name(myhtml_tag_t* tags, const ch
         return ctx;
     
     mctree_index_t idx = mctree_search_lowercase(tags->tree, name, length);
-    size_t ctx_idx = (size_t)tags->tree->nodes[idx].value;
-    
-    if(ctx_idx && ctx_idx < tags->context_length)
-        return &tags->context[ctx_idx];
     
-    return NULL;
+    return (myhtml_tag_context_t*)tags->tree->nodes[idx].value;
 }
 
 void myhtml_tag_print(myhtml_tag_t* tags, FILE* fh)
@@ -306,7 +305,7 @@ void myhtml_tag_print(myhtml_tag_t* tags, FILE* fh)
         fprintf(fh, "<%s id=\"%zu\">\n", ctx->name, i);
     }
     
-    for(i = (MyHTML_TAG_LAST_ENTRY + 1); i < tags->context_length; i++)
+    for(i = (MyHTML_TAG_LAST_ENTRY + 1); i < tags->tags_count; i++)
     {
         const myhtml_tag_context_t *ctx = myhtml_tag_get_by_id(tags, i);
         
diff --git a/source/myhtml/tag.h b/source/myhtml/tag.h
index 32616c0..188d4a2 100644
--- a/source/myhtml/tag.h
+++ b/source/myhtml/tag.h
@@ -29,14 +29,14 @@ extern "C" {
 #include "myhtml/tag_const.h"
 #include "myhtml/tokenizer.h"
 #include "myhtml/tree.h"
+#include "myhtml/utils.h"
 #include "myhtml/utils/mctree.h"
 #include "myhtml/utils/mchar_async.h"
 #include "myhtml/utils/mcobject_async.h"
+#include "myhtml/utils/mcsimple.h"
 
 #define myhtml_tag_get(__tags__, __idx__, __attr__) __tags__->context[__idx__].__attr__
 
-#define myhtml_tag_context_get_free_id(__tags__) __tags__->context_length
-
 #define myhtml_tag_context_clean(__tags__, __idx__)                       \
     __tags__->context[__idx__].id          = 0;                           \
     __tags__->context[__idx__].name        = NULL;                        \
@@ -96,10 +96,9 @@ typedef myhtml_tag_static_list_t;
 
 struct myhtml_tag {
     mctree_t* tree;
+    mcsimple_t* mcsimple_context;
     
-    myhtml_tag_context_t* context;
-    size_t context_length;
-    size_t context_size;
+    size_t tags_count;
     
     size_t mcobject_node;
     size_t mchar_node;
diff --git a/source/myhtml/thread.c b/source/myhtml/thread.c
index 9109dd6..38a6a01 100644
--- a/source/myhtml/thread.c
+++ b/source/myhtml/thread.c
@@ -72,21 +72,18 @@ myhtml_status_t myhtml_hread_sem_create(mythread_t *mythread, mythread_context_t
 {
     ctx->sem_name = calloc(1024, sizeof(wchar_t));
     
-    char tmp[1024] = {0};
-    sprintf_s(tmp, 1024, "Global/%s%zus%zup%zu", MyTHREAD_SEM_NAME, prefix_id, ctx->id, (size_t)mythread);
+    sprintf(ctx->sem_name, "Global/%s%zus%zup%zu", MyTHREAD_SEM_NAME, prefix_id, ctx->id, (size_t)mythread);
     
-    size_t retval = 0;
-    mbstowcs_s(&retval, ctx->sem_name, 1024, tmp, strlen(tmp) + 1);
-    
-    ctx->sem_name_size = wcslen(ctx->sem_name);
+    ctx->sem_name_size = strlen(ctx->sem_name);
     
     ctx->sem = CreateSemaphore(NULL,           // default security attributes
                                0,              // initial count
-                               0,              // maximum count
-                               ctx->sem_name); // unnamed semaphore
+                               1,              // maximum count
+                               ctx->sem_name); // named semaphore
     
     if (ctx->sem == NULL) {
         free(ctx->sem_name);
+        ctx->sem_name = NULL;
         
         mythread->sys_last_error = GetLastError();
         return MyHTML_STATUS_THREAD_ERROR_SEM_CREATE;
@@ -253,12 +250,6 @@ mythread_t * mythread_create(void)
 
 myhtml_status_t mythread_init(mythread_t *mythread, const char *sem_prefix, size_t thread_count, size_t queue_size)
 {
-    myhtml_status_t status;
-    mythread->queue = mythread_queue_create(4096, &status);
-    
-    if(mythread->queue == NULL)
-        return status;
-    
     return MyHTML_STATUS_OK;
 }
 
@@ -268,8 +259,8 @@ myhtml_status_t mythread_init(mythread_t *mythread, const char *sem_prefix, size
 {
     mythread->batch_count    = 0;
     mythread->batch_first_id = 0;
-    mythread->stream_opt     = MyTHREAD_OPT_WAIT;
-    mythread->batch_opt      = MyTHREAD_OPT_WAIT;
+    mythread->stream_opt     = MyTHREAD_OPT_STOP;
+    mythread->batch_opt      = MyTHREAD_OPT_STOP;
     
     if(thread_count)
     {
@@ -296,9 +287,9 @@ myhtml_status_t mythread_init(mythread_t *mythread, const char *sem_prefix, size
     }
     
     myhtml_status_t status;
-    mythread->queue = mythread_queue_create(4096, &status);
+    mythread->queue_list = mythread_queue_list_create(mythread, 1024, &status);
     
-    if(mythread->queue == NULL)
+    if(mythread->queue_list == NULL)
         return status;
     
     if(sem_prefix)
@@ -325,22 +316,6 @@ myhtml_status_t mythread_init(mythread_t *mythread, const char *sem_prefix, size
 void mythread_clean(mythread_t *mythread)
 {
     mythread->sys_last_error = 0;
-    
-    if(mythread->queue)
-        mythread_queue_clean(mythread->queue);
-    
-#ifndef MyHTML_BUILD_WITHOUT_THREADS
-    
-    size_t idx;
-    for (idx = mythread->pth_list_root; idx < mythread->pth_list_length; idx++) {
-        mythread->pth_list[idx].data.use = 0;
-    }
-    
-    for (idx = 0; idx < mythread->batch_count; idx++) {
-        mythread->pth_list[( mythread->batch_first_id + idx )].data.use = idx;
-    }
-    
-#endif /* MyHTML_BUILD_WITHOUT_THREADS */
 }
 
 mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy)
@@ -356,7 +331,7 @@ mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy)
         mythread_resume_all(mythread);
         mythread_stream_quit_all(mythread);
         mythread_batch_quit_all(mythread);
-        mythread_wait_all(mythread);
+        mythread_wait_all_for_done(mythread);
         
         for (size_t i = mythread->pth_list_root; i < mythread->pth_list_length; i++)
         {
@@ -371,6 +346,10 @@ mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy)
         mythread->pth_list = NULL;
     }
     
+    if(mythread->queue_list) {
+        free(mythread->queue_list);
+    }
+    
     if(mythread->sem_prefix) {
         free(mythread->sem_prefix);
         
@@ -380,9 +359,6 @@ mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy)
     
 #endif /* MyHTML_BUILD_WITHOUT_THREADS */
     
-    if(mythread->queue)
-        mythread_queue_destroy(mythread->queue);
-    
     if(self_destroy) {
         free(mythread);
         return NULL;
@@ -412,9 +388,8 @@ mythread_id_t _myhread_create_stream_raw(mythread_t *mythread, mythread_f func,
     thr->data.mythread = mythread;
     thr->data.func     = func;
     thr->data.id       = mythread->pth_list_length;
-    thr->data.use      = 0;
-    thr->data.qnode    = NULL;
     thr->data.t_count  = total_count;
+    thr->data.opt      = MyTHREAD_OPT_STOP;
     
     myhtml_status_t m_status = myhtml_hread_sem_create(mythread, &thr->data, 0);
     
@@ -460,8 +435,8 @@ mythread_id_t myhread_create_batch(mythread_t *mythread, mythread_f func, myhtml
     
     bool init_first = false;
     
-    for (size_t i = 0; i < count; i++) {
-        
+    for (size_t i = 0; i < count; i++)
+    {
         mythread_id_t curr_id = _myhread_create_stream_raw(mythread, func, mythread_function_batch, status, count);
         
         if(init_first == false) {
@@ -489,9 +464,6 @@ mythread_id_t myhread_create_batch(mythread_t *mythread, mythread_f func, myhtml
             
             break;
         }
-        else {
-            mythread->pth_list[curr_id].data.use = i;
-        }
     }
     
     return mythread->batch_first_id;
@@ -500,6 +472,151 @@ mythread_id_t myhread_create_batch(mythread_t *mythread, mythread_f func, myhtml
 #endif /* MyHTML_BUILD_WITHOUT_THREADS */
 
 // mythread queue functions
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+mythread_queue_list_t * mythread_queue_list_create(mythread_t *mythread, size_t size, myhtml_status_t *status)
+{
+    if(status)
+        *status = MyHTML_STATUS_OK;
+    
+    if(size < 1024)
+        size = 1024;
+    
+    mythread_queue_list_t* queue_list = (mythread_queue_list_t*)mycalloc(1, sizeof(mythread_queue_list_t));
+    
+    if(queue_list == NULL) {
+        if(status)
+            *status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
+        return NULL;
+    }
+    
+    return queue_list;
+}
+
+mythread_queue_list_entry_t * mythread_queue_list_entry_push(mythread_t *mythread, mythread_queue_t *queue, myhtml_status_t *status)
+{
+    mythread_queue_list_t *queue_list = mythread->queue_list;
+    
+    if(status)
+        *status = MyHTML_STATUS_OK;
+    
+    mythread_queue_list_entry_t* entry = (mythread_queue_list_entry_t*)mycalloc(1, sizeof(mythread_queue_list_entry_t));
+    
+    if(entry == NULL) {
+        if(status)
+            *status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
+        return NULL;
+    }
+    
+    entry->thread_param = (mythread_queue_thread_param_t*)mycalloc(mythread->pth_list_size, sizeof(mythread_queue_thread_param_t));
+    
+    if(entry == NULL) {
+        free(entry);
+        
+        if(status)
+            *status = MyHTML_STATUS_THREAD_ERROR_QUEUE_MALLOC;
+        return NULL;
+    }
+    
+    entry->queue = queue;
+    
+    if(mythread->stream_opt == MyTHREAD_OPT_UNDEF) {
+        mythread_suspend_all(mythread);
+    }
+    else if(mythread->stream_opt == MyTHREAD_OPT_STOP) {
+        mythread_stop_all(mythread);
+    }
+    
+    if(queue_list->first) {
+        queue_list->last->next = entry;
+        entry->prev = queue_list->last;
+        
+        queue_list->last = entry;
+    }
+    else {
+        queue_list->first = entry;
+        queue_list->last = entry;
+    }
+    
+    queue_list->count++;
+    
+    if(mythread->stream_opt != MyTHREAD_OPT_STOP)
+        mythread_resume_all(mythread);
+    
+    return entry;
+}
+
+mythread_queue_list_entry_t * mythread_queue_list_entry_delete(mythread_t *mythread, mythread_queue_list_entry_t *entry, bool destroy_queue)
+{
+    mythread_queue_list_t *queue_list = mythread->queue_list;
+    
+    mythread_queue_list_entry_t *next = entry->next;
+    mythread_queue_list_entry_t *prev = entry->prev;
+    
+    if(mythread->stream_opt == MyTHREAD_OPT_UNDEF) {
+        mythread_suspend_all(mythread);
+    }
+    else if(mythread->stream_opt == MyTHREAD_OPT_STOP) {
+        mythread_stop_all(mythread);
+    }
+    
+    if(prev)
+        prev->next = next;
+    
+    if(next)
+        next->prev = prev;
+    
+    if(queue_list->first == entry)
+        queue_list->first = next;
+    
+    if(queue_list->last == entry)
+        queue_list->last = prev;
+    
+    if(mythread->stream_opt != MyTHREAD_OPT_STOP)
+        mythread_resume_all(mythread);
+    
+    if(destroy_queue && entry->queue)
+        mythread_queue_destroy(entry->queue);
+    
+    if(entry->thread_param)
+        free(entry->thread_param);
+    
+    free(entry);
+    
+    queue_list->count--;
+    
+    return NULL;
+}
+
+void mythread_queue_list_entry_clean(mythread_t *mythread, mythread_queue_list_entry_t *entry)
+{
+    if(entry == NULL)
+        return;
+    
+    mythread_queue_clean(entry->queue);
+    
+    size_t idx;
+    for (idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
+        entry->thread_param[idx].use = 0;
+    }
+}
+
+void mythread_queue_list_entry_wait_for_done(mythread_t *mythread, mythread_queue_list_entry_t *entry)
+{
+    if(entry == NULL)
+        return;
+    
+    size_t idx;
+    const struct timespec tomeout = {0, 10000};
+    
+    for (idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
+        while(entry->thread_param[idx].use < entry->queue->nodes_uses) {
+            myhtml_thread_nanosleep(&tomeout);
+        }
+    }
+}
+
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
+
 mythread_queue_t * mythread_queue_create(size_t size, myhtml_status_t *status)
 {
     if(status)
@@ -508,7 +625,7 @@ mythread_queue_t * mythread_queue_create(size_t size, myhtml_status_t *status)
     if(size < 4096)
         size = 4096;
     
-    mythread_queue_t* queue = (mythread_queue_t*)malloc(sizeof(mythread_queue_t));
+    mythread_queue_t* queue = (mythread_queue_t*)mymalloc(sizeof(mythread_queue_t));
     
     if(queue == NULL) {
         if(status)
@@ -518,7 +635,7 @@ mythread_queue_t * mythread_queue_create(size_t size, myhtml_status_t *status)
     
     queue->nodes_pos_size = 512;
     queue->nodes_size     = size;
-    queue->nodes          = (mythread_queue_node_t**)calloc(queue->nodes_pos_size, sizeof(mythread_queue_node_t*));
+    queue->nodes          = (mythread_queue_node_t**)mycalloc(queue->nodes_pos_size, sizeof(mythread_queue_node_t*));
     
     if(queue->nodes == NULL) {
         free(queue);
@@ -530,7 +647,7 @@ mythread_queue_t * mythread_queue_create(size_t size, myhtml_status_t *status)
     
     mythread_queue_clean(queue);
     
-    queue->nodes[queue->nodes_pos] = (mythread_queue_node_t*)malloc(sizeof(mythread_queue_node_t) * queue->nodes_size);
+    queue->nodes[queue->nodes_pos] = (mythread_queue_node_t*)mymalloc(sizeof(mythread_queue_node_t) * queue->nodes_size);
     
     if(queue->nodes[queue->nodes_pos] == NULL) {
         free(queue->nodes);
@@ -578,17 +695,9 @@ void mythread_queue_node_clean(mythread_queue_node_t* qnode)
     memset(qnode, 0, sizeof(mythread_queue_node_t));
 }
 
-mythread_queue_node_t * mythread_queue_get_prev_node(mythread_queue_t* queue)
+mythread_queue_node_t * mythread_queue_get_prev_node(mythread_queue_node_t* qnode)
 {
-    if(queue->nodes_length == 0)
-    {
-        if(queue->nodes_pos == 0)
-            return NULL;
-        
-        return &queue->nodes[(queue->nodes_pos - 1)][(queue->nodes_size - 1)];
-    }
-    
-    return &queue->nodes[queue->nodes_pos][(queue->nodes_length - 1)];
+    return qnode->prev;
 }
 
 mythread_queue_node_t * mythread_queue_get_current_node(mythread_queue_t* queue)
@@ -606,7 +715,7 @@ size_t mythread_queue_count_used_node(mythread_queue_t* queue)
     return queue->nodes_uses;
 }
 
-mythread_queue_node_t * mythread_queue_node_malloc(mythread_queue_t* queue, const char* text, size_t begin, myhtml_status_t *status)
+mythread_queue_node_t * mythread_queue_node_malloc(mythread_t *mythread, mythread_queue_t* queue, const char* text, size_t begin, myhtml_status_t *status)
 {
     queue->nodes_length++;
     
@@ -616,6 +725,8 @@ mythread_queue_node_t * mythread_queue_node_malloc(mythread_queue_t* queue, cons
         
         if(queue->nodes_pos >= queue->nodes_pos_size)
         {
+            mythread_wait_all_for_done(mythread);
+            
             queue->nodes_pos_size <<= 1;
             mythread_queue_node_t** tmp = realloc(queue->nodes, sizeof(mythread_queue_node_t*) * queue->nodes_pos_size);
             
@@ -656,16 +767,104 @@ mythread_queue_node_t * mythread_queue_node_malloc(mythread_queue_t* queue, cons
     return qnode;
 }
 
+mythread_queue_node_t * mythread_queue_node_malloc_limit(mythread_t *mythread, mythread_queue_t* queue, const char* text, size_t begin, size_t limit, myhtml_status_t *status)
+{
+    queue->nodes_length++;
+    
+    if(queue->nodes_uses >= limit) {
+        mythread_wait_all_for_done(mythread);
+        
+        queue->nodes_length = 0;
+        queue->nodes_pos    = 0;
+        queue->nodes_root   = 0;
+        queue->nodes_uses   = 0;
+    }
+    else if(queue->nodes_length >= queue->nodes_size)
+    {
+        queue->nodes_pos++;
+        
+        if(queue->nodes_pos >= queue->nodes_pos_size)
+        {
+            mythread_wait_all_for_done(mythread);
+            
+            queue->nodes_pos_size <<= 1;
+            mythread_queue_node_t** tmp = realloc(queue->nodes, sizeof(mythread_queue_node_t*) * queue->nodes_pos_size);
+            
+            if(tmp) {
+                memset(&tmp[queue->nodes_pos], 0, sizeof(mythread_queue_node_t*) * (queue->nodes_pos_size - queue->nodes_pos));
+                
+                queue->nodes = tmp;
+            }
+            else {
+                if(status)
+                    *status = MyHTML_STATUS_THREAD_ERROR_QUEUE_NODES_MALLOC;
+                
+                return NULL;
+            }
+        }
+        
+        if(queue->nodes[queue->nodes_pos] == NULL) {
+            queue->nodes[queue->nodes_pos] = (mythread_queue_node_t*)malloc(sizeof(mythread_queue_node_t) * queue->nodes_size);
+            
+            if(queue->nodes[queue->nodes_pos] == NULL) {
+                if(status)
+                    *status = MyHTML_STATUS_THREAD_ERROR_QUEUE_NODE_MALLOC;
+                
+                return NULL;
+            }
+        }
+        
+        queue->nodes_length = 0;
+    }
+    
+    queue->nodes_uses++;
+    
+    mythread_queue_node_t *qnode = &queue->nodes[queue->nodes_pos][queue->nodes_length];
+    
+    qnode->text  = text;
+    qnode->begin = begin;
+    
+    return qnode;
+}
+
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+
+mythread_queue_node_t * mythread_queue_node_malloc_round(mythread_t *mythread, mythread_queue_list_entry_t *entry,
+                                                              const char* text, size_t begin, myhtml_status_t *status)
+{
+    mythread_queue_t* queue = entry->queue;
+    
+    queue->nodes_length++;
+    
+    if(queue->nodes_length >= queue->nodes_size) {
+        queue->nodes_uses++;
+        
+        mythread_queue_list_entry_wait_for_done(mythread, entry);
+        mythread_queue_list_entry_clean(mythread, entry);
+    }
+    else
+        queue->nodes_uses++;
+    
+    mythread_queue_node_t *qnode = &queue->nodes[queue->nodes_pos][queue->nodes_length];
+    
+    qnode->text  = text;
+    qnode->begin = begin;
+    
+    return qnode;
+}
+
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
+
 #ifdef MyHTML_BUILD_WITHOUT_THREADS
 
 void mythread_stream_quit_all(mythread_t *mythread) {}
 void mythread_batch_quit_all(mythread_t *mythread) {}
-void mythread_stream_pause_all(mythread_t *mythread) {}
-void mythread_batch_pause_all(mythread_t *mythread) {}
-void mythread_resume_all(mythread_t *mythread) {}
-void mythread_wait_all(mythread_t *mythread) {}
-void mythread_function_batch(void *arg) {}
-void mythread_function_stream(void *arg) {}
+void mythread_stream_stop_all(mythread_t *mythread) {};
+void mythread_batch_stop_all(mythread_t *mythread) {};
+void mythread_stop_all(mythread_t *mythread) {};
+void mythread_resume_all(mythread_t *mythread) {};
+void mythread_wait_all_for_done(mythread_t *mythread) {};
+void mythread_suspend_all(mythread_t *mythread) {};
 
 #else /* MyHTML_BUILD_WITHOUT_THREADS */
 
@@ -680,14 +879,40 @@ void mythread_batch_quit_all(mythread_t *mythread)
     mythread->batch_opt = MyTHREAD_OPT_QUIT;
 }
 
-void mythread_stream_pause_all(mythread_t *mythread)
+void mythread_stream_stop_all(mythread_t *mythread)
+{
+    if(mythread->stream_opt != MyTHREAD_OPT_STOP)
+        mythread->stream_opt = MyTHREAD_OPT_STOP;
+    
+    size_t idx;
+    const struct timespec tomeout = {0, 10000};
+    
+    for (idx = mythread->pth_list_root; idx < mythread->batch_first_id; idx++) {
+        while(mythread->pth_list[idx].data.opt != MyTHREAD_OPT_STOP) {
+            myhtml_thread_nanosleep(&tomeout);
+        }
+    }
+}
+
+void mythread_batch_stop_all(mythread_t *mythread)
 {
-    mythread->stream_opt = MyTHREAD_OPT_WAIT;
+    if(mythread->batch_opt != MyTHREAD_OPT_STOP)
+        mythread->batch_opt = MyTHREAD_OPT_STOP;
+    
+    size_t idx;
+    const struct timespec tomeout = {0, 10000};
+    
+    for (idx = mythread->batch_first_id; idx < (mythread->batch_first_id + mythread->batch_count); idx++) {
+        while(mythread->pth_list[idx].data.opt != MyTHREAD_OPT_STOP) {
+            myhtml_thread_nanosleep(&tomeout);
+        }
+    }
 }
 
-void mythread_batch_pause_all(mythread_t *mythread)
+void mythread_stop_all(mythread_t *mythread)
 {
-    mythread->batch_opt = MyTHREAD_OPT_WAIT;
+    mythread_stream_stop_all(mythread);
+    mythread_batch_stop_all(mythread);
 }
 
 void mythread_resume_all(mythread_t *mythread)
@@ -696,64 +921,159 @@ void mythread_resume_all(mythread_t *mythread)
        mythread->batch_opt  == MyTHREAD_OPT_UNDEF)
         return;
     
-    mythread->stream_opt = MyTHREAD_OPT_UNDEF;
-    mythread->batch_opt  = MyTHREAD_OPT_UNDEF;
+    if(mythread->stream_opt == MyTHREAD_OPT_WAIT ||
+       mythread->batch_opt == MyTHREAD_OPT_WAIT)
+    {
+        mythread->stream_opt = MyTHREAD_OPT_UNDEF;
+        mythread->batch_opt  = MyTHREAD_OPT_UNDEF;
+    }
+    else {
+        mythread->stream_opt = MyTHREAD_OPT_UNDEF;
+        mythread->batch_opt  = MyTHREAD_OPT_UNDEF;
+        
+        for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
+            myhtml_hread_sem_post(mythread, &mythread->pth_list[idx].data);
+        }
+    }
+}
+
+void mythread_wait_all_for_done(mythread_t *mythread)
+{
+    const struct timespec tomeout = {0, 10000};
+    
+    mythread_queue_list_t *queue_list = mythread->queue_list;
+    mythread_queue_list_entry_t *entry = queue_list->first;
     
-    for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_length; idx++) {
-        myhtml_hread_sem_post(mythread, &mythread->pth_list[idx].data);
+    while(entry)
+    {
+        for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
+            while(entry->thread_param[idx].use < entry->queue->nodes_uses) {
+                myhtml_thread_nanosleep(&tomeout);
+            }
+        }
+        
+        entry = entry->next;
     }
 }
 
-void mythread_wait_all(mythread_t *mythread)
+void mythread_suspend_all(mythread_t *mythread)
 {
+    if(mythread->stream_opt != MyTHREAD_OPT_WAIT)
+        mythread->stream_opt = MyTHREAD_OPT_WAIT;
+    
+    if(mythread->batch_opt != MyTHREAD_OPT_WAIT)
+        mythread->batch_opt  = MyTHREAD_OPT_WAIT;
+    
     const struct timespec tomeout = {0, 10000};
     
-    for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_length; idx++) {
-        while(mythread->pth_list[idx].data.use < mythread->queue->nodes_uses) {
+    for (size_t idx = mythread->pth_list_root; idx < mythread->pth_list_size; idx++) {
+        while(mythread->pth_list[idx].data.opt != MyTHREAD_OPT_WAIT) {
             myhtml_thread_nanosleep(&tomeout);
         }
     }
 }
 
+bool mythread_function_see_for_all_done(mythread_queue_list_t *queue_list, size_t thread_id)
+{
+    size_t done_count = 0;
+    
+    mythread_queue_list_entry_t *entry = queue_list->first;
+    while(entry)
+    {
+        if(entry->thread_param[ thread_id ].use >= entry->queue->nodes_uses) {
+            done_count++;
+            entry = entry->next;
+        }
+        else
+            break;
+    }
+    
+    return done_count == queue_list->count;
+}
+
+bool mythread_function_see_opt(mythread_context_t *ctx, volatile mythread_thread_opt_t opt, size_t done_count, const struct timespec *timeout)
+{
+    mythread_t * mythread = ctx->mythread;
+    mythread_queue_list_t *queue_list = mythread->queue_list;
+    
+    if(done_count != queue_list->count)
+        return false;
+    
+    if(opt & MyTHREAD_OPT_STOP)
+    {
+        if(mythread_function_see_for_all_done(queue_list, ctx->id))
+        {
+            ctx->opt = MyTHREAD_OPT_STOP;
+            myhtml_hread_sem_wait(mythread, ctx);
+            ctx->opt = MyTHREAD_OPT_UNDEF;
+            
+            return false;
+        }
+    }
+    else if(opt & MyTHREAD_OPT_QUIT)
+    {
+        if(mythread_function_see_for_all_done(queue_list, ctx->id))
+        {
+            myhtml_hread_sem_close(mythread, ctx);
+            ctx->opt = MyTHREAD_OPT_QUIT;
+            return true;
+        }
+    }
+    
+    myhtml_thread_nanosleep(timeout);
+    
+    return false;
+}
+
 void mythread_function_batch(void *arg)
 {
     mythread_context_t *ctx = (mythread_context_t*)arg;
     mythread_t * mythread = ctx->mythread;
-    mythread_queue_t *queue = mythread->queue;
+    mythread_queue_list_t *queue_list = mythread->queue_list;
     
-    const struct timespec tomeout = {0, 10000};
+    const struct timespec timeout = {0, 10000};
     
     myhtml_hread_sem_wait(mythread, ctx);
     
     do {
-        while (ctx->use >= queue->nodes_uses) {
-            if(mythread->batch_opt & MyTHREAD_OPT_WAIT) {
-                if(ctx->use >= queue->nodes_uses) {
-                    ctx->opt = MyTHREAD_OPT_WAIT;
-                    myhtml_hread_sem_wait(mythread, ctx);
-                    ctx->opt = MyTHREAD_OPT_UNDEF;
-                }
-            }
-            else if(mythread->batch_opt & MyTHREAD_OPT_QUIT) {
-                if(ctx->use >= queue->nodes_uses) {
-                    myhtml_hread_sem_close(mythread, ctx);
-                    ctx->opt = MyTHREAD_OPT_QUIT;
-                    return;
-                }
+        if(mythread->batch_opt & MyTHREAD_OPT_WAIT) {
+            ctx->opt = MyTHREAD_OPT_WAIT;
+            
+            while (mythread->batch_opt & MyTHREAD_OPT_WAIT) {
+                myhtml_thread_nanosleep(&timeout);
             }
             
-            myhtml_thread_nanosleep(&tomeout);
+            ctx->opt = MyTHREAD_OPT_UNDEF;
         }
         
-        size_t pos = ctx->use / queue->nodes_size;
-        size_t len = ctx->use % queue->nodes_size;
+        mythread_queue_list_entry_t *entry = queue_list->first;
+        size_t done_count = 0;
         
-        mythread_queue_node_t *qnode = &queue->nodes[pos][len];
-        
-        if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
-            ctx->func(ctx->id, qnode);
+        while(entry)
+        {
+            mythread_queue_thread_param_t *thread_param = &entry->thread_param[ ctx->id ];
+            
+            if(thread_param->use < entry->queue->nodes_uses)
+            {
+                size_t pos = thread_param->use / entry->queue->nodes_size;
+                size_t len = thread_param->use % entry->queue->nodes_size;
+                
+                mythread_queue_node_t *qnode = &entry->queue->nodes[pos][len];
+                
+                if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
+                    ctx->func(ctx->id, qnode);
+                
+                thread_param->use += ctx->t_count;
+            }
+            else
+                done_count++;
+            
+            entry = entry->next;
+        }
         
-        ctx->use += ctx->t_count;
+        if(done_count == queue_list->count &&
+           mythread_function_see_opt(ctx, mythread->batch_opt, done_count, &timeout))
+            break;
     }
     while (1);
 }
@@ -762,41 +1082,50 @@ void mythread_function_stream(void *arg)
 {
     mythread_context_t *ctx = (mythread_context_t*)arg;
     mythread_t * mythread = ctx->mythread;
-    mythread_queue_t *queue = mythread->queue;
-    
-    const struct timespec tomeout = {0, 10000};
+    mythread_queue_list_t *queue_list = mythread->queue_list;
     
+    const struct timespec timeout = {0, 10000};
     myhtml_hread_sem_wait(mythread, ctx);
     
     do {
-        while (ctx->use >= queue->nodes_uses) {
-            if(mythread->stream_opt & MyTHREAD_OPT_WAIT) {
-                if(ctx->use >= queue->nodes_uses) {
-                    ctx->opt = MyTHREAD_OPT_WAIT;
-                    myhtml_hread_sem_wait(mythread, ctx);
-                    ctx->opt = MyTHREAD_OPT_UNDEF;
-                }
-            }
-            else if(mythread->stream_opt & MyTHREAD_OPT_QUIT) {
-                if(ctx->use >= queue->nodes_uses) {
-                    myhtml_hread_sem_close(mythread, ctx);
-                    ctx->opt = MyTHREAD_OPT_QUIT;
-                    return;
-                }
+        if(mythread->stream_opt & MyTHREAD_OPT_WAIT) {
+            ctx->opt = MyTHREAD_OPT_WAIT;
+            
+            while (mythread->stream_opt & MyTHREAD_OPT_WAIT) {
+                myhtml_thread_nanosleep(&timeout);
             }
             
-            myhtml_thread_nanosleep(&tomeout);
+            ctx->opt = MyTHREAD_OPT_UNDEF;
         }
         
-        size_t pos = ctx->use / queue->nodes_size;
-        size_t len = ctx->use % queue->nodes_size;
-        
-        mythread_queue_node_t *qnode = &queue->nodes[pos][len];
+        mythread_queue_list_entry_t *entry = queue_list->first;
+        size_t done_count = 0;
         
-        if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
-            ctx->func(ctx->id, qnode);
+        while(entry)
+        {
+            mythread_queue_thread_param_t *thread_param = &entry->thread_param[ ctx->id ];
+            
+            if(thread_param->use < entry->queue->nodes_uses)
+            {
+                size_t pos = thread_param->use / entry->queue->nodes_size;
+                size_t len = thread_param->use % entry->queue->nodes_size;
+                
+                mythread_queue_node_t *qnode = &entry->queue->nodes[pos][len];
+                
+                if((qnode->tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
+                    ctx->func(ctx->id, qnode);
+                
+                thread_param->use++;
+            }
+            else
+                done_count++;
+            
+            entry = entry->next;
+        }
         
-        ctx->use++;
+        if(done_count == queue_list->count &&
+           mythread_function_see_opt(ctx, mythread->stream_opt, done_count, &timeout))
+            break;
     }
     while (1);
 }
diff --git a/source/myhtml/thread.h b/source/myhtml/thread.h
index 2fb3826..89a1743 100644
--- a/source/myhtml/thread.h
+++ b/source/myhtml/thread.h
@@ -51,7 +51,6 @@ extern "C" {
 #ifdef MyHTML_BUILD_WITHOUT_THREADS
 
 struct mythread {
-    mythread_queue_t *queue;
     int sys_last_error;
 };
 
@@ -66,7 +65,7 @@ struct mythread_context {
     
 #if defined(IS_OS_WINDOWS)
     HANDLE sem;
-    wchar_t *sem_name;
+    char *sem_name;
 #else
     char *sem_name;
     sem_t *sem;
@@ -76,8 +75,6 @@ struct mythread_context {
     
     mythread_f func;
     
-    volatile size_t use;
-    volatile mythread_queue_node_t *qnode;
     volatile size_t t_count;
     volatile mythread_thread_opt_t opt;
     
@@ -104,7 +101,7 @@ struct mythread {
     size_t pth_list_size;
     size_t pth_list_root;
     
-    mythread_queue_t *queue;
+    mythread_queue_list_t *queue_list;
     
     char  *sem_prefix;
     size_t sem_prefix_length;
@@ -134,15 +131,17 @@ myhtml_status_t mythread_init(mythread_t *mythread, const char *sem_prefix, size
 void mythread_clean(mythread_t *mythread);
 mythread_t * mythread_destroy(mythread_t *mythread, bool self_destroy);
 
-void mythread_stream_pause_all(mythread_t *mythread);
-void mythread_batch_pause_all(mythread_t *mythread);
-
-void mythread_wait_all(mythread_t *mythread);
-void mythread_resume_all(mythread_t *mythread);
-
 void mythread_stream_quit_all(mythread_t *mythread);
 void mythread_batch_quit_all(mythread_t *mythread);
 
+void mythread_stream_stop_all(mythread_t *mythread);
+void mythread_batch_stop_all(mythread_t *mythread);
+
+void mythread_stop_all(mythread_t *mythread);
+void mythread_wait_all_for_done(mythread_t *mythread);
+void mythread_resume_all(mythread_t *mythread);
+void mythread_suspend_all(mythread_t *mythread);
+
 // queue
 struct mythread_queue_node {
     mythread_queue_node_t *prev;
@@ -155,9 +154,22 @@ struct mythread_queue_node {
     const char* text;
 };
 
-struct mythread_queue_list {
-    mythread_queue_list_t *next;
+struct mythread_queue_thread_param {
+    volatile size_t use;
+};
+
+struct mythread_queue_list_entry {
+    mythread_queue_list_entry_t *next;
+    mythread_queue_list_entry_t *prev;
     mythread_queue_t *queue;
+    mythread_queue_thread_param_t *thread_param;
+};
+
+struct mythread_queue_list {
+    mythread_queue_list_entry_t *first;
+    mythread_queue_list_entry_t *last;
+    
+    volatile size_t count;
 };
 
 struct mythread_queue {
@@ -180,9 +192,22 @@ void mythread_queue_node_clean(mythread_queue_node_t* qnode);
 
 size_t mythread_queue_count_used_node(mythread_queue_t* queue);
 mythread_queue_node_t * mythread_queue_get_first_node(mythread_queue_t* queue);
-mythread_queue_node_t * mythread_queue_get_prev_node(mythread_queue_t* queue);
+mythread_queue_node_t * mythread_queue_get_prev_node(mythread_queue_node_t* qnode);
 mythread_queue_node_t * mythread_queue_get_current_node(mythread_queue_t* queue);
-mythread_queue_node_t * mythread_queue_node_malloc(mythread_queue_t* queue, const char* text, size_t begin, myhtml_status_t *status);
+mythread_queue_node_t * mythread_queue_node_malloc(mythread_t *mythread, mythread_queue_t* queue, const char* text, size_t begin, myhtml_status_t *status);
+mythread_queue_node_t * mythread_queue_node_malloc_limit(mythread_t *mythread, mythread_queue_t* queue, const char* text, size_t begin, size_t limit, myhtml_status_t *status);
+
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+
+mythread_queue_list_t * mythread_queue_list_create(mythread_t *mythread, size_t size, myhtml_status_t *status);
+mythread_queue_list_entry_t * mythread_queue_list_entry_push(mythread_t *mythread, mythread_queue_t *queue, myhtml_status_t *status);
+mythread_queue_list_entry_t * mythread_queue_list_entry_delete(mythread_t *mythread, mythread_queue_list_entry_t *entry, bool destroy_queue);
+void mythread_queue_list_entry_clean(mythread_t *mythread, mythread_queue_list_entry_t *entry);
+void mythread_queue_list_entry_wait_for_done(mythread_t *mythread, mythread_queue_list_entry_t *entry);
+    
+mythread_queue_node_t * mythread_queue_node_malloc_round(mythread_t *mythread, mythread_queue_list_entry_t *entry, const char* text, size_t begin, myhtml_status_t *status);
+
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/source/myhtml/token.c b/source/myhtml/token.c
index a7a5c58..428c672 100644
--- a/source/myhtml/token.c
+++ b/source/myhtml/token.c
@@ -847,10 +847,19 @@ myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree,
     return token_to;
 }
 
-void myhtml_token_set_replacement_character_for_null_token(myhtml_token_node_t* node)
+void myhtml_token_set_replacement_character_for_null_token(myhtml_tree_t* tree, myhtml_token_node_t* node)
 {
-    node->my_str_tm.length = myhtml_string_raw_set_replacement_character(&node->my_str_tm, 0);
-    node->length = node->my_str_tm.length;
+    myhtml_token_node_wait_for_done(node);
+    
+    myhtml_string_t new_str;
+    myhtml_string_init(tree->mchar, tree->mchar_node_id, &new_str, (node->my_str_tm.length + 32));
+    
+    myhtml_string_append_with_replacement_null_characters_only(&new_str, node->my_str_tm.data, node->my_str_tm.length);
+    
+    node->length = new_str.length;
+    
+    // TODO: send to cache prev str
+    node->my_str_tm = new_str;
 }
 
 void myhtml_token_set_done(myhtml_token_node_t* node)
diff --git a/source/myhtml/token.h b/source/myhtml/token.h
index a638a4f..fa825a4 100644
--- a/source/myhtml/token.h
+++ b/source/myhtml/token.h
@@ -35,16 +35,9 @@ extern "C" {
 #include "myhtml/utils/mchar_async.h"
 #include "myhtml/utils/mcsync.h"
 
-// attr
-#define myhtml_token_attr(__token__, __idx__) __token__->attr[__idx__]
-#define myhtml_token_attr_get(__token__, __idx__, __patam__) myhtml_token_attr(__token__, __idx__).__patam__
-
-#define myhtml_token_attr_malloc(__token__, __attr_idx__, __thread_idx__)                  \
-    __attr_idx__ = mcobject_async_malloc(__token__->attr_obj, __thread_idx__, NULL);       \
-    myhtml_token_attr_clean(__attr_idx__)
-
-// nodes
-#define myhtml_token_node_get(__token__, __idx__, __patam__) __token__->nodes[__idx__].__patam__
+#define myhtml_token_attr_malloc(__token__, __attr_node__, __thread_idx__)                  \
+    __attr_node__ = mcobject_async_malloc(__token__->attr_obj, __thread_idx__, NULL);       \
+    myhtml_token_attr_clean(__attr_node__)
 
 #define myhtml_token_node_set_done(__token_node__) __token_node__->type |= MyHTML_TOKEN_TYPE_DONE
 
@@ -146,7 +139,7 @@ bool myhtml_token_attr_copy(myhtml_token_t* token, myhtml_token_attr_t* attr, my
 myhtml_token_attr_t * myhtml_token_attr_by_name(myhtml_token_node_t* node, const char* name, size_t name_size);
 bool myhtml_token_attr_compare(myhtml_token_node_t* target, myhtml_token_node_t* dest);
 myhtml_token_node_t * myhtml_token_merged_two_token_string(myhtml_tree_t* tree, myhtml_token_node_t* token_to, myhtml_token_node_t* token_from, bool cp_reverse);
-void myhtml_token_set_replacement_character_for_null_token(myhtml_token_node_t* node);
+void myhtml_token_set_replacement_character_for_null_token(myhtml_tree_t* tree, myhtml_token_node_t* node);
 
 void myhtml_token_print_param_by_idx(myhtml_tree_t* myhtml_tree, myhtml_token_node_t* node, FILE* out);
 void myhtml_token_print_by_idx(myhtml_tree_t* myhtml_tree, myhtml_token_node_t* node, FILE* out);
diff --git a/source/myhtml/tokenizer.c b/source/myhtml/tokenizer.c
index b39cac4..ecbb238 100644
--- a/source/myhtml/tokenizer.c
+++ b/source/myhtml/tokenizer.c
@@ -52,7 +52,7 @@ static const unsigned char myhtml_tokenizer_chars_map[] = {
 
 void myhtml_tokenizer_set_first_settings(myhtml_tree_t* tree, const char* html, size_t html_length)
 {
-    tree->current_qnode       = mythread_queue_get_current_node(tree->queue);
+    tree->current_qnode = mythread_queue_get_current_node(tree->queue);
     
     mythread_queue_node_clean(tree->current_qnode);
     
@@ -82,24 +82,21 @@ void myhtml_tokenizer_chunk_process(myhtml_tree_t* tree, const char* html, size_
     if(myhtml->opt & MyHTML_OPTIONS_PARSE_MODE_SINGLE)
         tree->flags |= MyHTML_TREE_FLAGS_SINGLE_MODE;
     
-    if(tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE)
+    if((tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
     {
-        if(tree->single_queue) {
-            tree->queue = tree->single_queue;
-        }
-        else {
-            tree->queue = mythread_queue_create(4096, NULL);
-            tree->single_queue = tree->queue;
+        if(tree->queue_entry == NULL) {
+            myhtml_status_t status = MyHTML_STATUS_OK;
+            tree->queue_entry = mythread_queue_list_entry_push(myhtml->thread, tree->queue, &status);
+            
+            if(status)
+                return;
         }
-    }
-    else {
-        tree->queue = myhtml->thread->queue;
+        
         myhtml_tokenizer_post(tree);
     }
     
 #else
     
-    tree->queue = myhtml->thread->queue;
     tree->flags |= MyHTML_TREE_FLAGS_SINGLE_MODE;
     
 #endif
@@ -174,15 +171,20 @@ void myhtml_tokenizer_end(myhtml_tree_t* tree)
     }
     
     tree->current_qnode->token->tag_ctx_idx = MyHTML_TAG__END_OF_FILE;
-    mh_queue_add(tree, NULL, 0, NULL);
+    
+    myhtml_queue_add(tree, NULL, 0, NULL);
     
 #ifndef MyHTML_BUILD_WITHOUT_THREADS
     
-    if((tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0 &&
-       (tree->myhtml->opt & MyHTML_OPTIONS_PARSE_MODE_SINGLE) == 0)
+    if((tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE) == 0)
     {
-        myhtml_tokenizer_wait(tree);
-        myhtml_tokenizer_pause(tree);
+        mythread_queue_list_entry_wait_for_done(tree->myhtml->thread, tree->queue_entry);
+        tree->queue_entry = mythread_queue_list_entry_delete(tree->myhtml->thread, tree->queue_entry, false);
+        
+        if(tree->myhtml->thread->queue_list->count == 0) {
+            //myhtml_tokenizer_wait(tree);
+            myhtml_tokenizer_pause(tree);
+        }
     }
     
 #endif
@@ -212,15 +214,15 @@ myhtml_tree_node_t * myhtml_tokenizer_fragment_init(myhtml_tree_t* tree, myhtml_
     if(my_namespace == MyHTML_NAMESPACE_HTML) {
         if(tag_idx == MyHTML_TAG_NOSCRIPT) {
             if(tree->flags & MyHTML_TREE_FLAGS_SCRIPT) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             }
         }
         else {
             const myhtml_tag_context_t *tag_ctx = myhtml_tag_get_by_id(tree->tags, tag_idx);
-            mh_state_set(tree) = tag_ctx->data_parser;
+            myhtml_tokenizer_state_set(tree) = tag_ctx->data_parser;
         }
     }
     
@@ -248,31 +250,24 @@ myhtml_tree_node_t * myhtml_tokenizer_fragment_init(myhtml_tree_t* tree, myhtml_
 
 void myhtml_tokenizer_wait(myhtml_tree_t* tree)
 {
-    myhtml_t* myhtml = tree->myhtml;
-    
-    mythread_wait_all(myhtml->thread);
+    mythread_wait_all_for_done(tree->myhtml->thread);
 }
 
 void myhtml_tokenizer_post(myhtml_tree_t* tree)
 {
-    myhtml_t* myhtml = tree->myhtml;
-    
-    mythread_resume_all(myhtml->thread);
+    mythread_resume_all(tree->myhtml->thread);
 }
 
 void myhtml_tokenizer_pause(myhtml_tree_t* tree)
 {
-    myhtml_t* myhtml = tree->myhtml;
-    
-    mythread_stream_pause_all(myhtml->thread);
-    mythread_batch_pause_all(myhtml->thread);
+    mythread_stop_all(tree->myhtml->thread);
 }
 
 void myhtml_tokenizer_calc_current_namespace(myhtml_tree_t* tree, mythread_queue_node_t* qnode)
 {
     if(tree->flags & MyHTML_TREE_FLAGS_SINGLE_MODE)
     {
-        mh_state_set(tree) = tree->state_of_builder;
+        myhtml_tokenizer_state_set(tree) = tree->state_of_builder;
     }
     else {
         if(qnode->token->tag_ctx_idx == MyHTML_TAG_MATH ||
@@ -287,7 +282,7 @@ void myhtml_tokenizer_calc_current_namespace(myhtml_tree_t* tree, mythread_queue
             if(tag_ctx->data_parser != MyHTML_TOKENIZER_STATE_DATA)
             {
                 myhtml_tree_wait_for_last_done_token(tree, qnode->token);
-                mh_state_set(tree) = tree->state_of_builder;
+                myhtml_tokenizer_state_set(tree) = tree->state_of_builder;
             }
         }
     }
@@ -311,7 +306,7 @@ void myhtml_tokenizer_calc_current_namespace(myhtml_tree_t* tree, mythread_queue
 //    }
 //    else if(tree->token_namespace)
 //    {
-//        mh_state_set(tree) = tree->state_of_builder;
+//        myhtml_tokenizer_state_set(tree) = tree->state_of_builder;
 //    }
 //}
 
@@ -354,7 +349,8 @@ mythread_queue_node_t * myhtml_tokenizer_queue_create_text_node_if_need(myhtml_t
             qnode->token->type |= type;
             qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
             qnode->length = absolute_html_offset - qnode->begin;
-            mh_queue_add(tree, html, 0, qnode);
+            
+            myhtml_queue_add(tree, html, 0, qnode);
             
             return tree->current_qnode;
         }
@@ -370,15 +366,15 @@ void myhtml_tokenizer_set_state(myhtml_tree_t* tree, mythread_queue_node_t* qnod
         if(qnode->token->tag_ctx_idx == MyHTML_TAG_NOSCRIPT &&
            (tree->flags & MyHTML_TREE_FLAGS_SCRIPT) == 0)
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         }
         else {
             const myhtml_tag_context_t *tag_ctx = myhtml_tag_get_by_id(tree->tags, qnode->token->tag_ctx_idx);
-            mh_state_set(tree) = tag_ctx->data_parser;
+            myhtml_tokenizer_state_set(tree) = tag_ctx->data_parser;
         }
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
 }
 
@@ -391,7 +387,8 @@ size_t myhtml_tokenizer_state_rcdata(myhtml_tree_t* tree, mythread_queue_node_t*
     if(tree->tmp_tag_id == 0) {
         qnode->begin = (html_offset + tree->global_offset);
         
-        mythread_queue_node_t* prev_qnode = mythread_queue_get_prev_node(tree->queue);
+        mythread_queue_node_t* prev_qnode = mythread_queue_get_prev_node(qnode);
+        
         if(prev_qnode && prev_qnode->token) {
             tree->tmp_tag_id = prev_qnode->token->tag_ctx_idx;
         }
@@ -405,7 +402,7 @@ size_t myhtml_tokenizer_state_rcdata(myhtml_tree_t* tree, mythread_queue_node_t*
         if(html[html_offset] == '<')
         {
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_LESS_THAN_SIGN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_LESS_THAN_SIGN;
             
             break;
         }
@@ -421,10 +418,10 @@ size_t myhtml_tokenizer_state_rcdata_less_than_sign(myhtml_tree_t* tree, mythrea
     if(html[html_offset] == '/')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_OPEN;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
     }
     
     return html_offset;
@@ -434,10 +431,10 @@ size_t myhtml_tokenizer_state_rcdata_end_tag_open(myhtml_tree_t* tree, mythread_
 {
     if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] == MyHTML_TOKENIZER_CHAR_A_Z_a_z)
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA_END_TAG_NAME;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
     }
     
     return html_offset;
@@ -453,7 +450,7 @@ bool _myhtml_tokenizer_state_andata_end_tag_name(myhtml_tree_t* tree, mythread_q
         qnode->begin  = tmp_begin;
         qnode->length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
         
         (*html_offset)++;
         return false;
@@ -466,7 +463,7 @@ bool _myhtml_tokenizer_state_andata_end_tag_name(myhtml_tree_t* tree, mythread_q
         qnode->token->type       |= type;
         qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
         
-        mh_queue_add(tree, html, *html_offset, qnode);
+        myhtml_queue_add(tree, html, *html_offset, qnode);
         qnode = tree->current_qnode;
     }
     
@@ -486,7 +483,7 @@ size_t myhtml_tokenizer_state_rcdata_end_tag_name(myhtml_tree_t* tree, mythread_
         if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] == MyHTML_TOKENIZER_CHAR_WHITESPACE)
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RCDATA)) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
                 
                 tree->tmp_tag_id = 0;
                 html_offset++;
@@ -500,10 +497,10 @@ size_t myhtml_tokenizer_state_rcdata_end_tag_name(myhtml_tree_t* tree, mythread_
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RCDATA)) {
                 html_offset++;
-                mh_queue_add(tree, html, html_offset, qnode);
+                myhtml_queue_add(tree, html, html_offset, qnode);
                 
                 tree->tmp_tag_id = 0;
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
                 
                 return html_offset;
             }
@@ -514,7 +511,7 @@ size_t myhtml_tokenizer_state_rcdata_end_tag_name(myhtml_tree_t* tree, mythread_
         else if(html[html_offset] == '/')
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RCDATA)) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
                 
                 tree->tmp_tag_id = 0;
                 html_offset++;
@@ -525,7 +522,7 @@ size_t myhtml_tokenizer_state_rcdata_end_tag_name(myhtml_tree_t* tree, mythread_
             break;
         }
         else if (myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] != MyHTML_TOKENIZER_CHAR_A_Z_a_z) {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RCDATA;
             break;
         }
         
@@ -545,7 +542,8 @@ size_t myhtml_tokenizer_state_rawtext(myhtml_tree_t* tree, mythread_queue_node_t
     if(tree->tmp_tag_id == 0) {
         qnode->begin = (html_offset + tree->global_offset);
         
-        mythread_queue_node_t* prev_qnode = mythread_queue_get_prev_node(tree->queue);
+        mythread_queue_node_t* prev_qnode = mythread_queue_get_prev_node(qnode);
+        
         if(prev_qnode && prev_qnode->token) {
             tree->tmp_tag_id = prev_qnode->token->tag_ctx_idx;
         }
@@ -560,7 +558,7 @@ size_t myhtml_tokenizer_state_rawtext(myhtml_tree_t* tree, mythread_queue_node_t
         if(html[html_offset] == '<')
         {
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_LESS_THAN_SIGN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_LESS_THAN_SIGN;
             
             break;
         }
@@ -576,10 +574,10 @@ size_t myhtml_tokenizer_state_rawtext_less_than_sign(myhtml_tree_t* tree, mythre
     if(html[html_offset] == '/')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_END_TAG_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_END_TAG_OPEN;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
     }
     
     return html_offset;
@@ -589,10 +587,10 @@ size_t myhtml_tokenizer_state_rawtext_end_tag_open(myhtml_tree_t* tree, mythread
 {
     if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] == MyHTML_TOKENIZER_CHAR_A_Z_a_z)
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_END_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT_END_TAG_NAME;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
     }
     
     return html_offset;
@@ -608,7 +606,7 @@ size_t myhtml_tokenizer_state_rawtext_end_tag_name(myhtml_tree_t* tree, mythread
         if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] == MyHTML_TOKENIZER_CHAR_WHITESPACE)
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RAWTEXT)) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
                 
                 tree->tmp_tag_id = 0;
                 html_offset++;
@@ -620,10 +618,10 @@ size_t myhtml_tokenizer_state_rawtext_end_tag_name(myhtml_tree_t* tree, mythread
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RAWTEXT)) {
                 html_offset++;
-                mh_queue_add(tree, html, html_offset, qnode);
+                myhtml_queue_add(tree, html, html_offset, qnode);
                 
                 tree->tmp_tag_id = 0;
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             }
             
             return html_offset;
@@ -632,7 +630,7 @@ size_t myhtml_tokenizer_state_rawtext_end_tag_name(myhtml_tree_t* tree, mythread
         else if(html[html_offset] == '/')
         {
             if(_myhtml_tokenizer_state_andata_end_tag_name(tree, qnode, html, &html_offset, tmp_begin, MyHTML_TOKEN_TYPE_RAWTEXT)) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
                 
                 tree->tmp_tag_id = 0;
                 html_offset++;
@@ -642,7 +640,7 @@ size_t myhtml_tokenizer_state_rawtext_end_tag_name(myhtml_tree_t* tree, mythread
         }
         else if (myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] != MyHTML_TOKENIZER_CHAR_A_Z_a_z) {
             qnode->begin = tmp_begin;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_RAWTEXT;
             
             return html_offset;
         }
@@ -667,8 +665,8 @@ size_t myhtml_tokenizer_state_plaintext(myhtml_tree_t* tree, mythread_queue_node
     qnode->length = (html_size + tree->global_offset) - qnode->begin;
     qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
     
-    mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
-    mh_queue_add(tree, html, html_size, qnode);
+    myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+    myhtml_queue_add(tree, html, html_size, qnode);
     
     return html_size;
 }
@@ -698,13 +696,13 @@ size_t myhtml_tokenizer_state_cdata_section(myhtml_tree_t* tree, mythread_queue_
                 html_offset++;
                 
                 if(qnode->length) {
-                    mh_queue_add(tree, html, html_offset, qnode);
+                    myhtml_queue_add(tree, html, html_offset, qnode);
                 }
                 else {
                     qnode->begin = html_offset + tree->global_offset;
                 }
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
                 break;
             }
         }
@@ -726,57 +724,17 @@ size_t myhtml_tokenizer_state_data(myhtml_tree_t* tree, mythread_queue_node_t* q
         if(html[html_offset] == '<')
         {
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_OPEN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_OPEN;
             
             break;
         }
-        else if(html[html_offset] == '\0') {
-            size_t ab_offset = (tree->global_offset + html_offset);
-            
-            if(ab_offset > qnode->begin)
-            {
-                qnode->token->type |= MyHTML_TOKEN_TYPE_DATA;
-                qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
-                qnode->length = ab_offset - qnode->begin;
-                mh_queue_add(tree, html, ab_offset, qnode);
-                
-                qnode = tree->current_qnode;
-            }
-            else
-                qnode->begin = ab_offset;
-            
-            ab_offset++;
-            
-            qnode->token->type |= MyHTML_TOKEN_TYPE_DATA|MyHTML_TOKEN_TYPE_NULL;
-            qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
-            qnode->length = 1;
-            mh_queue_add(tree, html, ab_offset, qnode);
-            
-            qnode = tree->current_qnode;
+        else if(html[html_offset] == '\0' && (qnode->token->type & MyHTML_TOKEN_TYPE_NULL) == 0) {
+            qnode->token->type |= MyHTML_TOKEN_TYPE_NULL;
         }
-//        else if(qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE)
-//        {
-//            if(myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] != MyHTML_TOKENIZER_CHAR_WHITESPACE)
-//            {
-//                size_t ab_offset = (tree->global_offset + html_offset);
-//                
-//                if(ab_offset > qnode->begin)
-//                {
-//                    qnode->token->type |= MyHTML_TOKEN_TYPE_DATA;
-//                    qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
-//                    qnode->length = ab_offset - qnode->begin;
-//                    mh_queue_add(tree, html, ab_offset, qnode);
-//                    
-//                    qnode = tree->current_qnode;
-//                }
-//                
-//                qnode->token->type ^= (qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE);
-//            }
-//        }
         else if(qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE &&
                 myhtml_tokenizer_chars_map[ (unsigned char)html[html_offset] ] != MyHTML_TOKENIZER_CHAR_WHITESPACE) {
             qnode->token->type ^= (qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE);
-            qnode->token->type = MyHTML_TOKEN_TYPE_DATA;
+            qnode->token->type |= MyHTML_TOKEN_TYPE_DATA;
         }
         
         html_offset++;
@@ -797,7 +755,7 @@ size_t myhtml_tokenizer_state_tag_open(myhtml_tree_t* tree, mythread_queue_node_
         
         qnode->begin = tree->global_offset + html_offset;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_NAME;
     }
     else if(html[html_offset] == '!')
     {
@@ -806,12 +764,12 @@ size_t myhtml_tokenizer_state_tag_open(myhtml_tree_t* tree, mythread_queue_node_
         html_offset++;
         qnode->begin = tree->global_offset + html_offset;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_MARKUP_DECLARATION_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_MARKUP_DECLARATION_OPEN;
     }
     else if(html[html_offset] == '/')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_END_TAG_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_END_TAG_OPEN;
     }
     else if(html[html_offset] == '?')
     {
@@ -819,11 +777,11 @@ size_t myhtml_tokenizer_state_tag_open(myhtml_tree_t* tree, mythread_queue_node_
         
         qnode->begin = tree->global_offset + html_offset;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
     }
     else {
         qnode->token->type ^= (qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE);
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     
     return html_offset;
@@ -842,19 +800,19 @@ size_t myhtml_tokenizer_state_end_tag_open(myhtml_tree_t* tree, mythread_queue_n
         qnode->begin = tree->global_offset + html_offset;
         qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_TAG_NAME;
     }
     else if(html[html_offset] == '>')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     else {
         qnode = myhtml_tokenizer_queue_create_text_node_if_need(tree, qnode, html, ((tree->global_offset + html_offset) - 2), MyHTML_TOKEN_TYPE_DATA);
         
         qnode->begin = tree->global_offset + html_offset;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
     }
     
     return html_offset;
@@ -876,7 +834,7 @@ size_t myhtml_tokenizer_state_markup_declaration_open(myhtml_tree_t* tree, mythr
     // for a comment
     if(tagname[0] == '-' && tagname[1] == '-')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_START;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_START;
         
         html_offset += 2;
         
@@ -895,7 +853,7 @@ size_t myhtml_tokenizer_state_markup_declaration_open(myhtml_tree_t* tree, mythr
     
     if(myhtml_strncasecmp(tagname, "DOCTYPE", 7) == 0)
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE;
         
         html_offset = (qnode->begin + 7) - tree->incoming_buf->offset;
         
@@ -915,7 +873,7 @@ size_t myhtml_tokenizer_state_markup_declaration_open(myhtml_tree_t* tree, mythr
             if(adjusted_current_node &&
                adjusted_current_node->my_namespace != MyHTML_NAMESPACE_HTML)
             {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_CDATA_SECTION;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_CDATA_SECTION;
                 
                 html_offset = (qnode->begin + 7) - tree->incoming_buf->offset;
                 
@@ -930,7 +888,7 @@ size_t myhtml_tokenizer_state_markup_declaration_open(myhtml_tree_t* tree, mythr
     
     qnode->length = 0;
     
-    mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
+    myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_COMMENT;
     return html_offset;
 }
 
@@ -948,7 +906,7 @@ size_t myhtml_tokenizer_state_tag_name(myhtml_tree_t* tree, mythread_queue_node_
             myhtml_check_tag_parser(tree, qnode, html, html_offset);
             
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             
             break;
         }
@@ -958,7 +916,7 @@ size_t myhtml_tokenizer_state_tag_name(myhtml_tree_t* tree, mythread_queue_node_
             myhtml_check_tag_parser(tree, qnode, html, html_offset);
             
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SELF_CLOSING_START_TAG;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SELF_CLOSING_START_TAG;
             
             break;
         }
@@ -970,7 +928,7 @@ size_t myhtml_tokenizer_state_tag_name(myhtml_tree_t* tree, mythread_queue_node_
             myhtml_tokenizer_set_state(tree, qnode);
             
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
             break;
         }
@@ -992,10 +950,10 @@ size_t myhtml_tokenizer_state_self_closing_start_tag(myhtml_tree_t* tree, mythre
         myhtml_tokenizer_set_state(tree, qnode);
         
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
     }
     
     return html_offset;
@@ -1019,7 +977,7 @@ size_t myhtml_tokenizer_state_before_attribute_name(myhtml_tree_t* tree, mythrea
         myhtml_tokenizer_set_state(tree, qnode);
         
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
     }
     else if(html[html_offset] == '/') {
         qnode->token->type |= MyHTML_TOKEN_TYPE_CLOSE_SELF;
@@ -1034,7 +992,7 @@ size_t myhtml_tokenizer_state_before_attribute_name(myhtml_tree_t* tree, mythrea
         tree->attr_current->value_begin  = 0;
         tree->attr_current->value_length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
     }
     
     return html_offset;
@@ -1051,7 +1009,7 @@ size_t myhtml_tokenizer_state_attribute_name(myhtml_tree_t* tree, mythread_queue
         if(myhtml_whithspace(html[html_offset], ==, ||))
         {
             tree->attr_current->name_length = (tree->global_offset + html_offset) - tree->attr_current->name_begin;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_ATTRIBUTE_NAME;
             
             html_offset++;
             break;
@@ -1059,7 +1017,7 @@ size_t myhtml_tokenizer_state_attribute_name(myhtml_tree_t* tree, mythread_queue
         else if(html[html_offset] == '=')
         {
             tree->attr_current->name_length = (tree->global_offset + html_offset) - tree->attr_current->name_begin;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_VALUE;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_VALUE;
             
             html_offset++;
             break;
@@ -1071,7 +1029,7 @@ size_t myhtml_tokenizer_state_attribute_name(myhtml_tree_t* tree, mythread_queue
             
             html_offset++;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
@@ -1082,7 +1040,7 @@ size_t myhtml_tokenizer_state_attribute_name(myhtml_tree_t* tree, mythread_queue
             tree->attr_current->name_length = (tree->global_offset + html_offset) - tree->attr_current->name_begin;
             
             qnode->token->type |= MyHTML_TOKEN_TYPE_CLOSE_SELF;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
@@ -1106,7 +1064,7 @@ size_t myhtml_tokenizer_state_after_attribute_name(myhtml_tree_t* tree, mythread
     {
         if(html[html_offset] == '=')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_VALUE;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_VALUE;
             
             html_offset++;
             break;
@@ -1117,7 +1075,7 @@ size_t myhtml_tokenizer_state_after_attribute_name(myhtml_tree_t* tree, mythread
             
             html_offset++;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
@@ -1133,7 +1091,7 @@ size_t myhtml_tokenizer_state_after_attribute_name(myhtml_tree_t* tree, mythread
             tree->attr_current->value_begin  = 0;
             tree->attr_current->value_length = 0;
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
             break;
         }
         else if(myhtml_whithspace(html[html_offset], !=, &&))
@@ -1146,7 +1104,7 @@ size_t myhtml_tokenizer_state_after_attribute_name(myhtml_tree_t* tree, mythread
             tree->attr_current->value_begin  = 0;
             tree->attr_current->value_length = 0;
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_NAME;
             break;
         }
         
@@ -1169,7 +1127,7 @@ size_t myhtml_tokenizer_state_before_attribute_value(myhtml_tree_t* tree, mythre
             
             html_offset++;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
@@ -1179,14 +1137,14 @@ size_t myhtml_tokenizer_state_before_attribute_value(myhtml_tree_t* tree, mythre
         {
             if(html[html_offset] == '"') {
                 html_offset++;
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_DOUBLE_QUOTED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_DOUBLE_QUOTED;
             }
             else if(html[html_offset] == '\'') {
                 html_offset++;
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_SINGLE_QUOTED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_SINGLE_QUOTED;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_UNQUOTED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_ATTRIBUTE_VALUE_UNQUOTED;
             }
             
             tree->attr_current->value_begin = (tree->global_offset + html_offset);
@@ -1216,7 +1174,7 @@ size_t myhtml_tokenizer_state_attribute_value_double_quoted(myhtml_tree_t* tree,
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             
             html_offset++;
             break;
@@ -1244,7 +1202,7 @@ size_t myhtml_tokenizer_state_attribute_value_single_quoted(myhtml_tree_t* tree,
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             
             html_offset++;
             break;
@@ -1266,7 +1224,7 @@ size_t myhtml_tokenizer_state_attribute_value_unquoted(myhtml_tree_t* tree, myth
     {
         if(myhtml_whithspace(html[html_offset], ==, ||))
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             
             tree->attr_current->value_length = (tree->global_offset + html_offset) - tree->attr_current->value_begin;
             
@@ -1282,7 +1240,7 @@ size_t myhtml_tokenizer_state_attribute_value_unquoted(myhtml_tree_t* tree, myth
             
             html_offset++;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
@@ -1305,21 +1263,21 @@ size_t myhtml_tokenizer_state_comment_start(myhtml_tree_t* tree, mythread_queue_
     
     if(html[html_offset] == '-')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_START_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_START_DASH;
     }
     else if(html[html_offset] == '>')
     {
         html_offset++;
         
         qnode->length = 0;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         
         return html_offset;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
     }
     
     html_offset++;
@@ -1333,21 +1291,21 @@ size_t myhtml_tokenizer_state_comment_start_dash(myhtml_tree_t* tree, mythread_q
     
     if(html[html_offset] == '-')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END;
     }
     else if(html[html_offset] == '>')
     {
         html_offset++;
         
         qnode->length = 0;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         
         return html_offset;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
     }
     
     html_offset++;
@@ -1363,7 +1321,7 @@ size_t myhtml_tokenizer_state_comment(myhtml_tree_t* tree, mythread_queue_node_t
     {
         if(html[html_offset] == '-')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_DASH;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_DASH;
             html_offset++;
             break;
         }
@@ -1379,11 +1337,11 @@ size_t myhtml_tokenizer_state_comment_end_dash(myhtml_tree_t* tree, mythread_que
     if(html[html_offset] == '-')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END;
     }
     else {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
     }
     
     return html_offset;
@@ -1401,20 +1359,20 @@ size_t myhtml_tokenizer_state_comment_end(myhtml_tree_t* tree, mythread_queue_no
             qnode->length = 0;
         
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     else if(html[html_offset] == '!') {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_BANG;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_BANG;
     }
     else if(html[html_offset] == '-') {
         html_offset++;
     }
     else {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
     }
     
     return html_offset;
@@ -1428,23 +1386,23 @@ size_t myhtml_tokenizer_state_comment_end_bang(myhtml_tree_t* tree, mythread_que
             qnode->length = ((tree->global_offset + html_offset) - qnode->begin) - 3;
             
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
         }
         else {
             html_offset++;
             qnode->length = 0;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
         }
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     else if(html[html_offset] == '-') {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT_END_DASH;
     }
     else {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_COMMENT;
     }
     
     return html_offset;
@@ -1466,9 +1424,9 @@ size_t myhtml_tokenizer_state_bogus_comment(myhtml_tree_t* tree, mythread_queue_
             qnode->length = ((tree->global_offset + html_offset) - qnode->begin);
             
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             break;
         }
         
diff --git a/source/myhtml/tokenizer_doctype.c b/source/myhtml/tokenizer_doctype.c
index 2880f11..d640d8f 100644
--- a/source/myhtml/tokenizer_doctype.c
+++ b/source/myhtml/tokenizer_doctype.c
@@ -26,7 +26,7 @@ size_t myhtml_tokenizer_state_doctype(myhtml_tree_t* tree, mythread_queue_node_t
 {
     //myhtml_t* myhtml = tree->myhtml;
     
-    mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_DOCTYPE_NAME;
+    myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_DOCTYPE_NAME;
     
     return html_offset;
 }
@@ -48,16 +48,16 @@ size_t myhtml_tokenizer_state_before_doctype_name(myhtml_tree_t* tree, mythread_
         tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
         
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     else {
         myhtml_parser_queue_set_attr(tree, qnode);
         tree->attr_current->name_begin = (html_offset + tree->global_offset);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_NAME;
     }
     
     return html_offset;
@@ -77,10 +77,10 @@ size_t myhtml_tokenizer_state_doctype_name(myhtml_tree_t* tree, mythread_queue_n
             
             html_offset++;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             
             break;
         }
@@ -90,7 +90,7 @@ size_t myhtml_tokenizer_state_doctype_name(myhtml_tree_t* tree, mythread_queue_n
             
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_NAME;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_NAME;
             
             html_offset++;
             break;
@@ -116,14 +116,14 @@ size_t myhtml_tokenizer_state_after_doctype_name(myhtml_tree_t* tree, mythread_q
     if(html[html_offset] == '>')
     {
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         return html_offset;
     }
     
     qnode->begin = (html_offset + tree->global_offset);
-    mh_state_set(tree) = MyHTML_TOKENIZER_STATE_CUSTOM_AFTER_DOCTYPE_NAME_A_Z;
+    myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_CUSTOM_AFTER_DOCTYPE_NAME_A_Z;
     
     return html_offset;
 }
@@ -144,7 +144,7 @@ size_t myhtml_tokenizer_state_custom_after_doctype_name_a_z(myhtml_tree_t* tree,
         
         myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER;
         
         html_offset = (qnode->begin + 6) - tree->incoming_buf->offset;
     }
@@ -156,13 +156,13 @@ size_t myhtml_tokenizer_state_custom_after_doctype_name_a_z(myhtml_tree_t* tree,
         
         myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
         
         html_offset = (qnode->begin + 6) - tree->incoming_buf->offset;
     }
     else {
         tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
     }
     
     return html_offset;
@@ -183,27 +183,27 @@ size_t myhtml_tokenizer_state_before_doctype_public_identifier(myhtml_tree_t* tr
         tree->attr_current->value_begin  = (html_offset + tree->global_offset) + 1;
         tree->attr_current->value_length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED;
     }
     else if(html[html_offset] == '\'') {
         tree->attr_current->value_begin  = (html_offset + tree->global_offset) + 1;
         tree->attr_current->value_length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED;
     }
     else if(html[html_offset] == '>')
     {
         tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
         
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         return html_offset;
     }
     else {
         tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
     }
     
     return (html_offset + 1);
@@ -224,7 +224,7 @@ size_t myhtml_tokenizer_doctype_public_identifier_dsq(myhtml_tree_t* tree, mythr
             myhtml_parser_queue_set_attr(tree, qnode);
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_PUBLIC_IDENTIFIER;
             
             html_offset++;
             break;
@@ -241,9 +241,9 @@ size_t myhtml_tokenizer_doctype_public_identifier_dsq(myhtml_tree_t* tree, mythr
             }
             
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             break;
         }
         
@@ -279,27 +279,27 @@ size_t myhtml_tokenizer_state_after_doctype_public_identifier(myhtml_tree_t* tre
         tree->attr_current->value_begin  = (html_offset + tree->global_offset) + 1;
         tree->attr_current->value_length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED;
     }
     else if(html[html_offset] == '\'')
     {
         tree->attr_current->value_begin  = (html_offset + tree->global_offset) + 1;
         tree->attr_current->value_length = 0;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED;
     }
     else if(html[html_offset] == '>')
     {
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
         return html_offset;
     }
     else {
         tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
         return html_offset;
     }
     
@@ -323,7 +323,7 @@ size_t myhtml_tokenizer_doctype_system_identifier_dsq(myhtml_tree_t* tree, mythr
             myhtml_parser_queue_set_attr(tree, qnode);
             myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_AFTER_DOCTYPE_SYSTEM_IDENTIFIER;
             
             html_offset++;
             break;
@@ -340,9 +340,9 @@ size_t myhtml_tokenizer_doctype_system_identifier_dsq(myhtml_tree_t* tree, mythr
             }
             
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             break;
         }
         
@@ -376,12 +376,12 @@ size_t myhtml_tokenizer_state_after_doctype_system_identifier(myhtml_tree_t* tre
     if(html[html_offset] == '>')
     {
         html_offset++;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
         
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BOGUS_DOCTYPE;
     }
     
     return html_offset;
@@ -398,9 +398,9 @@ size_t myhtml_tokenizer_state_bogus_doctype(myhtml_tree_t* tree, mythread_queue_
         if(html[html_offset] == '>')
         {
             html_offset++;
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
             
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             break;
         }
         
diff --git a/source/myhtml/tokenizer_end.c b/source/myhtml/tokenizer_end.c
index 418b2ab..9db3a67 100644
--- a/source/myhtml/tokenizer_end.c
+++ b/source/myhtml/tokenizer_end.c
@@ -32,7 +32,7 @@ size_t myhtml_tokenizer_end_state_tag_open(myhtml_tree_t* tree, mythread_queue_n
             qnode->length = (html_offset + tree->global_offset) - qnode->begin;
             myhtml_check_tag_parser(tree, qnode, html, html_offset);
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
         }
         else {
             qnode->token->type ^= (qnode->token->type & MyHTML_TOKEN_TYPE_WHITESPACE);
@@ -85,7 +85,7 @@ size_t myhtml_tokenizer_end_state_markup_declaration_open(myhtml_tree_t* tree, m
                 
                 qnode->length = (html_size + tree->global_offset) - qnode->begin;
                 
-                mh_queue_add(tree, html, html_offset, qnode);
+                myhtml_queue_add(tree, html, html_offset, qnode);
             }
         }
         else {
@@ -95,7 +95,7 @@ size_t myhtml_tokenizer_end_state_markup_declaration_open(myhtml_tree_t* tree, m
             
             qnode->length = (html_size + tree->global_offset) - qnode->begin;
             
-            mh_queue_add(tree, html, html_offset, qnode);
+            myhtml_queue_add(tree, html, html_offset, qnode);
         }
     }
     
@@ -104,27 +104,27 @@ size_t myhtml_tokenizer_end_state_markup_declaration_open(myhtml_tree_t* tree, m
 
 size_t myhtml_tokenizer_end_state_before_attribute_name(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_attribute_name(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     tree->attr_current->name_length = (html_offset + tree->global_offset) - tree->attr_current->name_begin;
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_after_attribute_name(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_before_attribute_value(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
     
     return html_offset;
@@ -134,7 +134,7 @@ size_t myhtml_tokenizer_end_state_attribute_value_double_quoted(myhtml_tree_t* t
 {
 //    tree->attr_current->value_length = (html_offset + tree->global_offset) - tree->attr_current->value_begin;
 //    
-//    mh_queue_add(tree, html, html_offset, qnode);
+//    myhtml_queue_add(tree, html, html_offset, qnode);
 //    myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
     
     return html_offset;
@@ -144,7 +144,7 @@ size_t myhtml_tokenizer_end_state_attribute_value_single_quoted(myhtml_tree_t* t
 {
 //    tree->attr_current->value_length = (html_offset + tree->global_offset) - tree->attr_current->value_begin;
 //    
-//    mh_queue_add(tree, html, html_offset, qnode);
+//    myhtml_queue_add(tree, html, html_offset, qnode);
 //    myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
     
     return html_offset;
@@ -154,7 +154,7 @@ size_t myhtml_tokenizer_end_state_attribute_value_unquoted(myhtml_tree_t* tree,
 {
     tree->attr_current->value_length = (html_offset + tree->global_offset) - tree->attr_current->value_begin;
     
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->token->mcasync_attr_id);
     
     return html_offset;
@@ -163,7 +163,7 @@ size_t myhtml_tokenizer_end_state_attribute_value_unquoted(myhtml_tree_t* tree,
 size_t myhtml_tokenizer_end_state_comment_start(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -171,7 +171,7 @@ size_t myhtml_tokenizer_end_state_comment_start(myhtml_tree_t* tree, mythread_qu
 size_t myhtml_tokenizer_end_state_comment_start_dash(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -179,7 +179,7 @@ size_t myhtml_tokenizer_end_state_comment_start_dash(myhtml_tree_t* tree, mythre
 size_t myhtml_tokenizer_end_state_comment(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -190,7 +190,7 @@ size_t myhtml_tokenizer_end_state_comment_end(myhtml_tree_t* tree, mythread_queu
     
     if(qnode->length > 2) {
         qnode->length -= 2;
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
     }
     
     return html_offset;
@@ -199,7 +199,7 @@ size_t myhtml_tokenizer_end_state_comment_end(myhtml_tree_t* tree, mythread_queu
 size_t myhtml_tokenizer_end_state_comment_end_dash(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -207,7 +207,7 @@ size_t myhtml_tokenizer_end_state_comment_end_dash(myhtml_tree_t* tree, mythread
 size_t myhtml_tokenizer_end_state_comment_end_bang(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -215,7 +215,7 @@ size_t myhtml_tokenizer_end_state_comment_end_bang(myhtml_tree_t* tree, mythread
 size_t myhtml_tokenizer_end_state_bogus_comment(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -225,7 +225,7 @@ size_t myhtml_tokenizer_end_state_cdata_section(myhtml_tree_t* tree, mythread_qu
     qnode->length = ((html_offset + tree->global_offset) - qnode->begin);
     
     if(qnode->length) {
-        mh_queue_add(tree, html, html_offset, qnode);
+        myhtml_queue_add(tree, html, html_offset, qnode);
     }
     
     return html_offset;
@@ -238,7 +238,7 @@ size_t myhtml_tokenizer_end_state_rcdata(myhtml_tree_t* tree, mythread_queue_nod
         qnode->token->tag_ctx_idx = MyHTML_TAG__TEXT;
         qnode->length = (html_size + tree->global_offset) - qnode->begin;
         
-        mh_queue_add(tree, html, 0, qnode);
+        myhtml_queue_add(tree, html, 0, qnode);
     }
     
     return html_offset;
@@ -301,7 +301,7 @@ size_t myhtml_tokenizer_end_state_doctype(myhtml_tree_t* tree, mythread_queue_no
 size_t myhtml_tokenizer_end_state_before_doctype_name(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -310,27 +310,27 @@ size_t myhtml_tokenizer_end_state_doctype_name(myhtml_tree_t* tree, mythread_que
 {
     tree->attr_current->name_length = (html_offset + tree->global_offset) - tree->attr_current->name_begin;
     
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_after_doctype_name(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_custom_after_doctype_name_a_z(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_before_doctype_public_identifier(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     tree->compat_mode = MyHTML_TREE_COMPAT_MODE_QUIRKS;
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -343,7 +343,7 @@ size_t myhtml_tokenizer_end_state_doctype_public_identifier_double_quoted(myhtml
         tree->attr_current->name_length = (html_offset + tree->global_offset) - tree->attr_current->name_begin;
     }
     
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -356,7 +356,7 @@ size_t myhtml_tokenizer_end_state_doctype_public_identifier_single_quoted(myhtml
 
 size_t myhtml_tokenizer_end_state_after_doctype_public_identifier(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
@@ -368,7 +368,7 @@ size_t myhtml_tokenizer_end_state_doctype_system_identifier_double_quoted(myhtml
         tree->attr_current->name_length = (html_offset + tree->global_offset) - tree->attr_current->name_begin;
     }
     
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     
     return html_offset;
 }
@@ -381,13 +381,13 @@ size_t myhtml_tokenizer_end_state_doctype_system_identifier_single_quoted(myhtml
 
 size_t myhtml_tokenizer_end_state_after_doctype_system_identifier(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
 size_t myhtml_tokenizer_end_state_bogus_doctype(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
-    mh_queue_add(tree, html, html_offset, qnode);
+    myhtml_queue_add(tree, html, html_offset, qnode);
     return html_offset;
 }
 
diff --git a/source/myhtml/tokenizer_script.c b/source/myhtml/tokenizer_script.c
index 38d13ce..55431e3 100644
--- a/source/myhtml/tokenizer_script.c
+++ b/source/myhtml/tokenizer_script.c
@@ -25,7 +25,7 @@ size_t myhtml_tokenizer_state_script_data(myhtml_tree_t* tree, mythread_queue_no
     {
         if(html[html_offset] == '<') {
             html_offset++;
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_LESS_THAN_SIGN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_LESS_THAN_SIGN;
             
             break;
         }
@@ -41,15 +41,15 @@ size_t myhtml_tokenizer_state_script_data_less_than_sign(myhtml_tree_t* tree, my
     if(html[html_offset] == '/')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_END_TAG_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_END_TAG_OPEN;
     }
     else if(html[html_offset] == '!')
     {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPE_START;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPE_START;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     
     return html_offset;
@@ -59,10 +59,10 @@ size_t myhtml_tokenizer_state_script_data_escape_start(myhtml_tree_t* tree, myth
 {
     if(html[html_offset] == '-') {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPE_START_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPE_START_DASH;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     
     return html_offset;
@@ -72,10 +72,10 @@ size_t myhtml_tokenizer_state_script_data_escape_start_dash(myhtml_tree_t* tree,
 {
     if(html[html_offset] == '-') {
         html_offset++;
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH_DASH;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     
     return html_offset;
@@ -85,10 +85,10 @@ size_t myhtml_tokenizer_state_script_data_end_tag_open(myhtml_tree_t* tree, myth
 {
     if(myhtml_ascii_char_cmp(html[html_offset])) {
         qnode->token->begin = (html_offset + tree->global_offset);
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_END_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_END_TAG_NAME;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     
     return html_offset;
@@ -101,7 +101,7 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
         if(myhtml_whithspace(html[html_offset], ==, ||))
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
                 html_offset++;
                 break;
             }
@@ -122,10 +122,10 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
                 qnode->token->tag_ctx_idx = MyHTML_TAG_SCRIPT;
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE;
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
             }
             
             html_offset++;
@@ -134,7 +134,7 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
         else if(html[html_offset] == '/')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
                 html_offset++;
                 break;
             }
@@ -155,10 +155,10 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
                 qnode->token->tag_ctx_idx = MyHTML_TAG_SCRIPT;
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE|MyHTML_TOKEN_TYPE_CLOSE_SELF;
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
             }
             
             html_offset++;
@@ -167,7 +167,7 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
         else if(html[html_offset] == '>')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
                 html_offset++;
                 break;
             }
@@ -188,12 +188,12 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE;
                 
                 html_offset++;
-                mh_queue_add(tree, html, html_offset, qnode);
+                myhtml_queue_add(tree, html, html_offset, qnode);
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
                 html_offset++;
             }
             
@@ -201,7 +201,7 @@ size_t myhtml_tokenizer_state_script_data_end_tag_name(myhtml_tree_t* tree, myth
         }
         else if(myhtml_ascii_char_unless_cmp(html[html_offset]))
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
             break;
         }
         
@@ -219,13 +219,13 @@ size_t myhtml_tokenizer_state_script_data_escaped_dash_dash(myhtml_tree_t* tree,
     }
     
     if(html[html_offset] == '<') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
     }
     else if(html[html_offset] == '>') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
     }
     
     html_offset++;
@@ -236,15 +236,15 @@ size_t myhtml_tokenizer_state_script_data_escaped_dash_dash(myhtml_tree_t* tree,
 size_t myhtml_tokenizer_state_script_data_escaped_less_than_sign(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     if(html[html_offset] == '/') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_END_TAG_OPEN;
         html_offset++;
     }
     else if(myhtml_ascii_char_cmp(html[html_offset])) {
         qnode->token->begin = (html_offset + tree->global_offset);
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPE_START;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPE_START;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
     }
     
     return html_offset;
@@ -254,10 +254,10 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_open(myhtml_tree_t* tr
 {
     if(myhtml_ascii_char_cmp(html[html_offset])) {
         qnode->token->begin = (html_offset + tree->global_offset);
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_END_TAG_NAME;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_END_TAG_NAME;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
     }
     
     return html_offset;
@@ -270,7 +270,7 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
         if(myhtml_whithspace(html[html_offset], ==, ||))
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
                 html_offset++;
                 break;
             }
@@ -291,10 +291,10 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
                 qnode->token->tag_ctx_idx = MyHTML_TAG_SCRIPT;
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE;
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             }
             
             html_offset++;
@@ -303,7 +303,7 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
         else if(html[html_offset] == '/')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
                 html_offset++;
                 break;
             }
@@ -324,10 +324,10 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
                 qnode->token->tag_ctx_idx = MyHTML_TAG_SCRIPT;
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE|MyHTML_TOKEN_TYPE_CLOSE_SELF;
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_BEFORE_ATTRIBUTE_NAME;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             }
             
             html_offset++;
@@ -336,7 +336,7 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
         else if(html[html_offset] == '>')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
                 html_offset++;
                 break;
             }
@@ -357,20 +357,20 @@ size_t myhtml_tokenizer_state_script_data_escaped_end_tag_name(myhtml_tree_t* tr
                 qnode->token->tag_ctx_idx = MyHTML_TAG_SCRIPT;
                 qnode->token->type = MyHTML_TOKEN_TYPE_CLOSE;
                 
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_DATA;
                 
                 html_offset++;
-                mh_queue_add(tree, html, html_offset, qnode);
+                myhtml_queue_add(tree, html, html_offset, qnode);
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
                 html_offset++;
             }
             break;
         }
         else if(myhtml_ascii_char_unless_cmp(html[html_offset]))
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             break;
         }
         
@@ -386,13 +386,13 @@ size_t myhtml_tokenizer_state_script_data_escaped(myhtml_tree_t* tree, mythread_
     {
         if(html[html_offset] == '-')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH;
             html_offset++;
             break;
         }
         else if(html[html_offset] == '<')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
             html_offset++;
             break;
         }
@@ -406,17 +406,17 @@ size_t myhtml_tokenizer_state_script_data_escaped(myhtml_tree_t* tree, mythread_
 size_t myhtml_tokenizer_state_script_data_escaped_dash(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     if(html[html_offset] == '-') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_DASH_DASH;
         html_offset++;
     }
     else if(html[html_offset] == '<') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN;
     }
     else if(html[html_offset] == '\0') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
         html_offset++;
     }
     
@@ -430,7 +430,7 @@ size_t myhtml_tokenizer_state_script_data_double_escape_start(myhtml_tree_t* tre
         if(myhtml_whithspace(html[html_offset], ==, ||) || html[html_offset] == '/' || html[html_offset] == '>')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
                 html_offset++;
                 break;
             }
@@ -443,10 +443,10 @@ size_t myhtml_tokenizer_state_script_data_double_escape_start(myhtml_tree_t* tre
             qnode->begin = tmp_size;
             
             if(myhtml_strncasecmp(tem_name, "script", 6) == 0) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             }
             
             html_offset++;
@@ -454,7 +454,7 @@ size_t myhtml_tokenizer_state_script_data_double_escape_start(myhtml_tree_t* tre
         }
         else if(myhtml_ascii_char_unless_cmp(html[html_offset]))
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             break;
         }
         
@@ -470,13 +470,13 @@ size_t myhtml_tokenizer_state_script_data_double_escaped(myhtml_tree_t* tree, my
     {
         if(html[html_offset] == '-')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_DASH;
             html_offset++;
             break;
         }
         else if(html[html_offset] == '<')
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
             html_offset++;
             break;
         }
@@ -491,14 +491,14 @@ size_t myhtml_tokenizer_state_script_data_double_escaped_dash(myhtml_tree_t* tre
 {
     if(html[html_offset] == '-')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH;
     }
     else if(html[html_offset] == '<')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
     }
     
     html_offset++;
@@ -515,14 +515,14 @@ size_t myhtml_tokenizer_state_script_data_double_escaped_dash_dash(myhtml_tree_t
     
     if(html[html_offset] == '<')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN;
     }
     else if(html[html_offset] == '>')
     {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA;
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
     }
     
     html_offset++;
@@ -533,13 +533,13 @@ size_t myhtml_tokenizer_state_script_data_double_escaped_dash_dash(myhtml_tree_t
 size_t myhtml_tokenizer_state_script_data_double_escaped_less_than_sign(myhtml_tree_t* tree, mythread_queue_node_t* qnode, const char* html, size_t html_offset, size_t html_size)
 {
     if(html[html_offset] == '/') {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPE_END;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPE_END;
         html_offset++;
         
         qnode->token->begin = (html_offset + tree->global_offset);
     }
     else {
-        mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+        myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
     }
     
     return html_offset;
@@ -552,7 +552,7 @@ size_t myhtml_tokenizer_state_script_data_double_escape_end(myhtml_tree_t* tree,
         if(myhtml_whithspace(html[html_offset], ==, ||) || html[html_offset] == '/' || html[html_offset] == '>')
         {
             if((html_offset - qnode->token->begin) != 6) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
                 html_offset++;
                 break;
             }
@@ -565,10 +565,10 @@ size_t myhtml_tokenizer_state_script_data_double_escape_end(myhtml_tree_t* tree,
             qnode->begin = tmp_size;
             
             if(myhtml_strncasecmp(tem_name, "script", 6) == 0) {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_ESCAPED;
             }
             else {
-                mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+                myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
             }
             
             html_offset++;
@@ -576,7 +576,7 @@ size_t myhtml_tokenizer_state_script_data_double_escape_end(myhtml_tree_t* tree,
         }
         else if(myhtml_ascii_char_unless_cmp(html[html_offset]))
         {
-            mh_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
+            myhtml_tokenizer_state_set(tree) = MyHTML_TOKENIZER_STATE_SCRIPT_DATA_DOUBLE_ESCAPED;
             break;
         }
         
diff --git a/source/myhtml/tree.c b/source/myhtml/tree.c
index 9cb8839..50fa418 100644
--- a/source/myhtml/tree.c
+++ b/source/myhtml/tree.c
@@ -30,9 +30,11 @@ myhtml_status_t myhtml_tree_init(myhtml_tree_t* tree, myhtml_t* myhtml)
     tree->myhtml             = myhtml;
     tree->token              = myhtml_token_create(tree, 4096);
     tree->temp_tag_name.data = NULL;
-    tree->queue              = myhtml->thread->queue;
-    tree->single_queue       = NULL;
     tree->temp_stream        = NULL;
+    tree->queue              = mythread_queue_create(9182, &status);
+    
+    if(status)
+        return status;
     
     tree->tree_obj = mcobject_async_create();
     if(tree->tree_obj == NULL)
@@ -130,6 +132,10 @@ void myhtml_tree_clean(myhtml_tree_t* tree)
     mcobject_async_node_clean(tree->token->attr_obj, tree->mcasync_attr_id);
     mchar_async_node_clean(tree->mchar, tree->mchar_node_id);
     
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+    mythread_queue_list_entry_clean(tree->myhtml->thread, tree->queue_entry);
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
+    
     myhtml_token_clean(tree->token);
     
     // null root
@@ -166,9 +172,6 @@ void myhtml_tree_clean(myhtml_tree_t* tree)
     tree->encoding            = MyHTML_ENCODING_UTF_8;
     tree->encoding_usereq     = MyHTML_ENCODING_DEFAULT;
     
-    if(tree->single_queue)
-        mythread_queue_clean(tree->single_queue);
-    
     myhtml_tree_temp_stream_clean(tree);
     
     myhtml_tree_active_formatting_clean(tree);
@@ -179,6 +182,7 @@ void myhtml_tree_clean(myhtml_tree_t* tree)
     myhtml_tree_index_clean(tree, tree->tags);
     mcobject_async_node_clean(myhtml->async_incoming_buf, tree->mcasync_incoming_buf_id);
     myhtml_tag_clean(tree->tags);
+    mythread_queue_clean(tree->queue);
     
     myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->mcasync_attr_id);
 }
@@ -223,9 +227,6 @@ void myhtml_tree_clean_all(myhtml_tree_t* tree)
     tree->encoding            = MyHTML_ENCODING_UTF_8;
     tree->encoding_usereq     = MyHTML_ENCODING_DEFAULT;
     
-    if(tree->single_queue)
-        mythread_queue_clean(tree->single_queue);
-    
     myhtml_tree_temp_stream_clean(tree);
     
     myhtml_tree_active_formatting_clean(tree);
@@ -237,6 +238,10 @@ void myhtml_tree_clean_all(myhtml_tree_t* tree)
     mcobject_async_node_clean(tree->myhtml->async_incoming_buf, tree->mcasync_incoming_buf_id);
     myhtml_tag_clean(tree->tags);
     
+#ifndef MyHTML_BUILD_WITHOUT_THREADS
+    mythread_queue_list_entry_clean(tree->myhtml->thread, tree->queue_entry);
+#endif /* MyHTML_BUILD_WITHOUT_THREADS */
+    
     myhtml_token_attr_malloc(tree->token, tree->attr_current, tree->mcasync_attr_id);
 }
 
@@ -257,10 +262,7 @@ myhtml_tree_t * myhtml_tree_destroy(myhtml_tree_t* tree)
     tree->mchar              = mchar_async_destroy(tree->mchar, 1);
     tree->temp_stream        = myhtml_tree_temp_stream_free(tree);
     tree->tags               = myhtml_tag_destroy(tree->tags);
-    
-    if(tree->single_queue) {
-        tree->single_queue = mythread_queue_destroy(tree->single_queue);
-    }
+    tree->queue              = mythread_queue_destroy(tree->queue);
     
     mcobject_async_node_delete(tree->myhtml->async_incoming_buf, tree->mcasync_incoming_buf_id);
     myhtml_tree_temp_tag_name_destroy(&tree->temp_tag_name, false);
@@ -2256,9 +2258,6 @@ void myhtml_tree_print_node(myhtml_tree_t* tree, myhtml_tree_node_t* node, FILE*
     
     const myhtml_tag_context_t *ctx = myhtml_tag_get_by_id(tree->tags, node->tag_idx);
     
-//    size_t mctree_id = mh_tags_get(node->tag_idx, mctree_id);
-//    size_t tag_name_size = mctree_nodes[mctree_id].str_size;
-    
     if(node->tag_idx == MyHTML_TAG__TEXT ||
        node->tag_idx == MyHTML_TAG__COMMENT)
     {
@@ -2288,10 +2287,6 @@ void myhtml_tree_print_node(myhtml_tree_t* tree, myhtml_tree_node_t* node, FILE*
     }
     else
     {
-#ifdef DEBUG_MODE
-        fprintf(out, "<%.*s tagid=\"%zu\" mem=\"%zx\"", (int)tag_name_size, mctree_nodes[mctree_id].str,
-                mh_tags_get(node->tag_idx, id), (size_t)node);
-#else
         fprintf(out, "<%.*s", (int)ctx->name_length, ctx->name);
         
         if(node->my_namespace != MyHTML_NAMESPACE_HTML) {
@@ -2315,7 +2310,6 @@ void myhtml_tree_print_node(myhtml_tree_t* tree, myhtml_tree_node_t* node, FILE*
                     break;
             }
         }
-#endif
         
         if(node->token)
             myhtml_token_print_attr(tree, node->token, out);
diff --git a/source/myhtml/tree.h b/source/myhtml/tree.h
index a2fe001..a58f1ce 100644
--- a/source/myhtml/tree.h
+++ b/source/myhtml/tree.h
@@ -159,14 +159,14 @@ struct myhtml_tree_temp_stream {
 
 struct myhtml_tree {
     // ref
-    myhtml_t*             myhtml;
-    mchar_async_t*        mchar;
-    myhtml_token_t*       token;
-    mcobject_async_t*     tree_obj;
-    mcsync_t*             sync;
-    mythread_queue_t*     queue;
-    mythread_queue_t*     single_queue;
-    myhtml_tag_t*         tags;
+    myhtml_t*                    myhtml;
+    mchar_async_t*               mchar;
+    myhtml_token_t*              token;
+    mcobject_async_t*            tree_obj;
+    mcsync_t*                    sync;
+    mythread_queue_list_entry_t* queue_entry;
+    mythread_queue_t*            queue;
+    myhtml_tag_t*                tags;
     
     // init id's
     size_t                  mcasync_token_id;
diff --git a/source/myhtml/utils/mcobject_async.c b/source/myhtml/utils/mcobject_async.c
index b1ec4a9..3fd4daf 100644
--- a/source/myhtml/utils/mcobject_async.c
+++ b/source/myhtml/utils/mcobject_async.c
@@ -96,8 +96,9 @@ void mcobject_async_clean(mcobject_async_t *mcobj_async)
         mcobject_async_node_t *node = &mcobj_async->nodes[node_idx];
         node->cache_length = 0;
         
-        node->chunk = mcobject_async_chunk_malloc(mcobj_async, mcobj_async->origin_size, NULL);
-        node->chunk->prev = NULL;
+        if(node->chunk) {
+            node->chunk = mcobject_async_chunk_malloc(mcobj_async, mcobj_async->origin_size, NULL);
+        }
     }
 }
 
@@ -184,6 +185,20 @@ mcobject_async_status_t mcobject_async_mem_malloc(mcobject_async_t *mcobj_async,
 
 mcobject_async_chunk_t * mcobject_async_chunk_malloc_without_lock(mcobject_async_t *mcobj_async, size_t length, mcobject_async_status_t *status)
 {
+    if(status)
+        *status = MCOBJECT_ASYNC_STATUS_OK;
+    
+    if(mcobj_async->chunk_cache_length)
+    {
+        mcobj_async->chunk_cache_length--;
+        
+        mcobj_async->chunk_cache[ mcobj_async->chunk_cache_length ]->length = 0;
+        mcobj_async->chunk_cache[ mcobj_async->chunk_cache_length ]->next   = NULL;
+        mcobj_async->chunk_cache[ mcobj_async->chunk_cache_length ]->prev   = NULL;
+        
+        return mcobj_async->chunk_cache[ mcobj_async->chunk_cache_length ];
+    }
+    
     if(mcobj_async->chunks_length >= mcobj_async->chunks_size)
     {
         if(mcobj_async->chunks_pos_length >= mcobj_async->chunks_pos_size)
@@ -221,6 +236,9 @@ mcobject_async_chunk_t * mcobject_async_chunk_malloc_without_lock(mcobject_async
     mcobject_async_chunk_t* chunk = &mcobj_async->chunks[mcobj_async->chunks_pos_length - 1][mcobj_async->chunks_length];
     mcobj_async->chunks_length++;
     
+    chunk->next = NULL;
+    chunk->prev = NULL;
+    
     if(status)
         *status = mcobject_async_mem_malloc(mcobj_async, chunk, length);
     else
@@ -261,22 +279,11 @@ size_t mcobject_async_node_add(mcobject_async_t *mcobj_async, mcobject_async_sta
     
     mcobject_async_node_t *node = &mcobj_async->nodes[node_idx];
     
-    if(status) {
-        node->chunk = mcobject_async_chunk_malloc_without_lock(mcobj_async, mcobj_async->origin_size, status);
-        
-        if(*status) {
-            mcsync_unlock(mcobj_async->mcsync);
-            return 0;
-        }
-    }
-    else {
-        mcobject_async_status_t mystatus;
-        node->chunk = mcobject_async_chunk_malloc_without_lock(mcobj_async, mcobj_async->origin_size, &mystatus);
-        
-        if(mystatus) {
-            mcsync_unlock(mcobj_async->mcsync);
-            return 0;
-        }
+    node->chunk = mcobject_async_chunk_malloc_without_lock(mcobj_async, mcobj_async->origin_size, status);
+    
+    if(status && *status) {
+        mcsync_unlock(mcobj_async->mcsync);
+        return 0;
     }
     
     node->chunk->next = NULL;
diff --git a/source/myhtml/utils/mcsimple.c b/source/myhtml/utils/mcsimple.c
new file mode 100644
index 0000000..892c036
--- /dev/null
+++ b/source/myhtml/utils/mcsimple.c
@@ -0,0 +1,113 @@
+//
+//  mcsimple.c
+//  osx
+//
+//  Created by Alexander Borisov on 23.03.16.
+//  Copyright © 2016 Alexander Borisov. All rights reserved.
+//
+
+#include "mcsimple.h"
+
+mcsimple_t * mcsimple_create(void)
+{
+    return mycalloc(1, sizeof(mcsimple_t));
+}
+
+void mcsimple_init(mcsimple_t *mcsimple, size_t pos_size, size_t list_size, size_t struct_size)
+{
+    mcsimple->struct_size = struct_size;
+    
+    mcsimple->list_pos_length_used = 0;
+    mcsimple->list_pos_length = 0;
+    mcsimple->list_pos_size = pos_size;
+    mcsimple->list = (uint8_t**)mycalloc(pos_size, sizeof(uint8_t*));
+    
+    if(mcsimple->list == NULL) {
+        return;
+    }
+    
+    mcsimple->list_size = list_size * struct_size;
+    
+    if((mcsimple_init_list_entries(mcsimple, mcsimple->list_pos_length) == NULL)) {
+        return;
+    }
+}
+
+void mcsimple_clean(mcsimple_t *mcsimple)
+{
+    mcsimple->list_length = 0;
+    mcsimple->list_pos_length = 0;
+}
+
+mcsimple_t * mcsimple_destroy(mcsimple_t *mcsimple, bool destroy_self)
+{
+    if(mcsimple == NULL)
+        return NULL;
+    
+    if(mcsimple->list) {
+        for(size_t i = 0; i < mcsimple->list_pos_length_used; i++) {
+            if(mcsimple->list[i])
+                free(mcsimple->list[i]);
+        }
+        
+        free(mcsimple->list);
+    }
+    
+    if(destroy_self) {
+        free(mcsimple);
+        return NULL;
+    }
+    
+    return mcsimple;
+}
+
+uint8_t * mcsimple_init_list_entries(mcsimple_t *mcsimple, size_t pos)
+{
+    if(mcsimple->list_pos_length >= mcsimple->list_pos_size)
+    {
+        size_t new_size = mcsimple->list_pos_size + 128;
+        uint8_t **list = (uint8_t**)myrealloc(mcsimple->list, mcsimple->list_pos_size * sizeof(uint8_t*));
+        
+        if(list) {
+            mcsimple->list = list;
+            memset(&mcsimple->list[pos], 0, (new_size - mcsimple->list_pos_size) * sizeof(uint8_t*));
+            
+            mcsimple->list_pos_size = new_size;
+        }
+        else
+            return NULL;
+    }
+    
+    mcsimple->list_length = 0;
+    
+    if(mcsimple->list[pos] == NULL) {
+        mcsimple->list_pos_length_used++;
+        mcsimple->list[pos] = (uint8_t*)mymalloc(mcsimple->list_size * sizeof(uint8_t));
+    }
+    
+    return mcsimple->list[pos];
+}
+
+void * mcsimple_malloc(mcsimple_t *mcsimple)
+{
+    if(mcsimple->list_length >= mcsimple->list_size)
+    {
+        mcsimple->list_pos_length++;
+        if((mcsimple_init_list_entries(mcsimple, mcsimple->list_pos_length) == NULL)) {
+            return NULL;
+        }
+    }
+    
+    size_t current = mcsimple->list_length;
+    mcsimple->list_length += mcsimple->struct_size;
+    
+    return &mcsimple->list[mcsimple->list_pos_length][current];
+}
+
+void * mcsimple_get_by_absolute_position(mcsimple_t *mcsimple, size_t pos)
+{
+    pos *= mcsimple->struct_size;
+    return &mcsimple->list[ (pos / mcsimple->list_size) ][ (pos % mcsimple->list_size) ];
+}
+
+
diff --git a/source/myhtml/utils/mcsimple.h b/source/myhtml/utils/mcsimple.h
new file mode 100644
index 0000000..4e1aaab
--- /dev/null
+++ b/source/myhtml/utils/mcsimple.h
@@ -0,0 +1,49 @@
+/*
+ Copyright 2016 Alexander Borisov
+ 
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ 
+ http://www.apache.org/licenses/LICENSE-2.0
+ 
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ 
+ Author: lex.borisov@gmail.com (Alexander Borisov)
+*/
+
+#ifndef MyHTML_UTILS_MCSIMPLE_H
+#define MyHTML_UTILS_MCSIMPLE_H
+#pragma once
+
+#include "myhtml/myosi.h"
+
+struct mcsimple {
+    size_t  struct_size;
+    
+    uint8_t **list;
+    
+    size_t list_pos_size;
+    size_t list_pos_length;
+    size_t list_pos_length_used;
+    size_t list_size;
+    size_t list_length;
+}
+typedef mcsimple_t;
+
+
+mcsimple_t * mcsimple_create(void);
+void mcsimple_init(mcsimple_t *mcsimple, size_t pos_size, size_t list_size, size_t struct_size);
+void mcsimple_clean(mcsimple_t *mcsimple);
+mcsimple_t * mcsimple_destroy(mcsimple_t *mcsimple, bool destroy_self);
+
+uint8_t * mcsimple_init_list_entries(mcsimple_t *mcsimple, size_t pos);
+
+void * mcsimple_malloc(mcsimple_t *mcsimple);
+void * mcsimple_get_by_absolute_position(mcsimple_t *mcsimple, size_t pos);
+
+#endif /* MyHTML_UTILS_MCSIMPLE_H */
diff --git a/source/myhtml/utils/mctree.c b/source/myhtml/utils/mctree.c
index 0a40830..e8a8085 100644
--- a/source/myhtml/utils/mctree.c
+++ b/source/myhtml/utils/mctree.c
@@ -33,6 +33,12 @@ mctree_t * mctree_create(size_t start_size)
     return mctree;
 }
 
+void mctree_clean(mctree_t* mctree)
+{
+    mctree->nodes_length = mctree->start_size + 1;
+    memset(mctree->nodes, 0, sizeof(mctree_node_t) * mctree->nodes_size);
+}
+
 mctree_t * mctree_destroy(mctree_t* mctree)
 {
     if(mctree == NULL)
diff --git a/source/myhtml/utils/mctree.h b/source/myhtml/utils/mctree.h
index 635768f..cdcb1d4 100644
--- a/source/myhtml/utils/mctree.h
+++ b/source/myhtml/utils/mctree.h
@@ -81,6 +81,7 @@ typedef void (*mctree_before_insert_f)(const char* key, size_t key_size, void **
 
 
 mctree_t * mctree_create(size_t start_size);
+void mctree_clean(mctree_t* mctree);
 mctree_t * mctree_destroy(mctree_t* mctree);
 
 mctree_index_t mctree_insert(mctree_t* mctree, const char* key, size_t key_size, void* value, mctree_before_insert_f b_insert);