diff --git a/texla.py b/texla.py
index dd69bb6..18f75e5 100644
--- a/texla.py
+++ b/texla.py
@@ -1,67 +1,67 @@
 from log import *
 import json
 import yaml
 from texla.Parser import Parser
 from texla.Renderers.MediaWikiRenderer import MediaWikiRenderer
 import texla.PageTree.Exporter as exporter
 from texla.Exceptions.TexlaExceptions import *
 from texla.Reporter import Reporter
 
 
 def execute_texla_mediawiki(config):
     p = Parser(config)
     a = open(config['input_path'], 'r').read()
     try:
         tree = p.parse(a)
     except (PreparserError, ParserError) as err:
         err.print_error()
         err.print_complete_tree('debug/crash_tree')
         exit()
     f = open(config['output_path'] + '.tree', 'w')
-    json_tree = tree.root_block.to_json(0)
-    n_blocks = tree.root_block.n_children_blocks_total()
+    json_tree = tree.print_raw_tree()
+    n_blocks = tree.get_number_blocks()
     logging.info('PARSED %i Blocks', n_blocks)
     f.write(json_tree)
     logging.info('\033[0;34m############### STARTING RENDERING ###############\033[0m')
     #creating Reporter
     reporter = Reporter(tree)
     #rendering
     rend = MediaWikiRenderer(config, reporter)
     rend.start_rendering(tree)
     o = open(config['output_path'] + '.json', 'w')
     o.write(json.dumps(rend.tree.get_tree_json(), indent=3))
     #print page tree before POST-PROCESSING
     logging.info('PageTree:\n'+rend.tree.get_tree_debug())
     #collpasing
     logging.info('\033[0;34m############### STARTING POST-PROCESSING ###############\033[0m')
     tree = rend.tree
     tree.collapse_tree(config['collapse_content_level'],
                        config['collapse_pages_level'])
     #printing tree after POST-PROCESSING
     logging.info('PageTree:\n'+rend.tree.get_tree_debug())
     oc = open(config['output_path'] + '-coll.json', 'w')
     oc.write(json.dumps(rend.tree.get_tree_json(), indent=3))
     logging.info('\033[0;34m############### EXPORTING ###############\033[0m')
     if config['create_index']:
         tree.create_indexes(config["export_book_page"])
     exporter.exportPages(tree.pages, config['output_path'] + '.mw',
                          config['export_format'])
     if config['export_single_pages']:
         exporter.export_singlePages(tree.pages,
                                     config['output_path'] + '_pages',
                                     config['export_format'])
     if config['export_pages_tree']:
         exporter.export_pages_tree(tree.pages.values(),
                                    config['output_path'] + "_pages")
     reporter.print_report(console=True)
     logging.info('Finished')
 
 
 if __name__ == '__main__':
     #reading JSON configs
     config = yaml.load(open('configs.yaml','r'))
     #loading localized keywords
     config['keywords'] = yaml.load(open('i18n.yaml','r'))[config['lang']]
     #executing process for alla renderers
     if config['renderer'] == 'mediawiki':
         execute_texla_mediawiki(config)
diff --git a/texla/Parser/TreeExplorer.py b/texla/Parser/TreeExplorer.py
index 092b3cc..bac8598 100644
--- a/texla/Parser/TreeExplorer.py
+++ b/texla/Parser/TreeExplorer.py
@@ -1,150 +1,159 @@
 import logging
 
 class TreeExplorer:
     """
     The TreeExplorer class is an utility to navigate
     and extract information from the tree of parsed blocks.
     For example it is useful to extract the tree of the
     parents of a block for debugging reasons. It is useful
     also in rendering to localize blocks inside the document.
     It is the default container of the result of the parsing process
     because it handles the chain of block with several utilities for
     quering.
     """
 
     def __init__(self, root_block):
         """ The constructor needs a root_block to
         begin the tree"""
         self.root_block = root_block
         self.blocks = {'@': root_block}
         self.block_names = {"default":[]}
         #registering blocks by id
         self.register_blocks(root_block.ch_blocks)
         self.register_block_names()
 
     @staticmethod
     def create_tree_from_children(block):
         #first of all we need the root_block
         current = block
         while True:
             if current.parent_block is None:
                 root_block = current
                 break
             #populating ch_blocks of parent block if not present
             #in order to have a fully functional TreeExplorer.
             #This is necessary if the TreeExplorer is used before
