prompt: We are currently solving the following issue within our repository. Here is the issue text:
  --- BEGIN ISSUE ---
  FileNotFoundError: [Errno 2] No such file or directory: 'solc'
  I launch  program like this:
  
      slither Contract.sol 
  
  and receive an error:
  "FileNotFoundError: [Errno 2] No such file or directory: 'solc'"
  
  I have solc installed.
  
      $ solcjs --version
      0.4.25+commit.59dbf8f1.Emscripten.clang
  
  But executable is called **solcjs**, not **solc**. Or it is something different?
  
  Reasoning for "Trusted" versions of Solidity
  Re: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity
  
  I am wondering why `0.4.25 or 0.5.11` are chosen as trusted versions.
  
  Would 0.4.26 or 0.5.17 be acceptable? (current highest patches of those minor versions)
  
  Why are none of the 0.6.x versions included as a "trusted" version?
  
  What are the criteria for adding / bumping the version of "trusted"? Is it based on a simple metric like time since release? Or were those two specific versions manually audited by your team members?
  
  Sorry for all the questions. I have a project which is fairly portable between `>=0.5.0 <=0.7.0` and am wondering which version to target... I would like to use `immutable` from `>=0.6.5`, but not at the expense of some possible security issue. And after using this tool I wondered what the criteria was for "trusted versions" of the compiler.
  
  Thanks.
  
  --- END ISSUE ---
  
  Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
  --- BEGIN FILES ---
  Path: `slither/detectors/attributes/incorrect_solc.py`
  Content:
  ```
  1 """
  2     Check if an incorrect version of solc is used
  3 """
  4 
  5 import re
  6 from slither.detectors.abstract_detector import AbstractDetector, DetectorClassification
  7 from slither.formatters.attributes.incorrect_solc import format
  8 
  9 # group:
  10 # 0: ^ > >= < <= (optional)
  11 # 1: ' ' (optional)
  12 # 2: version number
  13 # 3: version number
  14 # 4: version number
  15 
  16 PATTERN = re.compile('(\^|>|>=|<|<=)?([ ]+)?(\d+)\.(\d+)\.(\d+)')
  17 
  18 
  19 class IncorrectSolc(AbstractDetector):
  20     """
  21     Check if an old version of solc is used
  22     """
  23 
  24     ARGUMENT = 'solc-version'
  25     HELP = 'Incorrect Solidity version'
  26     IMPACT = DetectorClassification.INFORMATIONAL
  27     CONFIDENCE = DetectorClassification.HIGH
  28 
  29     WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'
  30 
  31     WIKI_TITLE = 'Incorrect versions of Solidity'
  32     WIKI_DESCRIPTION = '''
  33 `solc` frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.
  34 We also recommend avoiding complex `pragma` statement.'''
  35     WIKI_RECOMMENDATION = '''
  36 Use Solidity 0.4.25 or 0.5.11. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''
  37 
  38     COMPLEX_PRAGMA_TXT = "is too complex"
  39     OLD_VERSION_TXT = "allows old versions"
  40     LESS_THAN_TXT = "uses lesser than"
  41 
  42     TOO_RECENT_VERSION_TXT = "necessitates versions too recent to be trusted. Consider deploying with 0.5.11"
  43     BUGGY_VERSION_TXT = "is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)"
  44 
  45     # Indicates the allowed versions. Must be formatted in increasing order.
  46     ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.11"]
  47 
  48     # Indicates the versions that should not be used.
  49     BUGGY_VERSIONS = ["0.4.22", "^0.4.22",
  50                       "0.5.5", "^0.5.5",
  51                       "0.5.6", "^0.5.6",
  52                       "0.5.14", "^0.5.14"]
  53 
  54     def _check_version(self, version):
  55         op = version[0]
  56         if op and op not in ['>', '>=', '^']:
  57             return self.LESS_THAN_TXT
  58         version_number = '.'.join(version[2:])
  59         if version_number not in self.ALLOWED_VERSIONS:
  60             if list(map(int, version[2:])) > list(map(int, self.ALLOWED_VERSIONS[-1].split('.'))):
  61                 return self.TOO_RECENT_VERSION_TXT
  62             return self.OLD_VERSION_TXT
  63         return None
  64 
  65     def _check_pragma(self, version):
  66         if version in self.BUGGY_VERSIONS:
  67             return self.BUGGY_VERSION_TXT
  68         versions = PATTERN.findall(version)
  69         if len(versions) == 1:
  70             version = versions[0]
  71             return self._check_version(version)
  72         elif len(versions) == 2:
  73             version_left = versions[0]
  74             version_right = versions[1]
  75             # Only allow two elements if the second one is
  76             # <0.5.0 or <0.6.0
  77             if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0'), ('<', '', '0', '7', '0')]:
  78                 return self.COMPLEX_PRAGMA_TXT
  79             return self._check_version(version_left)
  80         else:
  81             return self.COMPLEX_PRAGMA_TXT
  82 
  83     def _detect(self):
  84         """
  85         Detects pragma statements that allow for outdated solc versions.
  86         :return: Returns the relevant JSON data for the findings.
  87         """
  88         # Detect all version related pragmas and check if they are disallowed.
  89         results = []
  90         pragma = self.slither.pragma_directives
  91         disallowed_pragmas = []
  92         detected_version = False
  93         for p in pragma:
  94             # Skip any pragma directives which do not refer to version
  95             if len(p.directive) < 1 or p.directive[0] != "solidity":
  96                 continue
  97 
  98             # This is version, so we test if this is disallowed.
  99             detected_version = True
  100             reason = self._check_pragma(p.version)
  101             if reason:
  102                 disallowed_pragmas.append((reason, p))
  103 
  104         # If we found any disallowed pragmas, we output our findings.
  105         if disallowed_pragmas:
  106             for (reason, p) in disallowed_pragmas:
  107                 info = ["Pragma version", p, f" {reason}\n"]
  108 
  109                 json = self.generate_result(info)
  110 
  111                 results.append(json)
  112 
  113         return results
  114 
  115     @staticmethod
  116     def _format(slither, result):
  117         format(slither, result)
  118
  ```
  --- END FILES ---
  
  Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.
  
  Here is an example:
  
  ```diff
  diff --git a/examples/server_async.py b/examples/server_async.py
  --- a/examples/server_async.py
  +++ b/examples/server_async.py
  @@ -313,4 +313,4 @@
   
   
   if __name__ == "__main__":
  -    asyncio.run(run_async_server("."), debug=True)
  +    asyncio.run(run_async_server(), debug=True)
  diff --git a/examples/server_sync.py b/examples/server_sync.py
  --- a/examples/server_sync.py
  +++ b/examples/server_sync.py
  @@ -313,5 +313,5 @@
   
   
   if __name__ == "__main__":
  -    server = run_sync_server(".")
  +    server = run_sync_server()
       server.shutdown()
  
  ```
  
