code: def Clone(self, tools=[], toolpath=None, parse_flags = None, **kw):
          
  
          builders = self._dict.get('BUILDERS', {})
  
          clone = copy.copy(self)
          # BUILDERS is not safe to do a simple copy
          clone._dict = semi_deepcopy_dict(self._dict, ['BUILDERS'])
          clone._dict['BUILDERS'] = BuilderDict(builders, clone)
  
          # Check the methods added via AddMethod() and re-bind them to
          # the cloned environment.  Only do this if the attribute hasn't
          # been overwritten by the user explicitly and still points to
          # the added method.
          clone.added_methods = []
          for mw in self.added_methods:
              if mw == getattr(self, mw.name):
                  clone.added_methods.append(mw.clone(clone))
  
          clone._memo = {}
  
          # Apply passed-in variables before the tools
          # so the tools can use the new variables
          kw = copy_non_reserved_keywords(kw)
          new = {}
          for key, value in kw.items():
              new[key] = SCons.Subst.scons_subst_once(value, self, key)
          clone.Replace(**new)
  
          apply_tools(clone, tools, toolpath)
  
          # apply them again in case the tools overwrote them
          clone.Replace(**new)
  
          # Finally, apply any flags to be merged in
          if parse_flags: clone.MergeFlags(parse_flags)
  
          if SCons.Debug.track_instances: logInstanceCreation(self, 'Environment.EnvironmentClone')
          return clone
docs: Return a copy of a construction Environment.  The
          copy is like a Python "deep copy"--that is, independent
          copies are made recursively of each objects--except that
          a reference is copied when an object is not deep-copyable
          (like a function).  There are no references to any mutable
          objects in the original Environment.