code: def load_library(self, flags=None):
      # XXX review all usages of 'self' here!
      # import it as a new extension module
      imp.acquire_lock()
      try:
          if hasattr(sys, "getdlopenflags"):
              previous_flags = sys.getdlopenflags()
          try:
              if hasattr(sys, "setdlopenflags") and flags is not None:
                  sys.setdlopenflags(flags)
              module = imp.load_dynamic(
                  self.verifier.get_module_name(),
                  self.verifier.modulefilename,
              )
          except ImportError as e:
              error = "importing %r: %s" % (
                  self.verifier.modulefilename,
                  e,
              )
              raise VerificationError(error)
          finally:
              if hasattr(sys, "setdlopenflags"):
                  sys.setdlopenflags(previous_flags)
      finally:
          imp.release_lock()
      #
      # call loading_cpy_struct() to get the struct layout inferred by
      # the C compiler
      self._load(module, "loading")
      #
      # the C code will need the <ctype> objects.  Collect them in
      # order in a list.
      revmapping = dict(
          [(value, key) for (key, value) in self._typesdict.items()]
      )
      lst = [revmapping[i] for i in range(len(revmapping))]
      lst = list(map(self.ffi._get_cached_btype, lst))
  
      #
      # build the FFILibrary class and instance and call _cffi_setup().
      # this will set up some fields like '_cffi_types', and only then
      # it will invoke the chained list of functions that will really
      # build (notably) the constant objects, as <cdata> if they are
      # pointers, and store them as attributes on the 'library' object.
      class FFILibrary(object):
          _cffi_python_module = module
          _cffi_ffi = self.ffi
          _cffi_dir = []
  
          def __dir__(self):
              return FFILibrary._cffi_dir + list(self.__dict__)
  
      library = FFILibrary()
      if module._cffi_setup(lst, VerificationError, library):
          import warnings
  
          warnings.warn(
              "reimporting %r might overwrite older definitions"
              % (self.verifier.get_module_name())
          )
      #
      # finally, call the loaded_cpy_xxx() functions.  This will perform
      # the final adjustments, like copying the Python->C wrapper
      # functions from the module to the 'library' object, and setting
      # up the FFILibrary class with properties for the global C variables.
      self._load(module, "loaded", library=library)
      module._cffi_original_ffi = self.ffi
      module._cffi_types_of_builtin_funcs = (
          self._types_of_builtin_functions
      )
      return library
  
imports: import sys
  from .None import model
  from .error import VerificationError
  from .None import _imp_emulation
label_desc: Use image node_id 9 for calling the VCPythonEngine obj's underlying member method code with example usage: obj.load_library(flags) and returns: library, unknown