code: def make_int(width, unsigned):
      delay_type_int = getattr(
          delay_type, unsigned + "int" + str(width)
      )
  
      @class_annotate()
      class int:
          _width = width
          _unsigned = unsigned
  
          @annotate(v=delay_type_int)
          def __init__(self, v=0):
              self._val = v
  
          @property
          def val(self):
              return self._val
  
          @val.setter
          def val(self, v):
              from .type_mapping import (
                  builtin_to_string,
                  nptype_from_builtin,
                  numpy_type_to_builtin_type,
              )
  
              if not isinstance(v, (np.generic, np.ndarray, sm.Basic)):
                  raise ValueError(
                      f"types should have value of numpy type or Symbols, got {type(v)} instead"
                  )
  
              if isinstance(v, sm.Basic):
                  self._val = v
              elif isinstance(v, np.integer):
                  v_type = numpy_type_to_builtin_type(v.dtype)
                  if v_type.get_bitwidth() <= self.get_bitwidth() and (
                      v >= 0 or v < 0 and not self.is_unsigned()
                  ):
                      self._val = v
                  else:
                      self._val = v.astype(
                          nptype_from_builtin(self.__class__)
                      )
                      logger.warning(
                          f"Saving value type of {v.dtype} into a builtin type of "
                          f"{builtin_to_string(self.__class__)}, might overflow or loses precision!"
                      )
              else:
                  self._val = v.astype(
                      nptype_from_builtin(self.__class__)
                  )
                  logger.warning(
                      f"Saving value type of {v.dtype} into a builtin type of "
                      f"{builtin_to_string(self.__class__)}, might be incompatible or loses precision!"
                  )
  
          @classmethod
          def __type_info__(cls):
              return Type(
                  cls._unsigned + "int" + str(cls._width),
                  python_class=cls,
              )
  
          @classmethod
          def get_bitwidth(cls):
              return cls._width
  
          @classmethod
          def is_unsigned(cls):
              return cls._unsigned == "u"
  
          @annotate(delay_type_int, other=delay_type_int)
          def __add__(self, other):
              assert isinstance(other, int)
              return int(self.val + other.val)
  
          @annotate(delay_type_int, other=delay_type_int)
          def __sub__(self, other):
              assert isinstance(other, int)
              return int(self.val - other.val)
  
          @annotate(delay_type_int, other=delay_type_int)
          def __mul__(self, other):
              assert isinstance(other, int)
              return int(self.val * other.val)
  
          @annotate(delay_type_int, other=delay_type_int)
          def __div__(self, other):
              assert isinstance(other, int)
              return int(self.val // other.val)
  
          @annotate(delay_type_int, other=delay_type_int)
          def __mod__(self, other):
              assert isinstance(other, int)
              return int(self.val % other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __lt__(self, other):
              return bool(self.val < other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __gt__(self, other):
              return bool(self.val > other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __le__(self, other):
              return bool(self.val <= other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __ge__(self, other):
              return bool(self.val >= other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __eq__(self, other):
              return bool(self.val == other.val)
  
          @annotate(delay_type.bool, other=delay_type_int)
          def __ne__(self, other):
              return bool(self.val != other.val)
  
          @annotate(delay_type.bool)
          def __bool__(self):
              return self.val != 0
  
          @annotate(delay_type_int)
          def __int__(self):
              return int(self)
  
          @annotate(delay_type.double)
          def __double__(self):
              return float(self.val)
  
          @annotate(delay_type.str)
          def __str__(self):
              return str(self.val)
  
          @annotate(delay_type.double)
          def __log__(self):
              return math.log(self.val)
  
          @annotate(delay_type.double)
          def __exp__(self):
              return math.exp(self.val)
  
          @annotate(delay_type_int)
          def __neg__(self):
              return int(-self.val)
  
      return int
  
file_path: coremltools/coremltools/converters/mil/mil/types/type_int.py
imports: import math
  import numpy
  import sympy
  from coremltools import _logger
  from .annotate import annotate, class_annotate, delay_type
  from .type_bool import bool
  from .type_spec import Type
label_desc: Use image node_id 1 for calling a global function with example usage: make_int(width, unsigned) and returns: int, self, Type, cls, unknown, int, int, int, int, int, bool, bool, bool, bool, bool, bool, unknown, int, float, str, math, math, int