code: def _less_than_indices_numba(
      left_array: np.ndarray,
      right_array: np.ndarray,
      left_index: np.ndarray,
      right_index: np.ndarray,
      right_is_sorted: bool,
      keep: str,
      any_nulls: bool,
      strict: bool = False,
  ) -> np.ndarray:
      """
      Get indices for less than join
      """
      low = 0
      high = len(right_array)
      length = len(left_array)
      positions = np.empty(length, dtype=np.intp)
      booleans = np.ones(length, dtype=np.bool_)
      counts = 0
      exclude = 0
      for num in prange(length):
          value = left_array[num]
          pos = _less_than_index_numba(right_array, value, low, high)
          if pos == high:
              booleans[num] = False
              exclude += 1
              continue
          if strict and (right_array[pos] == value):
              pos = _greater_than_index_numba(
                  right_array, value, pos + 1, high
              )
              if pos == high:
                  booleans[num] = False
                  exclude += 1
                  continue
          positions[num] = pos
          counts += high - pos
      if counts == 0:
          return None, None
  
      if exclude > 0:
          positions = positions[booleans]
          left_index = left_index[booleans]
          booleans = None
      length = len(positions)
      if right_is_sorted and (keep == "first"):
          right_arr = np.empty(length, dtype=np.intp)
          if any_nulls:
              for num in prange(length):
                  right_arr[num] = right_index[positions[num]]
              return left_index, right_arr
          return left_index, positions
  
      if keep == "first":
          right_arr = np.empty(length, dtype=np.intp)
          for num in prange(length):
              pos = positions[num]
              minimum = right_index[pos]
              for n in range(pos, high):
                  value = right_index[n]
                  if value < minimum:
                      minimum = value
              right_arr[num] = minimum
          return left_index, right_arr
  
      if keep == "last":
          right_arr = np.empty(length, dtype=np.intp)
          for num in prange(length):
              pos = positions[num]
              maximum = right_index[pos]
              for n in range(pos, high):
                  value = right_index[n]
                  if value > maximum:
                      maximum = value
              right_arr[num] = maximum
          return left_index, right_arr
  
      starts = np.empty(length, dtype=np.intp)
      starts[0] = 0
      starts[1:] = np.cumsum((high - positions)[:-1])
      left_arr = np.empty(counts, dtype=np.intp)
      right_arr = np.empty(counts, dtype=np.intp)
      for num in prange(length):
          start = starts[num]
          pos = positions[num]
          l_index = left_index[num]
          for n in range(high - pos):
              left_arr[start + n] = l_index
              right_arr[start + n] = right_index[pos + n]
  
      return left_arr, right_arr
  
file_path: pyjanitor/janitor/functions/_numba.py
imports: import numpy
  import pandas
  from numba import njit, prange
  from pandas.api.types import is_datetime64_dtype, is_extension_array_dtype
  from janitor.functions.utils import _generic_func_cond_join, _null_checks_cond_join, greater_than_join_types, less_than_join_types
label_desc: Use image node_id 13 for calling a global function with example usage: _less_than_indices_numba(left_array, right_array, left_index, right_index, right_is_sorted, keep, any_nulls, strict) and returns: left_arr,  right_arr, None,  None, left_index,  positions, left_index,  right_arr, left_index,  right_arr, left_index,  right_arr