code: def _read_header_22_and_above(fname):
      basic_header = {}
      dtype0 = nsx_header_dict["basic"]
      dtype1 = nsx_header_dict["extended"]
  
      nsx_file_header = np.fromfile(fname, count=1, dtype=dtype0)[0]
      basic_header.update(
          {
              name: nsx_file_header[name]
              for name in nsx_file_header.dtype.names
          }
      )
  
      offset_dtype0 = np.dtype(dtype0).itemsize
      shape = nsx_file_header["channel_count"]
      basic_header["extended"] = np.memmap(
          fname,
          shape=shape,
          offset=offset_dtype0,
          dtype=dtype1,
          mode="r",
      )
  
      # The following values are stored in mHz
      # See:
      # https://blackrockneurotech.com/wp-content/uploads/LB-0023-7.00_NEV_File_Format.pdf
      basic_header["highpass"] = basic_header["extended"][
          "hi_freq_corner"
      ]
      basic_header["lowpass"] = basic_header["extended"][
          "lo_freq_corner"
      ]
      for x in ["highpass", "lowpass"]:
          basic_header[x] = basic_header[x] * 1e-3
  
      ver_major, ver_minor = basic_header.pop(
          "ver_major"
      ), basic_header.pop("ver_minor")
      basic_header["spec"] = f"{ver_major}.{ver_minor}"
  
      data_header = list()
      index = 0
      offset = basic_header["bytes_in_headers"]
      filesize = _file_size(fname)
      if float(basic_header["spec"]) < 3.0:
          dtype2 = nsx_header_dict["data>2.1<3"]
      else:
          dtype2 = nsx_header_dict["data>=3"]
      while offset < filesize:
          dh = np.memmap(
              fname, dtype=dtype2, shape=1, offset=offset, mode="r"
          )[0]
          data_header.append(
              {
                  "header": dh["header"],
                  "timestamp": dh["timestamp"],
                  "nb_data_points": dh["nb_data_points"],
                  "offset_to_data_block": offset + dh.dtype.itemsize,
              }
          )
          # data size = number of data points * (data_bytes * number of channels)
          # use of `int` avoids overflow problem
          data_size = (
              int(dh["nb_data_points"])
              * int(basic_header["channel_count"])
              * DATA_BYTE_SIZE
          )
          # define new offset (to possible next data block)
          offset = (
              data_header[index]["offset_to_data_block"] + data_size
          )
          index += 1
  
      basic_header["data_header"] = data_header
      return basic_header
  
file_path: mne-python/mne/io/nsx/nsx.py
imports: import os
  from datetime import datetime, timezone
  import numpy
  from ..._fiff.constants import FIFF
  from ..._fiff.meas_info import _empty_info
  from ..._fiff.utils import _file_size, _read_segments_file
  from ...annotations import Annotations
  from ...utils import fill_doc, logger, warn
  from ..base import BaseRaw, _get_scaling
label_desc: Use image node_id 3 for calling a global function with example usage: _read_header_22_and_above(fname) and returns: basic_header