diff --git a/bin/irpf90 b/bin/irpf90
index 7112473..c135dec 100755
--- a/bin/irpf90
+++ b/bin/irpf90
@@ -1,4 +1,4 @@
-#!/usr/bin/python -u
+#!/usr/bin/python -O
 #   IRPF90 is a Fortran90 preprocessor written in Python for programming using
 #   the Implicit Reference to Parameters (IRP) method.
 #   Copyright (C) 2009 Anthony SCEMAMA 
diff --git a/src/create_man.py b/src/create_man.py
index d2505ee..d56d1bf 100644
--- a/src/create_man.py
+++ b/src/create_man.py
@@ -32,7 +32,7 @@ from util import *
 
 
 def do_print_short(file,var):
-  assert isinstance(var,Variable)
+  assert type(var) == Variable
   print >>file, "%s : %s :: %s %s"%( \
    var.line.filename[0].ljust(25),
    var.type.ljust(25),
@@ -41,7 +41,7 @@ def do_print_short(file,var):
 
 ######################################################################
 def process_doc(file,line):
-  assert isinstance(line,str)
+  assert type(line) == str
   line = line.strip()
   if line == "":
     line = ".br"
@@ -49,24 +49,24 @@ def process_doc(file,line):
 
 ######################################################################
 def process_deps(file,l):
-  assert isinstance(l,list)
+  assert type(l) == list
   for v in l:
     print >>file, "%s\n.br"%(v,)
 
 ######################################################################
 def process_types(file,var):
-  assert isinstance(var,Variable)
+  assert type(var) == Variable
   vars = [var.name] + var.others
   for var in vars:
     name = var
     var = variables[var]
-    type = var.type
+    Type = var.type
     dim = build_dim(var.dim)
-    print >>file, "%s\t:: %s\t%s"%(type,name,dim)
+    print >>file, "%s\t:: %s\t%s"%(Type,name,dim)
 
 ######################################################################
 def do_print(var):
-  assert isinstance(var,Variable)
+  assert type(var) == Variable
   filename = var.line.filename[0]
   name = var.name
   file = open("%s%s.l"%(mandir,var.name), "w")
diff --git a/src/module.py b/src/module.py
index 3b5024c..c17ca34 100644
--- a/src/module.py
+++ b/src/module.py
@@ -46,7 +46,7 @@ class Fmodule(object):
 
   def prog_name(self):
     if '_prog_name' not in self.__dict__:
-      buffer = filter(lambda x: isinstance(x[1],Program),self.text)
+      buffer = filter(lambda x: type(x[1]) == Program,self.text)
       if buffer == []:
         self._prog_name = None
       else:
@@ -111,11 +111,11 @@ class Fmodule(object):
         result = []
         inside = False
         for vars,line in text:
-          if isinstance(line,Begin_provider):
+          if type(line) == Begin_provider:
             inside = True
           if not inside:
             result.append( (vars,line) )
-          if isinstance(line,End_provider):
+          if type(line) == End_provider:
             inside = False
         return result
 
@@ -125,7 +125,7 @@ class Fmodule(object):
         for vars,line in text:
           if type(line) in [ Subroutine, Function ]:
             variable_list = list(vars)
-          elif isinstance(line,End):
+          elif type(line) == End:
             result += map(lambda x: ([],Use(line.i,x,line.filename)), build_use(variable_list))
           else:
             variable_list += vars
@@ -143,11 +143,11 @@ class Fmodule(object):
           if inside:
             result.append( (vars,line) )
           else:
-            if isinstance(line,Use):
+            if type(line) == Use:
               use.append( (vars,line) )
-            elif isinstance(line,Declaration):
+            elif type(line) == Declaration:
               dec.append( (vars,line) )
-          if isinstance(line,End):
+          if type(line) == End:
             inside = False
         return use, dec, result
 
diff --git a/src/parsed_text.py b/src/parsed_text.py
index 7a9f322..efe446a 100644
--- a/src/parsed_text.py
+++ b/src/parsed_text.py
@@ -68,7 +68,7 @@ def find_funcs_in_line(line):
 
 
 def find_subroutine_in_line(line):
-  assert isinstance(line,Call)
+  assert type(line) == Call
   buffer = line.text.split('(')[0]
   buffer = buffer.split()[1]
   return buffer
@@ -102,7 +102,7 @@ def update_variables():
             error.fail(line,"Variable %s unknown"%(v,))
           variables[v]._is_touched = True
 
-    for line in filter(lambda x: isinstance(x,Free),text):
+    for line in filter(lambda x: type(x) == Free,text):
         vars = line.text_lower.split()
         if len(vars) < 2:
           error.fail(line,"Syntax error")
@@ -111,10 +111,10 @@ def update_variables():
             error.fail(line,"Variable %s unknown"%(v,))
           variables[v].is_freed = True
 
-    for line in filter(lambda x: isinstance(x,Irp_read),text):
+    for line in filter(lambda x: type(x) == Irp_read,text):
         variables[line.filename]._is_read = True
 
-    for line in filter(lambda x: isinstance(x,Irp_write),text):
+    for line in filter(lambda x: type (x) == Irp_write,text):
         variables[line.filename]._is_written = True
 
 ################################################################################
@@ -124,9 +124,9 @@ def get_parsed_text():
     varlist = []
     result = []
     append = result.append
-    for line in filter(
-      lambda x: type(x) not in [ Doc, Begin_doc, End_doc ],
-      text):
+    for line in text: #filter(
+#     lambda x: type(x) not in [ Doc, Begin_doc, End_doc ],
+#     text):
       if type(line) in [ \
         Empty_line,
         Continue,
@@ -145,42 +145,31 @@ def get_parsed_text():
         End,
       ]: 
         append( ([],line) )
-      elif isinstance(line,End_provider):
+      elif type(line) in [ Begin_provider, Cont_provider ]:
+        if type(line) == Begin_provider:
+          varlist = []
+        buffer = map(strip,line.text_lower.replace(']','').split(','))
+        assert len(buffer) > 1
+        v = buffer[1]
+        varlist.append(v)
+        variable_list = find_variables_in_line(line)
+        try:
+          variable_list.remove(variables[v].same_as)
+        except ValueError:
+          print v, variables[v].same_as
+          raise
+        append( (variable_list,line) )
+      elif type(line) == End_provider:
         varlist = []
         append( ([],line) )
-      elif isinstance(line,Provide):
+      elif type(line) == Provide:
         l = line.text_lower.split()[1:]
         l = filter(lambda x: x not in varlist, l)
         for v in l:
           if v not in variables.keys():
             error.fail(line,"Variable %s is unknown"%(v))
         append( (l,Simple_line(line.i,"!%s"%(line.text),line.filename)) )
-      elif isinstance(line,Call):
-        l = find_variables_in_line(line)
-        l = filter(lambda x: x not in varlist, l)
-        sub = find_subroutine_in_line(line)
-        if sub not in subroutines:
-          t = Simple_line
-          append( (l,Simple_line(line.i,line.text,line.filename)) )
-        else:
-          append( (l,line) )
-          if subroutines[sub].touches != []:
-            append( ([],Provide_all(line.i,"",line.filename)) )
-      elif isinstance(line,Free):
-        vars = line.text_lower.split()
-        vars = vars[1:]
-        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
-        use = map(lambda x: "  use %s"%(variables[x].fmodule),vars)
-        for var in vars:
-          result += map(lambda x: ([],Use(line.i,x,line.filename)),
-            make_single(use))
-          result += map(lambda x: ([],Simple_line(line.i,x,line.filename)),
-            variables[var].free)
-      elif isinstance(line,Irp_read):
-        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
-      elif isinstance(line,Irp_write):
-        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
-      elif isinstance(line,Touch):
+      elif type(line) in [ Touch, SoftTouch ]:
         vars = line.text_lower.split()
         if len(vars) < 2:
           error.fail(line,"Syntax error")
@@ -204,24 +193,37 @@ def get_parsed_text():
             error.fail(line,"Variable %s unknown"%(x,))
           return ([],Simple_line(line.i," %s_is_built = .True."%(x,),line.filename))
         result += map( fun, main_vars[:-1] )
-        if isinstance(line,SoftTouch):
+        if type(line) == SoftTouch:
           append ( ([],Simple_line(line.i,"! <<< END TOUCH (Soft)",line.filename)) )
         else:
           append ( ([],Provide_all(line.i,"! <<< END TOUCH",line.filename)) )
-      elif type(line) in [ Begin_provider, Cont_provider ]:
-        if isinstance(line,Begin_provider):
-          varlist = []
-        buffer = map(strip,line.text_lower.replace(']','').split(','))
-        assert len(buffer) > 1
-        v = buffer[1]
-        varlist.append(v)
-        variable_list = find_variables_in_line(line)
-        try:
-          variable_list.remove(variables[v].same_as)
-        except ValueError:
-          print v, variables[v].same_as
-          raise
-        append( (variable_list,line) )
+      elif type(line) == Call:
+        l = find_variables_in_line(line)
+        l = filter(lambda x: x not in varlist, l)
+        sub = find_subroutine_in_line(line)
+        if sub not in subroutines:
+          t = Simple_line
+          append( (l,Simple_line(line.i,line.text,line.filename)) )
+        else:
+          append( (l,line) )
+          if subroutines[sub].touches != []:
+            append( ([],Provide_all(line.i,"",line.filename)) )
+      elif type(line) == Free:
+        vars = line.text_lower.split()
+        vars = vars[1:]
+        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
+        use = map(lambda x: "  use %s"%(variables[x].fmodule),vars)
+        for var in vars:
+          result += map(lambda x: ([],Use(line.i,x,line.filename)),
+            make_single(use))
+          result += map(lambda x: ([],Simple_line(line.i,x,line.filename)),
+            variables[var].free)
+      elif type(line) == Irp_read:
+        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
+      elif type(line) == Irp_write:
+        append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
+      elif type(line) in [ Begin_doc, End_doc, Doc ]:
+        pass
       else:
         l = find_variables_in_line(line)
         l = filter(lambda x: x not in varlist, l)
@@ -241,7 +243,7 @@ parsed_text = get_parsed_text()
 ######################################################################
 
 def move_to_top(text,t):
-  assert isinstance(text,list)
+  assert type(text) == list
   assert t in [ Declaration, Implicit, Use, Cont_provider ]
 
   inside = False
@@ -252,7 +254,7 @@ def move_to_top(text,t):
       inside = True
     elif type(line) in [ End_provider, End ]:
       inside = False
-    elif isinstance(line,t):
+    elif type(line) == t:
       if inside:
         text.pop(i)
         begin += 1
@@ -322,7 +324,7 @@ def move_variables():
          or old_elsevars != []:
           error.fail(line,"End if missing")
         varlist = []
-      elif isinstance(line,Provide_all):
+      elif type(line) == Provide_all:
         append( (vars,line) )
       else:
         varlist += vars
@@ -380,7 +382,7 @@ def build_sub_needs():
         sub = subroutines[subname]
         sub.needs = []
         sub.to_provide = vars
-      elif isinstance(line,End):
+      elif type(line) == End:
         sub.needs = make_single(sub.needs)
         sub = None
       if sub is not None:
@@ -395,7 +397,7 @@ def add_subroutine_needs():
     result = []
     append = result.append
     for vars,line in text:
-      if isinstance(line,Call):
+      if type(line) == Call:
         subname = find_subname(line)
         vars = subroutines[subname].to_provide
       append( (vars,line) )
@@ -411,18 +413,18 @@ def build_needs():
   for filename, text in parsed_text:
     var = None
     for vars,line in text:
-      if isinstance(line,Begin_provider):
+      if type(line) == Begin_provider:
         buffer = map(strip,line.text_lower.replace(']',',').split(','))
         var = variables[buffer[1]]
         var.needs = []
         var.to_provide = vars
-      elif isinstance(line,End_provider):
+      elif type(line) == End_provider:
         var.needs = make_single(var.needs)
         var.to_provide = make_single(var.to_provide)
         var = None
       if var is not None:
         var.needs += vars
-        if isinstance(line,Call):
+        if type(line) == Call:
           subname = find_subname(line)
           var.needs += subroutines[subname].needs
         elif type(line) in [ \
@@ -478,14 +480,14 @@ def check_opt():
   for filename, text in parsed_text:
     do_level = 0
     for vars,line in text:
-     if not isinstance(line,Provide_all):
+     if not type(line) == Provide_all:
       if do_level > 0 and vars != []:
         print "Optimization: %s line %d"%(line.filename,line.i)
         for v in vars:
           print "  PROVIDE ",v
-      if isinstance(line,Do):
+      if type(line) == Do:
         do_level += 1
-      elif isinstance(line,Enddo):
+      elif type(line) == Enddo:
         do_level -= 1
 check_opt()
 
diff --git a/src/preprocessed_text.py b/src/preprocessed_text.py
index 83557ae..59c0927 100644
--- a/src/preprocessed_text.py
+++ b/src/preprocessed_text.py
@@ -88,10 +88,10 @@ simple_dict_keys = simple_dict.keys()
 
 def get_type (i, filename, line, is_doc):
   '''Find the type of a text line'''
-  assert isinstance(i,int)
-  assert isinstance(filename,str)
-  assert isinstance(line,str)
-  assert isinstance(is_doc,bool)
+  assert type(i) == int
+  assert type(filename) == str
+  assert type(line) == str
+  assert type(is_doc) == bool
 
   line = line.rstrip()
   lower_line0 = line.lstrip().lower()
@@ -165,8 +165,8 @@ instead of
 ######################################################################
 def get_text(lines,filename):
   '''Read the input file and transform it to labeled lines'''
-  assert isinstance(filename,str)
-  assert isinstance(lines,list)
+  assert type(filename) == str
+  assert type(lines) == list
 
   result = []
   is_doc = False
@@ -183,9 +183,9 @@ def execute_shell(text):
   result = []
   for line in text:
     if inside:
-      if isinstance(line,Begin_shell):
+      if type(line) == Begin_shell:
         error.fail(line,"Nested Begin_shell")
-      elif isinstance(line,End_shell):
+      elif type(line) == End_shell:
         inside = False
         # Write script file
         scriptname = "%s%s_shell_%d"%(irpdir,line.filename,line.i)
@@ -206,7 +206,7 @@ def execute_shell(text):
       else:
         script.append(line.text+'\n')
     else:
-      if isinstance(line,Begin_shell):
+      if type(line) == Begin_shell:
         inside = True
         begin = line.i
         script = []
@@ -223,7 +223,7 @@ def execute_shell(text):
         elif len(buffer) < 2:
           fail(line,"Missing",']')
         shell = buffer[0].strip()
-      elif isinstance(line,End_shell):
+      elif type(line) == End_shell:
         error.fail(line,"Begin_shell missing")
       else:
         result.append(line)
@@ -248,18 +248,18 @@ def execute_templates(text):
   result = []
   for line in text:
     if inside == 0:
-      if isinstance(line,Begin_template):
+      if type(line) == Begin_template:
         script = []
         inside = TEMPLATE
         script = "template = \"\"\"\n"
       else:
         result.append(line)
     elif inside == TEMPLATE:
-      if isinstance(line,Begin_template):
+      if type(line) == Begin_template:
         fail(line,"template", "Nested Begin_Template")
-      elif isinstance(line,End_template):
+      elif type(line) == End_template:
         fail(line,"template","Missing Subst")
-      elif isinstance(line,Subst):
+      elif type(line) == Subst:
         inside = SUBST
         script += "\"\"\"\n"
         variables = get_variables(line)
@@ -268,11 +268,11 @@ def execute_templates(text):
       else:
         script += line.text+"\n"
     else: # inside == SUBST
-      if isinstance(line,Begin_template):
+      if type(line) == Begin_template:
         fail(line,"subst","Nested Begin_template")
-      elif isinstance(line,Subst):
+      elif type(line) == Subst:
         fail(line,"subst","Subst already defined")
-      elif isinstance(line,End_template):
+      elif type(line) == End_template:
         inside = 0
         subst = subst.rstrip()
         if subst[-2:] == ';;':
@@ -313,7 +313,7 @@ def execute_templates(text):
 ######################################################################
 def form(text):
   '''Find if the text is in fixed form or in free form'''
-  assert isinstance(text,list)
+  assert type(text) == list
   if len(text) == 0:
     return Free_form
   assert isinstance(text[0],Line)
@@ -370,7 +370,7 @@ def remove_comments(text,form):
     for line in text:
       if type(line) in [ Openmp, Doc] :
          result.append(line)
-      elif isinstance(line,Empty_line):
+      elif type(line) == Empty_line:
          pass
       else:
         newline = line.text.lstrip()
@@ -384,7 +384,7 @@ def remove_comments(text,form):
     for line in text:
       if type(line) in [ Openmp, Doc ]:
          result.append(line)
-      elif isinstance(line,Empty_line):
+      elif type(line) == Empty_line:
          pass
       else:
         newline = line.text.lstrip()
@@ -424,7 +424,7 @@ def remove_continuation(text,form):
     rev_text.reverse()
     for line in rev_text:
       is_continuation = False
-      if isinstance(line,Simple_line):
+      if type(line) == Simple_line:
         if len(line.text) >= 6:
           if line.text[5] != ' ':
             is_continuation = True
@@ -442,7 +442,7 @@ def irp_simple_statements(text):
   '''Processes simple statements'''
 
   def process_irp_rw(line,rw,t):
-    assert isinstance(line,t)
+    assert type(line) == t
     buffer = line.text.split()
     if len(buffer) == 2:
       dummy, variable = buffer
@@ -465,15 +465,15 @@ def irp_simple_statements(text):
     return result
     
   def process_irp_read (line):
-    assert isinstance(line,Irp_read)
+    assert type(line) == Irp_read
     return process_irp_rw(line,'read' ,Irp_read )
 
   def process_irp_write(line):
-    assert isinstance(line,Irp_write)
+    assert type(line) == Irp_write
     return process_irp_rw(line,'writ' ,Irp_write)
 
   def process_return(line):
-    assert isinstance(line,Return)
+    assert type(line) == Return
     if command_line.do_assert or command_line.do_debug:
       newline = Simple_line(line.i," call irp_leave(irp_here)",line.filename)
       result = [newline, line]
@@ -483,7 +483,7 @@ def irp_simple_statements(text):
 
   def debug_conditions(line):
     '''Find condition in assert statement for debug'''
-    assert isinstance(line,Assert)
+    assert type(line) == Assert
     match = re_test.search(line.text)
     result = []
     if match is not None:
@@ -495,7 +495,7 @@ def irp_simple_statements(text):
     return result
    
   def process_assert(line):
-    assert isinstance(line,Assert)
+    assert type(line) == Assert
     if command_line.do_assert:
       condition = "(%s"%(line.text.split('(',1)[1])
       if condition == "":
@@ -537,7 +537,7 @@ def irp_simple_statements(text):
     return result
 
   def process_begin_provider(line):
-    assert isinstance(line,Begin_provider)
+    assert type(line) == Begin_provider
     buffer = line.lower.replace('['," ")
     buffer = buffer.replace(']',"")
     buffer = buffer.split(',')
@@ -556,7 +556,7 @@ def irp_simple_statements(text):
     return result
 
   def process_cont_provider(line):
-    assert isinstance(line,Cont_provider)
+    assert type(line) == Cont_provider
     buffer = line.lower.replace('['," ")
     buffer = buffer.replace(']',"")
     buffer = buffer.split(',')
@@ -568,7 +568,7 @@ def irp_simple_statements(text):
     return [ Cont_provider(i,line.text,(f,varname)) ]
 
   def process_subroutine(line):
-    assert isinstance(line,Subroutine)
+    assert type(line) == Subroutine
     subname = find_subname(line)
     length = len(subname)
     i = line.i
@@ -582,7 +582,7 @@ def irp_simple_statements(text):
     return result
 
   def process_function(line):
-    assert isinstance(line,Function)
+    assert type(line) == Function
     buffer = line.text.split('(')
     subname = find_subname(line)
     length = len(subname)
@@ -598,7 +598,7 @@ def irp_simple_statements(text):
 
 
   def process_program(line):
-    assert isinstance(line,Program)
+    assert type(line) == Program
     program_name = line.lower.split()[1]
     result = [ Program(0,"",program_name) ] + \
        process_subroutine( Subroutine(line.i,"subroutine %s"%(program_name,),line.filename) )
@@ -621,7 +621,7 @@ def irp_simple_statements(text):
   for line in text:
     buffer = [ line ]
     for t in d.keys():
-      if isinstance(line,t):
+      if type(line) == t:
         buffer = d[t](line)
         break
     result += buffer
@@ -633,7 +633,7 @@ def change_includes(text):
   '''Deals with include files'''
   result = []
   for line in text:
-    if (isinstance(line,Include)):
+    if type(line) == Include:
      txt = line.text.replace('"',"'").split("'")
      if len(txt) != 3:
        print txt
@@ -652,7 +652,7 @@ def change_includes(text):
 ######################################################################
 def process_old_style_do(text):
   '''Changes old-style do loops to new style'''
-  assert isinstance(text,list)
+  assert type(text) == list
 
   def change_matching_enddo(begin,number):
     for i in range(begin+1,len(text)):
@@ -667,7 +667,7 @@ def process_old_style_do(text):
   result = []
   for i in range(len(text)):
     line = text[i]
-    if isinstance(line,Do):
+    if type(line) == Do:
       buffer = line.text.split()
       if buffer[1].isdigit():
         number = buffer.pop(1)
@@ -687,10 +687,10 @@ if (test) then
   result
 endif'''
 
-  assert isinstance(text,list)
+  assert type(text) == list
   result = []
   for line in text:
-    if isinstance(line,If):
+    if type(line) == If:
       if line.lower.endswith("then"):
         result.append(line)
       else:
@@ -737,15 +737,15 @@ def check_begin_end(text):
   d = { 'do' : Do,         'enddo': Enddo,
         'if' : If,         'endif': Endif,
         '_doc': Begin_doc, 'end_doc': End_doc}
-  assert isinstance(text,list)
+  assert type(text) == list
 
   def find_matching_end_ifdo(begin,x):
     level = 1
     for i in range(begin+1,len(text)):
       line = text[i]
-      if isinstance(line,d[x]):
+      if type(line) == d[x]:
         level += 1
-      elif isinstance(line,d["end%s"%(x,)]):
+      elif type(line) == d["end%s"%(x,)]:
         level -= 1
         if level == 0:
           return True
@@ -756,7 +756,7 @@ def check_begin_end(text):
   def find_matching_end_subfunpro(begin,x):
     for i in range(begin+1,len(text)):
       line = text[i]
-      if isinstance(line,x):
+      if type(line) == x:
         return
       if type(line) in [ Subroutine, Function, Begin_provider ]:
         error.fail(text[begin],"Subroutine/Function/Provider is not closed")
@@ -765,25 +765,25 @@ def check_begin_end(text):
   
   level = 0
   for i,line in enumerate(text):
-    if isinstance(line,Begin_doc):
+    if type(line) == Begin_doc:
       find_matching_end_ifdo(i,'_doc')
   for i,line in enumerate(text):
-    if isinstance(line,Do):
+    if type(line) == Do:
       find_matching_end_ifdo(i,'do')
-    elif isinstance(line,If):
+    elif type(line) == If:
       find_matching_end_ifdo(i,'if')
-    elif isinstance(line,Subroutine):
+    elif type(line) == Subroutine:
       level += 1
       find_matching_end_subfunpro(i,End)
-    elif isinstance(line,Function):
+    elif type(line) == Function:
       level += 1
       find_matching_end_subfunpro(i,End)
-    elif isinstance(line,Begin_provider):
+    elif type(line) == Begin_provider:
       level += 1
       find_matching_end_subfunpro(i,End_provider)
-    elif isinstance(line,End):
+    elif type(line) == End:
       level -= 1
-    elif isinstance(line,End_provider):
+    elif type(line) == End_provider:
       level -= 1
     if level < 0:
       error.fail(line,"Beginning of block not matched")
@@ -792,16 +792,16 @@ def check_begin_end(text):
 
 ######################################################################
 def remove_ifdefs(text):
-  assert isinstance(text,list)
+  assert type(text) == list
   result = []
   do_print = True
   for line in text:
-    if isinstance(line,Irp_If):
+    if type(line) == Irp_If:
       var = line.text.split()[1]
       do_print = var in command_line.defined
-    elif isinstance(line,Irp_Else):
+    elif type(line) == Irp_Else:
       do_print = not do_print
-    elif isinstance(line,Irp_Endif):
+    elif type(line) == Irp_Endif:
       do_print = True
     else:
       if do_print:
diff --git a/src/subroutine.py b/src/subroutine.py
index e555173..a9f85c7 100644
--- a/src/subroutine.py
+++ b/src/subroutine.py
@@ -33,7 +33,7 @@ class Sub(object):
 
   ############################################################
   def __init__(self,text):
-    assert isinstance(text,list)
+    assert type(text) == list
     assert len(text) > 0
     assert type(text[0]) in [Subroutine, Function]
     self.text = text
@@ -57,7 +57,7 @@ class Sub(object):
   def doc(self):
     if '_doc' not in self.__dict__:
       def f(l): return 
-      buffer = filter(lambda l:isinstance(l,Doc), self.text)
+      buffer = filter(lambda l:type(l) == Doc, self.text)
       self._doc = map(lambda l: l.text[1:], buffer)
       if buffer == []:
         error.warn(None,"Subroutine %s is not documented"%(self.name))
@@ -76,7 +76,7 @@ class Sub(object):
     if '_touches' not in self.__dict__:
       from subroutines import subroutines
       self._touches = []
-      for line in filter(lambda x: isinstance(x,Touch),self.text):
+      for line in filter(lambda x: type(x) in [Touch, SoftTouch],self.text):
         self._touches += line.text.split()[1:]
       for sub in self.calls:
         if sub in subroutines:
@@ -97,7 +97,7 @@ class Sub(object):
   ############################################################
   def calls(self):
     if '_calls' not in self.__dict__:
-      buffer = filter(lambda x: isinstance(x,Call),self.text)
+      buffer = filter(lambda x: type(x) == Call,self.text)
       self._calls = []
       for line in buffer:
         sub = line.text.split('(',1)[0].split()[1]
diff --git a/src/util.py b/src/util.py
index 1620a33..e81f25a 100644
--- a/src/util.py
+++ b/src/util.py
@@ -35,7 +35,7 @@ def lower(x):
 
 def same_file(filename,txt):
   assert isinstance(filename,str)
-  assert isinstance(txt,list)
+  assert type(txt) == list
 
   try:
     file = open(filename,"r")
@@ -85,7 +85,7 @@ def make_single(l):
   return d.keys()
 
 def flatten(l):
-  if isinstance(l,list):
+  if type(l) == list:
     result = []
     for i in range(len(l)):
       elem = l[i]
@@ -116,12 +116,12 @@ def dimsize(x):
     return size
 
 def put_info(text,filename):
-  assert isinstance(text,list)
+  assert type(text) == list
   if len(text) > 0:
-    assert isinstance(text[0],tuple)
+    assert type(text[0]) == tuple
     from irpf90_t import Line
-    assert isinstance(text[0][0],list)
-    assert isinstance(text[0][1],Line)
+    assert type(text[0][0]) == list
+    assert isinstance(text[0][1], Line)
     lenmax = 80 - len(filename)
     format = "%"+str(lenmax)+"s ! %s:%4s"
     for vars,line in text:
diff --git a/src/variable.py b/src/variable.py
index 4762ca1..6c92584 100644
--- a/src/variable.py
+++ b/src/variable.py
@@ -34,9 +34,9 @@ class Variable(object):
 
   ############################################################
   def __init__(self,text,name = None):
-    assert isinstance(text,list)
+    assert type(text) == list
     assert len(text) > 0
-    assert isinstance(text[0],Begin_provider)
+    assert type(text[0]) == Begin_provider
     self.text = text
     if name is not None:
       self._name = name
@@ -93,7 +93,7 @@ class Variable(object):
     if '_name' not in self.__dict__:
       buffer = None
       for line in self.text:
-        if isinstance(line,Begin_provider):
+        if type(line) == Begin_provider:
           self._name = line.filename[1]
           break
     return self._name
@@ -103,7 +103,7 @@ class Variable(object):
   def doc(self):
     if '_doc' not in self.__dict__:
       def f(l): return 
-      buffer = filter(lambda l:isinstance(l,Doc), self.text)
+      buffer = filter(lambda l:type(l) == Doc, self.text)
       self._doc = map(lambda l: l.text[1:], buffer)
       if buffer == []:
         error.warn(None,"Variable %s is not documented"%(self.name))
@@ -134,7 +134,7 @@ class Variable(object):
   ############################################################
   def same_as(self):
     if '_same_as' not in self.__dict__:
-      if isinstance(self.line,Begin_provider):
+      if type(self.line) == Begin_provider:
         result = self.name
       else:
         result = self.text[0].filename[1]
@@ -490,14 +490,14 @@ class Variable(object):
         same_as = self.same_as
         inside = False
         for vars,line in buffer:
-          if isinstance(line,Begin_provider):
+          if type(line) == Begin_provider:
             if line.filename[1] == same_as:
               inside = True
             vars = []
           if inside:
             text.append( (vars,line) )
             text += map( lambda x: ([],Simple_line(line.i,x,line.filename)), call_provides(vars) )
-          if isinstance(line,End_provider):
+          if type(line) == End_provider:
             if inside:
               break
         name = self.name
diff --git a/src/variables.py b/src/variables.py
index 0b10bed..7cfba32 100644
--- a/src/variables.py
+++ b/src/variables.py
@@ -38,11 +38,11 @@ def create_variables():
     buffer = []
     inside = False
     for line in text:
-      if isinstance(line,Begin_provider):
+      if type(line) == Begin_provider:
         inside = True
       if inside:
         buffer.append(line)
-      if isinstance(line,End_provider):
+      if type(line) == End_provider:
         inside = False
         v = Variable(buffer)
         result[v.name] = v
diff --git a/src/version.py b/src/version.py
index e2befe9..2cc23d7 100644
--- a/src/version.py
+++ b/src/version.py
@@ -1 +1 @@
-version = "1.1.55"
+version = "1.1.56"