code: def get_modifications_indirect(self):
          mod_event_types = list(ont_to_mod_type.keys())
          mod_event_types += ['ONT::PTM']
          def get_increase_events(mod_event_types):
              mod_events = []
              events = self.tree.findall("EVENT/[type='ONT::INCREASE']")
              for event in events:
                  affected = event.find(".//*[@role=':AFFECTED']")
                  if affected is None:
                      continue
                  affected_id = affected.attrib.get('id')
                  if not affected_id:
                      continue
                  pattern = "EVENT/[@id='%s']" % affected_id
                  affected_event = self.tree.find(pattern)
                  if affected_event is not None:
                      affected_type = affected_event.find('type')
                      if affected_type is not None and \
                          affected_type.text in mod_event_types:
                          mod_events.append(event)
              return mod_events
          def get_cause_events(mod_event_types):
              mod_events = []
              ccs = self.tree.findall("CC/[type='ONT::CAUSE']")
              for cc in ccs:
                  outcome = cc.find(".//*[@role=':OUTCOME']")
                  if outcome is None:
                      continue
                  outcome_id = outcome.attrib.get('id')
                  if not outcome_id:
                      continue
                  pattern = "EVENT/[@id='%s']" % outcome_id
                  outcome_event = self.tree.find(pattern)
                  if outcome_event is not None:
                      outcome_type = outcome_event.find('type')
                      if outcome_type is not None and \
                          outcome_type.text in mod_event_types:
                          mod_events.append(cc)
              return mod_events
          mod_events = get_increase_events(mod_event_types)
          mod_events += get_cause_events(mod_event_types)
          for event in mod_events:
              event_id = event.attrib['id']
              if event_id in self._static_events:
                  continue
              event_type = _get_type(event)
              enzyme = event.find(".//*[@role=':AGENT']")
              if enzyme is None:
                  enzyme = event.find(".//*[@role=':FACTOR']")
                  if enzyme is None:
                      return
              enzyme_id = enzyme.attrib.get('id')
              if enzyme_id is None:
                  continue
              enzyme_agent = self._get_agent_by_id(enzyme_id, event_id)
              affected_event_tag = event.find(".//*[@role=':AFFECTED']")
              if affected_event_tag is None:
                  affected_event_tag = event.find(".//*[@role=':OUTCOME']")
                  if affected_event_tag is None:
                      return
              affected_id = affected_event_tag.attrib.get('id')
              if not affected_id:
                  return
              affected_event = self.tree.find("EVENT/[@id='%s']" % affected_id)
              if affected_event is None:
                  return
              for enz_t in _agent_list_product((enzyme_agent, )):
                  enz = enz_t[0]
                  stmts = self._get_modification_event(affected_event)
                  stmts_to_make = []
                  if stmts:
                      for stmt in stmts:
                          if stmt.enz is None and stmt.sub is not None:
                              stmts_to_make.append(stmt)
                  for stmt in stmts_to_make:
                      stmt.enz = enz
                      for ev in stmt.evidence:
                          ev.epistemics['direct'] = False
                      self.statements.append(stmt)
              self._add_extracted(event_type, event.attrib['id'])
              self._add_extracted(affected_event.find('type').text, affected_id)