-            #the end of Parsing process. 
+            #the end of Parsing process.
             if current not in current.parent_block.ch_blocks:
                 current.parent_block.ch_blocks.append(current)
             current = current.parent_block
 
         #now we can return a new TreeExplorer
         #constructed from the found root.
         return TreeExplorer(root_block)
 
     def register_blocks(self, blocks):
         """This methods reads all the blocks tree
         from the root_block and created a dictionary
         with id:block"""
         for block in blocks:
             if not block.id in self.blocks:
                 self.blocks[block.id] = block
             if block.N_chblocks > 0:
                 self.register_blocks(block.ch_blocks)
 
     def register_block_names(self):
         """This function registers the block_names, creating
          a dictionary with blocks groups by type"""
         for bl in self.blocks.values():
             if not bl in self.block_names:
                 self.block_names[bl.block_name] = []
             if not bl in self.block_names[bl.block_name]:
                 self.block_names[bl.block_name].append(bl)
 
     def update_blocks_register(self):
         """This methods update the blocks' ids register
         recalling register_blocks with the root_block"""
         self.register_blocks(self.root_block.ch_blocks)
         self.register_block_names()
 
     def get_parents_list(self, block):
         """This method returns the list of the parent
         blocks of the requested block """
         if isinstance(block, str):
             block = self.blocks[block]
         parents = []
         current = block
         while True:
             if current == self.root_block:
                 break
             parents.append(current.parent_block)
             current = current.parent_block
         parents.reverse()
         return parents
 
     def get_parents_list_ids(self, block):
         parents = self.get_parents_list(block)
         return [x.id for x in parents]
 
     def get_block(self, blockid):
         return self.blocks.get(blockid)
 
+    def get_number_blocks(self):
+        return self.root_block.n_children_blocks_total()
+
     #############################################################
     # Quering functions
-    
+
     def query_block_by_name(self, block_name, depth_first=False):
         """
         This methods queries recursively the tree of blocks
         and returns a list of blocks with the requested block_name.
         depth_first controls the type of query.
         """
         return self.root_block.query_children_blocks(block_name, depth_first)
 
-    
+
     #############################################################
-    #  Printing functions   
-    
+    #  Printing functions
+
     def print_tree(self, block, filter_list=None):
         """This methods prints a beautified tree starting
         from block parameter and his children. If filter_list
         is present only the block with the id in the list
         are printed. It returns a single string. """
         output = []
         if filter_list is None or block.id in filter_list:
             lstr = ".    "* (block.tree_depth+1)
             output.append(lstr+ ".   "+ "  "+"_"*40 )
             output.append(lstr+ "#"+"---"+ ">|ID : {}".format(block.id))
             output.append(lstr+ ".   "+ " |block_name : {}".
                           format(block.block_name))
             output.append(lstr+ ".   "+ " |attributes: ")
             for at,attr in block.attributes.items():
                 output.append(lstr+ ".   " + " |   - "+ "{} : {}".
                               format(at, attr))
             output.append(lstr+ ".   "+ " |content : {}".
                         format(block.get_content()))
             output.append(lstr+ ".    ."+"\u203E"*40+"\n")
         output = "\n".join(output)
         #iterating on the block children
         for bl in block.ch_blocks:
             output += self.print_tree(bl, filter_list)
         return output
 
     def print_tree_to_blocks(self, blocks):
         """This methods print the tree of parents
         of the list of blocks passed as parameter.
         First of all it gets all the parents ids and
         then prints the tree using the list as filter."""
         fl = []
         for bl in blocks:
             fl+= self.get_parents_list_ids(bl)
             if isinstance(bl, str):
                 fl.append(bl)
             else:
                 fl.append(bl.id)
         return self.print_tree(self.root_block, filter_list=fl)
 
     def print_tree_to_block(self, block):
         return self.print_tree_to_blocks([block])
 
     def print_all_tree(self):
         return self.print_tree(self.root_block)
