docs: def fix_builtins(override_debug=False):
      """Activate the builtins compatibility."""
      override_dict = {}
      orig_print = None
      used_print = None
  
      if(__builtins__.__class__ is dict):
          builtins_dict = __builtins__
      else:
          try:
              import builtins
          except ImportError:
              import __builtin__ as builtins
          builtins_dict = builtins.__dict__
  
      def _deprecated(*args, **kwargs):
          """Report the fact that the called function is deprecated."""
          import traceback
          raise DeprecationWarning("the called function is deprecated => " +
                                   traceback.extract_stack(None, 2)[0][3])
  
      def _print_wrapper(*args, **kwargs):
          flush = kwargs.get("flush", False)
          if "flush" in kwargs:
              del kwargs["flush"]
          orig_print(*args, **kwargs)
          if flush:
              kwargs.get("file", sys.stdout).flush()
  
      def _print_full(*args, **kwargs):
          opt = {"sep": " ", "end": "\n", "file": sys.stdout, "flush": False}
          for key in kwargs:
              if(key in opt):
                  opt[key] = kwargs[key]
              else:
                  raise TypeError("'"+key+"' is an invalid keyword argument "
                                  "for this function")
          opt["file"].write(opt["sep"].join(str(val) for val in args)+opt["end"])
          if opt["flush"]:
              opt["file"].flush()
  
      def _sorted(my_list):
          my_list = list(my_list)
          my_list.sort()
          return my_list
  
      def _format(value, format_spec):
          return value.__format__(format_spec)
  
      if builtins_dict.get(__name__, False):
          raise RuntimeError(__name__+" already loaded")
  
      # Exceptions
      if builtins_dict.get("BaseException") is None:
          override_dict["BaseException"] = Exception
  
      # basestring
      if builtins_dict.get("basestring") is None:
          if builtins_dict.get("bytes") is None:
              import types
              override_dict["basestring"] = types.StringType
          else:
              override_dict["basestring"] = (str, bytes)  # It works only when used in isinstance
      # IntType
      if getattr(int, "__str__", None) is None:
          import types
          override_dict["IntType"] = types.IntType
      else:
          override_dict["IntType"] = int  # Python >= 2.2
  
      if 'format' not in str.__dict__:
          override_dict["str"] = _Internal.ExtStr
      # Function 'input'
      if builtins_dict.get("raw_input") is not None:
          override_dict["input"] = builtins_dict.get("raw_input")
      override_dict["raw_input"] = _deprecated
      # Function 'print' (also aliased as print_)
      if sys.version_info >= (3, 3):
          used_print = builtins_dict.get("print")
      else:
          orig_print = builtins_dict.get("print")
          if orig_print is not None:
              used_print = _print_wrapper
          else:
              used_print = _print_full
          override_dict["print"] = used_print
      override_dict["print_"] = used_print
      # Function 'sorted'
      if builtins_dict.get("sorted") is None:
          override_dict["sorted"] = _sorted
      # Function 'format'
      if builtins_dict.get("format") is None:
          override_dict["format"] = _format
  
      override_dict[__name__] = True
      builtins_dict.update(override_dict)
      del override_dict