golden_diff: diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py
  --- a/slither/detectors/attributes/incorrect_solc.py
  +++ b/slither/detectors/attributes/incorrect_solc.py
  @@ -33,23 +33,30 @@
   `solc` frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.
   We also recommend avoiding complex `pragma` statement.'''
       WIKI_RECOMMENDATION = '''
  -Use Solidity 0.4.25 or 0.5.11. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''
  +Deploy with any of the following Solidity versions:
  +- 0.5.11 - 0.5.13,
  +- 0.5.15 - 0.5.17,
  +- 0.6.8,
  +- 0.6.10 - 0.6.11.
  +Use a simple pragma version that allows any of these versions.
  +Consider using the latest version of Solidity for testing.'''
   
       COMPLEX_PRAGMA_TXT = "is too complex"
       OLD_VERSION_TXT = "allows old versions"
       LESS_THAN_TXT = "uses lesser than"
   
  -    TOO_RECENT_VERSION_TXT = "necessitates versions too recent to be trusted. Consider deploying with 0.5.11"
  -    BUGGY_VERSION_TXT = "is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)"
  +    TOO_RECENT_VERSION_TXT = "necessitates a version too recent to be trusted. Consider deploying with 0.6.11"
  +    BUGGY_VERSION_TXT = "is known to contain severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)"
   
       # Indicates the allowed versions. Must be formatted in increasing order.
  -    ALLOWED_VERSIONS = ["0.4.25", "0.4.26", "0.5.11"]
  +    ALLOWED_VERSIONS = ["0.5.11", "0.5.12", "0.5.13", "0.5.15", "0.5.16", "0.5.17", "0.6.8", "0.6.10", "0.6.11"]
   
       # Indicates the versions that should not be used.
       BUGGY_VERSIONS = ["0.4.22", "^0.4.22",
                         "0.5.5", "^0.5.5",
                         "0.5.6", "^0.5.6",
  -                      "0.5.14", "^0.5.14"]
  +                      "0.5.14", "^0.5.14",
  +                      "0.6.9", "^0.6.9"]
   
       def _check_version(self, version):
           op = version[0]
  @@ -110,6 +117,17 @@
   
                   results.append(json)
   
  +        if self.slither.crytic_compile:
  +            if self.slither.crytic_compile.compiler_version:
  +                if self.slither.crytic_compile.compiler_version.version not in self.ALLOWED_VERSIONS:
  +                    info = ["solc-",
  +                            self.slither.crytic_compile.compiler_version.version,
  +                            " is not recommended for deployement\n"]
  +
  +                    json = self.generate_result(info)
  +
  +                    results.append(json)
  +
           return results
   
       @staticmethod
  
verification_info: {"golden_diff": "diff --git a/slither/detectors/attributes/incorrect_solc.py b/slither/detectors/attributes/incorrect_solc.py\n--- a/slither/detectors/attributes/incorrect_solc.py\n+++ b/slither/detectors/attributes/incorrect_solc.py\n@@ -33,23 +33,30 @@\n `solc` frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.\n We also recommend avoiding complex `pragma` statement.'''\n     WIKI_RECOMMENDATION = '''\n-Use Solidity 0.4.25 or 0.5.11. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''\n+Deploy with any of the following Solidity versions:\n+- 0.5.11 - 0.5.13,\n+- 0.5.15 - 0.5.17,\n+- 0.6.8,\n+- 0.6.10 - 0.6.11.\n+Use a simple pragma version that allows any of these versions.\n+Consider using the latest version of Solidity for testing.'''\n \n     COMPLEX_PRAGMA_TXT = \"is too complex\"\n     OLD_VERSION_TXT = \"allows old versions\"\n     LESS_THAN_TXT = \"uses lesser than\"\n \n-    TOO_RECENT_VERSION_TXT = \"necessitates versions too recent to be trusted. Consider deploying with 0.5.11\"\n-    BUGGY_VERSION_TXT = \"is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\"\n+    TOO_RECENT_VERSION_TXT = \"necessitates a version too recent to be trusted. Consider deploying with 0.6.11\"\n+    BUGGY_VERSION_TXT = \"is known to contain severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)\"\n \n     # Indicates the allowed versions. Must be formatted in increasing order.\n-    ALLOWED_VERSIONS = [\"0.4.25\", \"0.4.26\", \"0.5.11\"]\n+    ALLOWED_VERSIONS = [\"0.5.11\", \"0.5.12\", \"0.5.13\", \"0.5.15\", \"0.5.16\", \"0.5.17\", \"0.6.8\", \"0.6.10\", \"0.6.11\"]\n \n     # Indicates the versions that should not be used.\n     BUGGY_VERSIONS = [\"0.4.22\", \"^0.4.22\",\n                       \"0.5.5\", \"^0.5.5\",\n                       \"0.5.6\", \"^0.5.6\",\n-                      \"0.5.14\", \"^0.5.14\"]\n+                      \"0.5.14\", \"^0.5.14\",\n+                      \"0.6.9\", \"^0.6.9\"]\n \n     def _check_version(self, version):\n         op = version[0]\n@@ -110,6 +117,17 @@\n \n                 results.append(json)\n \n+        if self.slither.crytic_compile:\n+            if self.slither.crytic_compile.compiler_version:\n+                if self.slither.crytic_compile.compiler_version.version not in self.ALLOWED_VERSIONS:\n+                    info = [\"solc-\",\n+                            self.slither.crytic_compile.compiler_version.version,\n+                            \" is not recommended for deployement\\n\"]\n+\n+                    json = self.generate_result(info)\n+\n+                    results.append(json)\n+\n         return results\n \n     @staticmethod\n", "issue": "FileNotFoundError: [Errno 2] No such file or directory: 'solc'\nI launch  program like this:\r\n\r\n    slither Contract.sol \r\n\r\nand receive an error:\r\n\"FileNotFoundError: [Errno 2] No such file or directory: 'solc'\"\r\n\r\nI have solc installed.\r\n\r\n    $ solcjs --version\r\n    0.4.25+commit.59dbf8f1.Emscripten.clang\r\n\r\nBut executable is called **solcjs**, not **solc**. Or it is something different?\r\n\nReasoning for \"Trusted\" versions of Solidity\nRe: https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity\r\n\r\nI am wondering why `0.4.25 or 0.5.11` are chosen as trusted versions.\r\n\r\nWould 0.4.26 or 0.5.17 be acceptable? (current highest patches of those minor versions)\r\n\r\nWhy are none of the 0.6.x versions included as a \"trusted\" version?\r\n\r\nWhat are the criteria for adding / bumping the version of \"trusted\"? Is it based on a simple metric like time since release? Or were those two specific versions manually audited by your team members?\r\n\r\nSorry for all the questions. I have a project which is fairly portable between `>=0.5.0 <=0.7.0` and am wondering which version to target... I would like to use `immutable` from `>=0.6.5`, but not at the expense of some possible security issue. And after using this tool I wondered what the criteria was for \"trusted versions\" of the compiler.\r\n\r\nThanks.\n", "before_files": [{"content": "\"\"\"\n    Check if an incorrect version of solc is used\n\"\"\"\n\nimport re\nfrom slither.detectors.abstract_detector import AbstractDetector, DetectorClassification\nfrom slither.formatters.attributes.incorrect_solc import format\n\n# group:\n# 0: ^ > >= < <= (optional)\n# 1: ' ' (optional)\n# 2: version number\n# 3: version number\n# 4: version number\n\nPATTERN = re.compile('(\\^|>|>=|<|<=)?([ ]+)?(\\d+)\\.(\\d+)\\.(\\d+)')\n\n\nclass IncorrectSolc(AbstractDetector):\n    \"\"\"\n    Check if an old version of solc is used\n    \"\"\"\n\n    ARGUMENT = 'solc-version'\n    HELP = 'Incorrect Solidity version'\n    IMPACT = DetectorClassification.INFORMATIONAL\n    CONFIDENCE = DetectorClassification.HIGH\n\n    WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'\n\n    WIKI_TITLE = 'Incorrect versions of Solidity'\n    WIKI_DESCRIPTION = '''\n`solc` frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.\nWe also recommend avoiding complex `pragma` statement.'''\n    WIKI_RECOMMENDATION = '''\nUse Solidity 0.4.25 or 0.5.11. Consider using the latest version of Solidity for testing the compilation, and a trusted version for deploying.'''\n\n    COMPLEX_PRAGMA_TXT = \"is too complex\"\n    OLD_VERSION_TXT = \"allows old versions\"\n    LESS_THAN_TXT = \"uses lesser than\"\n\n    TOO_RECENT_VERSION_TXT = \"necessitates versions too recent to be trusted. Consider deploying with 0.5.11\"\n    BUGGY_VERSION_TXT = \"is known to contain severe issue (https://solidity.readthedocs.io/en/v0.5.8/bugs.html)\"\n\n    # Indicates the allowed versions. Must be formatted in increasing order.\n    ALLOWED_VERSIONS = [\"0.4.25\", \"0.4.26\", \"0.5.11\"]\n\n    # Indicates the versions that should not be used.\n    BUGGY_VERSIONS = [\"0.4.22\", \"^0.4.22\",\n                      \"0.5.5\", \"^0.5.5\",\n                      \"0.5.6\", \"^0.5.6\",\n                      \"0.5.14\", \"^0.5.14\"]\n\n    def _check_version(self, version):\n        op = version[0]\n        if op and op not in ['>', '>=', '^']:\n            return self.LESS_THAN_TXT\n        version_number = '.'.join(version[2:])\n        if version_number not in self.ALLOWED_VERSIONS:\n            if list(map(int, version[2:])) > list(map(int, self.ALLOWED_VERSIONS[-1].split('.'))):\n                return self.TOO_RECENT_VERSION_TXT\n            return self.OLD_VERSION_TXT\n        return None\n\n    def _check_pragma(self, version):\n        if version in self.BUGGY_VERSIONS:\n            return self.BUGGY_VERSION_TXT\n        versions = PATTERN.findall(version)\n        if len(versions) == 1:\n            version = versions[0]\n            return self._check_version(version)\n        elif len(versions) == 2:\n            version_left = versions[0]\n            version_right = versions[1]\n            # Only allow two elements if the second one is\n            # <0.5.0 or <0.6.0\n            if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0'), ('<', '', '0', '7', '0')]:\n                return self.COMPLEX_PRAGMA_TXT\n            return self._check_version(version_left)\n        else:\n            return self.COMPLEX_PRAGMA_TXT\n\n    def _detect(self):\n        \"\"\"\n        Detects pragma statements that allow for outdated solc versions.\n        :return: Returns the relevant JSON data for the findings.\n        \"\"\"\n        # Detect all version related pragmas and check if they are disallowed.\n        results = []\n        pragma = self.slither.pragma_directives\n        disallowed_pragmas = []\n        detected_version = False\n        for p in pragma:\n            # Skip any pragma directives which do not refer to version\n            if len(p.directive) < 1 or p.directive[0] != \"solidity\":\n                continue\n\n            # This is version, so we test if this is disallowed.\n            detected_version = True\n            reason = self._check_pragma(p.version)\n            if reason:\n                disallowed_pragmas.append((reason, p))\n\n        # If we found any disallowed pragmas, we output our findings.\n        if disallowed_pragmas:\n            for (reason, p) in disallowed_pragmas:\n                info = [\"Pragma version\", p, f\" {reason}\\n\"]\n\n                json = self.generate_result(info)\n\n                results.append(json)\n\n        return results\n\n    @staticmethod\n    def _format(slither, result):\n        format(slither, result)\n", "path": "slither/detectors/attributes/incorrect_solc.py"}], "after_files": [{"content": "\"\"\"\n    Check if an incorrect version of solc is used\n\"\"\"\n\nimport re\nfrom slither.detectors.abstract_detector import AbstractDetector, DetectorClassification\nfrom slither.formatters.attributes.incorrect_solc import format\n\n# group:\n# 0: ^ > >= < <= (optional)\n# 1: ' ' (optional)\n# 2: version number\n# 3: version number\n# 4: version number\n\nPATTERN = re.compile('(\\^|>|>=|<|<=)?([ ]+)?(\\d+)\\.(\\d+)\\.(\\d+)')\n\n\nclass IncorrectSolc(AbstractDetector):\n    \"\"\"\n    Check if an old version of solc is used\n    \"\"\"\n\n    ARGUMENT = 'solc-version'\n    HELP = 'Incorrect Solidity version'\n    IMPACT = DetectorClassification.INFORMATIONAL\n    CONFIDENCE = DetectorClassification.HIGH\n\n    WIKI = 'https://github.com/crytic/slither/wiki/Detector-Documentation#incorrect-versions-of-solidity'\n\n    WIKI_TITLE = 'Incorrect versions of Solidity'\n    WIKI_DESCRIPTION = '''\n`solc` frequently releases new compiler versions. Using an old version prevents access to new Solidity security checks.\nWe also recommend avoiding complex `pragma` statement.'''\n    WIKI_RECOMMENDATION = '''\nDeploy with any of the following Solidity versions:\n- 0.5.11 - 0.5.13,\n- 0.5.15 - 0.5.17,\n- 0.6.8,\n- 0.6.10 - 0.6.11.\nUse a simple pragma version that allows any of these versions.\nConsider using the latest version of Solidity for testing.'''\n\n    COMPLEX_PRAGMA_TXT = \"is too complex\"\n    OLD_VERSION_TXT = \"allows old versions\"\n    LESS_THAN_TXT = \"uses lesser than\"\n\n    TOO_RECENT_VERSION_TXT = \"necessitates a version too recent to be trusted. Consider deploying with 0.6.11\"\n    BUGGY_VERSION_TXT = \"is known to contain severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)\"\n\n    # Indicates the allowed versions. Must be formatted in increasing order.\n    ALLOWED_VERSIONS = [\"0.5.11\", \"0.5.12\", \"0.5.13\", \"0.5.15\", \"0.5.16\", \"0.5.17\", \"0.6.8\", \"0.6.10\", \"0.6.11\"]\n\n    # Indicates the versions that should not be used.\n    BUGGY_VERSIONS = [\"0.4.22\", \"^0.4.22\",\n                      \"0.5.5\", \"^0.5.5\",\n                      \"0.5.6\", \"^0.5.6\",\n                      \"0.5.14\", \"^0.5.14\",\n                      \"0.6.9\", \"^0.6.9\"]\n\n    def _check_version(self, version):\n        op = version[0]\n        if op and op not in ['>', '>=', '^']:\n            return self.LESS_THAN_TXT\n        version_number = '.'.join(version[2:])\n        if version_number not in self.ALLOWED_VERSIONS:\n            if list(map(int, version[2:])) > list(map(int, self.ALLOWED_VERSIONS[-1].split('.'))):\n                return self.TOO_RECENT_VERSION_TXT\n            return self.OLD_VERSION_TXT\n        return None\n\n    def _check_pragma(self, version):\n        if version in self.BUGGY_VERSIONS:\n            return self.BUGGY_VERSION_TXT\n        versions = PATTERN.findall(version)\n        if len(versions) == 1:\n            version = versions[0]\n            return self._check_version(version)\n        elif len(versions) == 2:\n            version_left = versions[0]\n            version_right = versions[1]\n            # Only allow two elements if the second one is\n            # <0.5.0 or <0.6.0\n            if version_right not in [('<', '', '0', '5', '0'), ('<', '', '0', '6', '0'), ('<', '', '0', '7', '0')]:\n                return self.COMPLEX_PRAGMA_TXT\n            return self._check_version(version_left)\n        else:\n            return self.COMPLEX_PRAGMA_TXT\n\n    def _detect(self):\n        \"\"\"\n        Detects pragma statements that allow for outdated solc versions.\n        :return: Returns the relevant JSON data for the findings.\n        \"\"\"\n        # Detect all version related pragmas and check if they are disallowed.\n        results = []\n        pragma = self.slither.pragma_directives\n        disallowed_pragmas = []\n        detected_version = False\n        for p in pragma:\n            # Skip any pragma directives which do not refer to version\n            if len(p.directive) < 1 or p.directive[0] != \"solidity\":\n                continue\n\n            # This is version, so we test if this is disallowed.\n            detected_version = True\n            reason = self._check_pragma(p.version)\n            if reason:\n                disallowed_pragmas.append((reason, p))\n\n        # If we found any disallowed pragmas, we output our findings.\n        if disallowed_pragmas:\n            for (reason, p) in disallowed_pragmas:\n                info = [\"Pragma version\", p, f\" {reason}\\n\"]\n\n                json = self.generate_result(info)\n\n                results.append(json)\n\n        if self.slither.crytic_compile:\n            if self.slither.crytic_compile.compiler_version:\n                if self.slither.crytic_compile.compiler_version.version not in self.ALLOWED_VERSIONS:\n                    info = [\"solc-\",\n                            self.slither.crytic_compile.compiler_version.version,\n                            \" is not recommended for deployement\\n\"]\n\n                    json = self.generate_result(info)\n\n                    results.append(json)\n\n        return results\n\n    @staticmethod\n    def _format(slither, result):\n        format(slither, result)\n", "path": "slither/detectors/attributes/incorrect_solc.py"}]}