code: def jit(
      fn: Optional[T] = None,
      *,
      version=None,
      do_not_specialize: Optional[Iterable[int]] = None,
      debug: Optional[bool] = None,
      noinline: Optional[bool] = None,
  ) -> Union[JITFunction[T], Callable[[T], JITFunction[T]]]:
      """
      Decorator for JIT-compiling a function using the Triton compiler.
  
      :note: When a jit'd function is called, arguments are
          implicitly converted to pointers if they have a :code:`.data_ptr()` method
          and a `.dtype` attribute.
  
      :note: This function will be compiled and run on the GPU. It will only have access to:
  
             * python primitives,
             * builtins within the triton package,
             * arguments to this function,
             * other jit'd functions
  
      :param fn: the function to be jit-compiled
      :type fn: Callable
      """
  
      def decorator(fn: T) -> JITFunction[T]:
          assert callable(fn)
          if os.getenv("TRITON_INTERPRET", "0") == "1":
              from .interpreter import InterpretedFunction
  
              return InterpretedFunction(fn)
          else:
              return JITFunction(
                  fn,
                  version=version,
                  do_not_specialize=do_not_specialize,
                  debug=debug,
                  noinline=noinline,
              )
  
      if fn is not None:
          return decorator(fn)
  
      else:
          return decorator
  
imports: from __future__ import annotations, division
  import ast
  import hashlib
  import inspect
  import os
  import textwrap
  from collections import defaultdict, namedtuple
  from functools import cached_property
  from typing import Callable, Generic, Iterable, List, Optional, TypeVar, Union, cast, overload
  from ..runtime.driver import driver
label_desc: Use image node_id 4 for calling a global function with example usage: jit(fn) and returns: decorator, decorator, InterpretedFunction, JITFunction