+
+    def print_raw_tree(self):
+        """
+        This function returns the tree of blocks in the raw format (json). 
+        """
+        return self.root_block.to_json()
diff --git a/texla/Renderers/MediaWikiRenderer.py b/texla/Renderers/MediaWikiRenderer.py
index 8272efa..b77947b 100644
--- a/texla/Renderers/MediaWikiRenderer.py
+++ b/texla/Renderers/MediaWikiRenderer.py
@@ -1,599 +1,605 @@
 import logging
 from .Renderer import Renderer
 from ..PageTree.PageTree import *
 
 class MediaWikiRenderer(Renderer):
 
     def __init__(self, configs, reporter):
         super().__init__(configs, reporter)
         self.configs = configs
         self.doc_title = configs['doc_title']
         #saving the hooks
         self.render_hooks = {
             #root
             'root-block': self.r_document,
             'default': self.default,
             #text
             'par': self.r_par,
             'newpage': self.r_newpage,
             'newline': self.r_newline,
             '\\': self.r_newline,
             'text': self.r_text,
             'clearpage': self.r_newpage,
             'cleardoublepage': self.r_newpage,
             #formatting
             'emph': self.r_textit,
             'textbf': self.r_textbf,
             'textit': self.r_textit,
             'textsc': self.r_textsc,
             'textsuperscript': self.r_superscript,
             'textsubscript': self.r_subscript,
             'underline': self.r_underline,
             'uline': self.r_underline,
             '%': self.r_special_character,
             '&': self.r_special_character,
             '$': self.r_special_character,
             '{': self.r_special_character,
             '}': self.r_special_character,
             '#': self.r_special_character,
             '_': self.r_special_character,
             'dots': self.r_dots,
             'ldots': self.r_dots,
             'flushright': self.r_flushright,
             'flushleft': self.r_flushleft,
             'center': self.r_center,
             'centerline': self.r_center,
             'abstract': self.r_abstract,
             'linebreak': self.r_break,
             'pagebreak': self.r_break,
             'nolinebreak': self.r_break,
             'nopagebreak': self.r_break,
             'verbatim': self.r_verbatim,
             'verb': self.r_verb,
             #spaces
             'vspace': self.r_vspace,
             'mandatory_space': self.r_mandatory_space,
             #theorems
             'theorem' : self.r_theorem,
             'proof' : self.r_proof,
             #sectioning
             'part': self.sectioning,
             'chapter': self.sectioning,
             'section': self.sectioning,
             'subsection': self.sectioning,
             'subsubsection': self.sectioning,
             'paragraph': self.sectioning,
             'subparagraph': self.sectioning,
             #math
             'displaymath': self.r_display_math,
             'inlinemath': self.r_inline_math,
             'ensuremath': self.r_inline_math,
             'equation': self.r_display_math,
             'eqnarray': self.r_align,
             'multline': self.r_align,
             'align': self.r_align,
             'alignat': self.r_align,
             'gather': self.r_gather,
             #lists
             'itemize': self.r_itemize,
             'enumerate': self.r_enumerate,
             'description': self.r_description,
             #quotes
             'quotation': self.r_quotes,
             'quote': self.r_quotes,
             'verse': self.r_verse,
             'footnote': self.r_footnote,
             #labels
             'label': self.r_label,
             'ref': self.r_ref,
             'vref': self.r_ref,
             'pageref': self.r_ref,
             'eqref': self.r_ref,
             #accents
             "accented_letter": self.r_accented_letter,
             #figures
             "figure": self.r_figure,
             #code
             "lstlisting": self.r_lstlisting
             }
         #PageTree object
         self.tree = PageTree(configs, reporter)
         #parameter for list formatting
         self.list_level = ''
         #parameters for theorem handling
         self.in_theorem = False
         self.theorem_number = 0
         self.th_numbering = {}
 
     ########################################
     #STARTING POINT
 
     def start_rendering(self, parser_tree_explorer):
