code: def _get_generic_modification(self, mod_class):
          mod_type = modclass_to_modtype[mod_class]
          if issubclass(mod_class, RemoveModification):
              mod_gain_const = mcct.LOSS
              mod_type = modtype_to_inverse[mod_type]
          else:
              mod_gain_const = mcct.GAIN
          mod_filter = mod_type[:5]
          p = BiopaxProcessor._construct_modification_pattern()
          p.add(mcc(mod_gain_const, mod_filter),
                    "input simple PE", "output simple PE")
          s = _bpp('Searcher')
          res = s.searchPlain(self.model, p)
          res_array = [_match_to_array(m) for m in res.toArray()]
          stmts = []
          for r in res_array:
              controller_pe = r[p.indexOf('controller PE')]
              input_pe = r[p.indexOf('input PE')]
              input_spe = r[p.indexOf('input simple PE')]
              output_spe = r[p.indexOf('output simple PE')]
              reaction = r[p.indexOf('Conversion')]
              control = r[p.indexOf('Control')]
              if not _is_catalysis(control):
                  continue
              cat_dir = control.getCatalysisDirection()
              if cat_dir is not None and cat_dir.name() != 'LEFT_TO_RIGHT':
                  logger.debug('Unexpected catalysis direction: %s.' % \
                      control.getCatalysisDirection())
                  continue
              enzs = BiopaxProcessor._get_primary_controller(controller_pe)
              if not enzs:
                  continue
              '''
              if _is_complex(input_pe):
                  sub_members_in = self._get_complex_members(input_pe)
                  sub_members_out = self._get_complex_members(output_pe)
                  logger.info('Cannot handle complex substrates.')
                  continue
              '''
              subs = BiopaxProcessor._get_agents_from_entity(input_spe,
                                                             expand_pe=False)
              ev = self._get_evidence(control)
              for enz, sub in itertools.product(_listify(enzs), _listify(subs)):
                  mod_in = \
                      BiopaxProcessor._get_entity_mods(input_spe)
                  mod_out = \
                      BiopaxProcessor._get_entity_mods(output_spe)
                  sub.mods = _get_mod_intersection(mod_in, mod_out)
                  if issubclass(mod_class, AddModification):
                      gained_mods = _get_mod_difference(mod_out, mod_in)
                  else:
                      gained_mods = _get_mod_difference(mod_in, mod_out)
                  for mod in gained_mods:
                      if mod.mod_type not in (mod_type,
                                              modtype_to_inverse[mod_type]):
                          continue
                      stmt = mod_class(enz, sub, mod.residue, mod.position,
                                       evidence=ev)
                      stmts.append(decode_obj(stmt, encoding='utf-8'))
          return stmts