code: def get_dependencies(src, include_path):
      result = {}
  
      from os.path import realpath, join
  
      def _inner(src):
          for match in C_INCLUDE_RE.finditer(src):
              included = match.group(1)
  
              found = False
              for ipath in include_path:
                  included_file_name = realpath(join(ipath, included))
  
                  if included_file_name not in result:
                      try:
                          src_file = open(included_file_name)
                      except OSError:
                          continue
  
                      try:
                          included_src = src_file.read()
                      finally:
                          src_file.close()
  
                      # jrevent infinite recursion if some header file appears to
                      # include itself
                      result[included_file_name] = None
  
                      checksum = new_hash()
                      update_checksum(checksum, included_src)
                      _inner(included_src)
  
                      result[included_file_name] = (
                          os.stat(included_file_name).st_mtime,
                          checksum.hexdigest(),
                      )
  
                      found = True
                      break  # stop searching the include path
  
              if not found:
                  pass
  
      _inner(src)
  
      result = [(name,) + vals for name, vals in result.items()]
      result.sort()
  
      return result
  
imports: import re
  import os
  import sys
  from dataclasses import dataclass
  from typing import List, Optional, Tuple
  import pyopencl._cl
  import logging
  import hashlib
label_desc: Use image node_id 3 for calling a global function with example usage: get_dependencies(src, include_path) and returns: result