code: def fire_lasers(
          self,
          modules: Optional[List[str]] = None,
          verbose_report: bool = False,
          transaction_count: Optional[int] = None,
      ) -> Report:
          
          all_issues = []  # type: List[Issue]
          SolverStatistics().enabled = True
          exceptions = []
          for contract in self.contracts:
              StartTime()  # Reinitialize start time for new contracts
              try:
                  sym = SymExecWrapper(
                      contract,
                      self.address,
                      self.strategy,
                      dynloader=DynLoader(
                          self.eth,
                          storage_loading=self.onchain_storage_access,
                          contract_loading=self.dynld,
                      ),
                      max_depth=self.max_depth,
                      execution_timeout=self.execution_timeout,
                      create_timeout=self.create_timeout,
                      transaction_count=transaction_count,
                      modules=modules,
                      compulsory_statespace=False,
                      enable_iprof=self.enable_iprof,
                  )
                  issues = fire_lasers(sym, modules)
              except KeyboardInterrupt:
                  log.critical("Keyboard Interrupt")
                  issues = retrieve_callback_issues(modules)
              except Exception:
                  log.critical(
                      "Exception occurred, aborting analysis. Please report this issue to the Mythril GitHub page.\n"
                      + traceback.format_exc()
                  )
                  issues = retrieve_callback_issues(modules)
                  exceptions.append(traceback.format_exc())
              for issue in issues:
                  issue.add_code_info(contract)
  
              all_issues += issues
              log.info("Solver statistics: \n{}".format(str(SolverStatistics())))
  
          source_data = Source()
          source_data.get_source_from_contracts_list(self.contracts)
          # Finally, output the results
          report = Report(verbose_report, contracts=self.contracts, exceptions=exceptions)
          for issue in all_issues:
              report.append_issue(issue)
  
          return report
docs: :param modules: The analysis modules which should be executed
          :param verbose_report: Gives out the transaction sequence of the vulnerability
          :param transaction_count: The amount of transactions to be executed
          :return: The Report class which contains the all the issues/vulnerabilities