-        #start rendering of base class
+        """
+        Entrypoint for rendering. It requires the
+        tree of parsed blocks as parameter
+        """
+        #start rendering of Rendering base class to activate plugins...
         super(MediaWikiRenderer, self).start_rendering(parser_tree_explorer)
-        """starting rendering from root-block"""
         root_block =  self.parser_tree_explorer.root_block
+        #start the rendering from root_block
         self.render_block(root_block)
-        #after rendering
+        #after rendering for PageTree structure
         self.tree.after_render()
-        #end rendering of base class
+        #end rendering of base class to stop plugins
         super(MediaWikiRenderer, self).end_rendering()
+        #return the PageTree as a result
+        return self.tree
 
     ####### ROOT BLOCK
     def r_document(self, block):
         #we trigger the rendering of content
         text = self.render_children_blocks(block)
         #text is the tex outside sections
         self.tree.addText(text)
         #returning the text to respect the interface
         return text
 
     ########################################
     #DEFAULT
 
     def default(self, block):
         #we don't print anything
         return ''
 
     #########################################
     #TEXT
 
     def r_text(self, block):
         text = block.attributes['text']
 
         # The following replace happens as ~ is the latex symbol
         # for unbreakable space
         return text.replace("~", " ")
 
     def r_newline(self, block):
         return '\n'
 
     def r_newpage(self, block):
         return '\n\n'
 
     def r_par(self, block):
         return '\n\n'
 
     #########################################
     #SECTIONING
 
     def sectioning(self, block):
         title = block.attributes['title']
         section_name = block.attributes['section_name']
         #remove the \n insiede title
         title = re.sub('\\n*', '', title)
         #creation of the new page
         self.tree.createPage(title, section_name)
         #content processing
         text = self.render_children_blocks(block)
         #adding text to current page
         self.tree.addText(text)
         #exiting the section
         self.tree.exitPage()
         return ''
 
     #########################################
     #MATH
 
     def r_display_math(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math display="block">' + s + '</math>'
 
     def r_inline_math(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math>' + s + '</math>'
 
     def r_align(self, block):
         s = block.attributes['content']
         #rendering labels
         self.render_blocks(block.labels)
         return '<math display="block">\\begin{align}' +\
                     s + '\end{align}</math>'
 
     def r_gather(self, block):
         s = block.attributes['content']
         output = []
         for eq in s.split("\\\\"):
             eq = eq.replace("\n","").strip()
             output.append('<math display="block">' +\
                         eq + '</math>')
         #rendering labels
         self.render_blocks(block.labels)
         return '\n'.join(output)
 
 
     #########################################
     #LABELS and refs
 
     def r_label(self, block):
         label = block.attributes['label']
         self.tree.addLabel(label)
         return ''
 
     def r_ref(self, block):
         ref = block.attributes['ref']
         #saving ref in Babel of PageTree
         self.tree.addReference(ref)
         return "{{ref@"+ ref+ "}}"
 
     #########################################
     #FIGURE
 
     def r_figure(self, block):
         captions = block.get_children("caption")
         includegraphics = block.get_children("includegraphics")
         s = "[[File:"
         if len(includegraphics):
             inc = includegraphics[0]
             s += inc.attributes["img_name"]
         else:
             return ""
         if len(block.get_children("centering")):
                 s += "|" + self.configs["keywords"]["center"]
 
         if len(captions):
             cap = captions[0]
             s += "|" + cap.attributes["caption"]
         s += "]]"
         return s
 
 
 
     #########################################
     #FORMATTING
 
     def r_special_character(self, block):
         return block.attributes['character']
 
     def r_dots(self, block):
         return '...'
 
     def r_textbf(self, block):
         s = []
         s.append("\'\'\'")
         s.append(self.render_children_blocks(block))
         s.append("\'\'\'")
         return ''.join(s)
 
     def r_textit(self, block):
         s = []
         s.append("\'\'")
         s.append(self.render_children_blocks(block))
         s.append("\'\'")
         return ''.join(s)
 
     def r_textsc(self, block):
         return self.render_children_blocks(block).upper()
 
     def r_superscript(self, block):
         s = []
         s.append('<sup>')
         s.append(self.render_children_blocks(block))
         s.append('</sup>')
         return ''.join(s)
 
     def r_subscript(self, block):
         s = []
         s.append('<sub>')
         s.append(self.render_children_blocks(block))
         s.append('</sub>')
         return ''.join(s)
 
     def r_underline(self, block):
         s = []
         s.append('{{Sottolineato|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_abstract(self, block):
         s = []
         s.append('{{Abstract|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_break(self, block):
         return ''
 
     def r_vspace(self,block):
         return '\n\n'
 
     def r_mandatory_space(self,block):
         return ' '
 
     def r_verbatim(self, block):
         return '<pre>' + block.attributes['content'] +'</pre>'
 
     def r_verb(self, block):
         return '<tt>' + block.attributes['content'] +'</tt>'
 
     #########################################
     #ALIGNMENT
 
     def r_center(self, block):
         s = []
         s.append('{{Center|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_flushleft(self, block):
         s = []
         s.append('{{Flushleft|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     def r_flushright(self, block):
         s = []
         s.append('{{Flushright|')
         s.append(self.render_children_blocks(block))
         s.append('}}')
         return ''.join(s)
 
     #########################################
     #LISTS
 
     def r_itemize(self, block):
         self.list_level += '*'
         s = ['\n']
         for item in block.ch_blocks:
             s.append(self.list_level)
             s.append(self.render_children_blocks(item).strip())
             s.append("\n")
         self.list_level = self.list_level[:-1]
         return ''.join(s)
 
     def r_enumerate(self, block):
         self.list_level += '#'
         s = ['\n']
         for item in block.ch_blocks:
             s.append(self.list_level)
             s.append(self.render_children_blocks(item).replace('\n', ''))
             s.append("\n")
         self.list_level = self.list_level[:-1]
         return ''.join(s)
 
     def r_description(self, block):
         s = ['\n']
         for item in block.ch_blocks:
             s.append(';')
             s.append(item.attributes['word'])
             s.append(':')
             s.append(self.render_children_blocks(item))
             s.append("\n")
         return ''.join(s)
 
     #########################################
     #QUOTES
 
     def r_quotes(self, block):
         s = []
         s.append('<blockquote>')
         s.append(self.render_children_blocks(block))
         s.append('</blockquote>')
         return ''.join(s)
 
     def r_verse(self, block):
         s = []
         s.append('<blockquote>')
         s.append('\n'.join(self.render_children_blocks(block).split('//')))
         s.append('</blockquote>')
         return ''.join(s)
 
     def r_footnote(self, block):
         s = []
         s.append("<ref>")
         s.append(self.render_children_blocks(block))
         s.append("</ref>")
         return ''.join(s)
 
     ########################################
     #Code
 
     def r_lstlisting(self, block):
         s = []
         if "language" in block.options:
             s.append('<source lang="{}" line>'.format(block.options["language"]))
         else:
             #check if there are any lstset block
             query = self.parser_tree_explorer.query_block_by_name("lstset")
             if len(query) == 0:
                 s.append('<source line>')
             else:
                 s.append('<source lang="{}" line>'.format(query[0].options["language"]))
         s.append(block.content)
         s.append('</source>')
         return '\n'.join(s)
 
-    
+
     #########################################
     #Theorems
 
     def r_theorem(self, block):
         #the label in theorems is not working for now
         th_definition = block.attributes['definition']
         th_title = ''
         if block.attributes['title'] != None:
             th_title +=" "+ block.attributes['title']
         s = []
         #adding the theorem to the tree
         self.theorem_number += 1
         self.tree.addTheorem(str(self.theorem_number), th_definition)
         #checking if the Environment template is used
         environ = False
         if self.configs['lang'] =='it':
             if th_definition.lower() == 'teorema':
             #adding content to page through a template
                 s.append("\n{{InizioTeorema|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineTeorema}}\n")
             elif th_definition.lower() == 'definizione':
                 s.append("\n{{InizioDefinizione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDefinizione}}\n")
             elif th_definition.lower() == 'proposizione':
                 s.append("\n{{InizioProposizione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineProposizione}}\n")
             elif th_definition.lower() == 'lemma':
                 s.append("\n{{InizioLemma|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineLemma}}\n")
             elif th_definition.lower() == 'corollario':
                 s.append("\n{{InizioCorollario|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineCorollario}}\n")
             elif th_definition.lower()[:-2] == 'eserciz':
                 s.append("\n{{InizioEsercizio|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineEsercizio}}\n")
             elif th_definition.lower()[:-1] == 'osservazion':
                 s.append("\n{{InizioOsservazione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineOsservazione}}\n")
             elif th_definition.lower()[:-2] == 'esemp':
                 s.append("\n{{InizioEsempio|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineEsempio}}\n")
             elif th_definition.lower() == 'dimostrazione':
                 s.append("\n{{InizioDimostrazione|titolo=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
             else:
                 s.append("\n{{Environment|name="+ th_definition + \
                         "|title=" + th_title +\
                         "|content=")
                 s.append(self.render_children_blocks(block))
                 s.append("}}\n")
         elif self.configs['lang'] =='en':
             if th_definition.lower() == 'theorem':
             #adding content to page through a template
                 s.append("\n{{BeginTheorem|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndTheorem}}\n")
             elif th_definition.lower() == 'definition':
                 s.append("\n{{BeginDefinition|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndDefinition}}\n")
             elif th_definition.lower() == 'proposition':
                 s.append("\n{{BeginProposition|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProposition}}\n")
             elif th_definition.lower() == 'lemma':
                 s.append("\n{{BeginLemma|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndLemma}}\n")
             elif th_definition.lower() == 'corollary':
                 s.append("\n{{BeginCorollary|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndCorollary}}\n")
             elif th_definition.lower() == 'exercise':
                 s.append("\n{{BeginExercise|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndExercise}}\n")
             elif th_definition.lower() == 'observation':
                 s.append("\n{{BeginObservation|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndObservation}}\n")
             elif th_definition.lower() == 'remark':
                 s.append("\n{{BeginRemark|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndRemark}}\n")
             elif th_definition.lower() == 'example':
                 s.append("\n{{BeginExample|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndExample}}\n")
             elif th_definition.lower() == 'demonstration':
                 s.append("\n{{BeginDemonstration|title=" + \
                         th_title+"|number={{thnum@"+ str(self.theorem_number)+"}}"+\
                             "|anchor={{thanchor@"+ str(self.theorem_number) +"}}}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndDemonstration}}\n")
             else:
                 s.append("\n{{Environment|name="+ th_definition + \
                         "|title=" + th_title +\
                         "|content=")
                 s.append(self.render_children_blocks(block))
                 s.append("}}\n")
         #exit from theorem ambient
         self.tree.exitTheorem()
         return '\n'.join(s)
 
     def r_proof(self, block):
         s=[]
         if self.configs['lang'] == 'it':
             if block.title !=None:
                 s.append('\n{{InizioDimostrazione|titolo='+\
                         block.attributes['title']+ "}}")
 
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
             else:
                 s.append('\n{{InizioDimostrazione}}')
                 s.append(self.render_children_blocks(block))
                 s.append("{{FineDimostrazione}}\n")
         elif self.configs['lang'] == 'en':
             if block.title !=None:
                 s.append('\n{{BeginProof|title='+\
                         block.attributes['title']+"}}")
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProof}}\n")
             else:
                 s.append('\n{{BeginProof}}')
                 s.append(self.render_children_blocks(block))
                 s.append("{{EndProof}}\n")
         return '\n'.join(s)
 
     #########################################
     #ACCENTED letters
     def r_accented_letter(self, block):
         if block.attributes["accent_type"] == '"' \
                 and block.attributes["letter"] == "a":
             return "ä"
         if block.attributes["accent_type"] in ["'","`"]:
             return block.attributes["letter"]+\
                     block.attributes["accent_type"]
         else:
             return block.attributes["letter"]