diff --git a/README.md b/README.md
index 8075253..123ea78 100644
--- a/README.md
+++ b/README.md
@@ -51,6 +51,7 @@ There are 3 examples with the VL53L8CH library:
 
 * VL53L8CH_ThresholdsDetection: This example code is to show how to configure the thresholds detection of the VL53L8CH satellite sensor.
 
+* VL53L8CH_CNHData: This example code is to show how to configure, capture and decode CNH data from the VL53L8CH sensors.
 
 ## Documentation
 
diff --git a/examples/VL53L8CH_CNHData/VL53L8CH_CNHData.ino b/examples/VL53L8CH_CNHData/VL53L8CH_CNHData.ino
new file mode 100644
index 0000000..48b0942
--- /dev/null
+++ b/examples/VL53L8CH_CNHData/VL53L8CH_CNHData.ino
@@ -0,0 +1,175 @@
+/**
+******************************************************************************
+* @file    VL53L8CH_CNHData.ino
+* @brief   Example Arduino sketch using VL53L8CH class API with CNH feature.
+******************************************************************************
+*/
+
+#include <vl53l8ch.h>
+#include <vl53lmz_plugin_cnh.h>
+
+#ifdef ARDUINO_SAM_DUE
+  #define DEV_I2C Wire1
+#else
+  #define DEV_I2C Wire
+#endif
+#define SerialPort Serial
+
+#define LPN_PIN A3
+#define PWREN_PIN 11
+
+VL53L8CH sensor(&DEV_I2C, LPN_PIN);
+
+VL53LMZ_Motion_Configuration cnh_config;
+cnh_data_buffer_t cnh_data_buffer;
+uint32_t cnh_data_size = 0;
+
+int32_t  *p_hist = NULL;
+int8_t   *p_hist_scaler = NULL;
+int32_t  *p_ambient = NULL;
+int8_t   *p_ambient_scaler = NULL;
+
+uint8_t status;
+uint8_t resolution = VL53LMZ_RESOLUTION_4X4;
+
+void setup()
+{
+  SerialPort.begin(460800);
+
+  if (PWREN_PIN >= 0) {
+    pinMode(PWREN_PIN, OUTPUT);
+    digitalWrite(PWREN_PIN, HIGH);
+    delay(10);
+  }
+
+  DEV_I2C.begin();
+
+  status = sensor.begin();
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Sensor begin failed");
+    while (1);
+  }
+
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Sensor init failed");
+    while (1);
+  }
+
+  status = sensor.set_resolution(resolution);
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Set resolution failed");
+    while (1);
+  }
+
+  status = sensor.cnh_init_config(&cnh_config, 0, 24, 4);
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("CNH init config failed");
+    while (1);
+  }
+
+  status = sensor.cnh_create_agg_map(&cnh_config,
+                                     16, 0, 0, 1, 1, 4, 4);
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("CNH create agg map failed");
+    while (1);
+  }
+
+  status = sensor.cnh_calc_required_memory(&cnh_config, &cnh_data_size);
+  if (status != VL53LMZ_STATUS_OK || cnh_data_size > VL53LMZ_CNH_MAX_DATA_BYTES) {
+    SerialPort.println("CNH memory size error");
+    while (1);
+  }
+
+  status = sensor.cnh_send_config(&cnh_config);
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("CNH send config failed");
+    while (1);
+  }
+
+  status = sensor.create_output_config();
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Create output config failed");
+    while (1);
+  }
+
+  union Block_header cnh_data_bh;
+  cnh_data_bh.idx = VL53LMZ_CNH_DATA_IDX;
+  cnh_data_bh.type = 4;
+  cnh_data_bh.size = cnh_data_size / 4;
+
+  status = sensor.add_output_block(cnh_data_bh.bytes);
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Add output block CNH failed");
+    while (1);
+  }
+
+  status = sensor.send_output_config_and_start();
+  if (status != VL53LMZ_STATUS_OK) {
+    SerialPort.println("Start ranging failed");
+    while (1);
+  }
+
+  SerialPort.println("Sensor and CNH configured, ranging started");
+}
+
+void loop()
+{
+  VL53LMZ_ResultsData results;
+  uint8_t data_ready = 0;
+
+  do {
+    status = sensor.check_data_ready(&data_ready);
+  } while (!data_ready);
+
+  if (status == VL53LMZ_STATUS_OK && data_ready) {
+    status = sensor.get_ranging_data(&results);
+    if (status == VL53LMZ_STATUS_OK) {
+      print_results(&results);
+    }
+
+    status = sensor.results_extract_block(VL53LMZ_CNH_DATA_IDX, (uint8_t *)cnh_data_buffer, cnh_data_size);
+    if (status == VL53LMZ_STATUS_OK) {
+      for (int agg_id = 0; agg_id < cnh_config.nb_of_aggregates; agg_id++) {
+        sensor.cnh_get_block_addresses(&cnh_config, agg_id, cnh_data_buffer,
+                                       &p_hist, &p_hist_scaler,
+                                       &p_ambient, &p_ambient_scaler);
+
+        float ambient = ((float) * p_ambient) / (1 << *p_ambient_scaler);
+        SerialPort.print("Aggregate ");
+        SerialPort.print(agg_id);
+        SerialPort.print(", Ambient: ");
+        SerialPort.print(ambient, 1);
+        SerialPort.print(", Bins: ");
+
+        for (int bin = 0; bin < cnh_config.feature_length; bin++) {
+          float bin_val = ((float)p_hist[bin]) / (1 << p_hist_scaler[bin]);
+          SerialPort.print(bin_val, 1);
+          SerialPort.print(", ");
+        }
+        SerialPort.println();
+      }
+    } else {
+      SerialPort.println("Failed to extract CNH data block");
+    }
+  }
+  delay(100);
+}
+
+void print_results(VL53LMZ_ResultsData *res)
+{
+  SerialPort.println("Ranging Results:");
+  for (int i = 0; i < resolution; i++) {
+    if (res->nb_target_detected[i] > 0) {
+      SerialPort.print("Zone ");
+      SerialPort.print(i);
+      SerialPort.print(": Distance=");
+      SerialPort.print(res->distance_mm[i]);
+      SerialPort.print(" mm, Status=");
+      SerialPort.println(res->target_status[i]);
+    } else {
+      SerialPort.print("Zone ");
+      SerialPort.print(i);
+      SerialPort.println(": No target");
+    }
+  }
+}
\ No newline at end of file
diff --git a/keywords.txt b/keywords.txt
index 2237f57..9f0f6fc 100644
--- a/keywords.txt
+++ b/keywords.txt
@@ -73,6 +73,10 @@ cnh_calc_min_max_distance    KEYWORD2
 cnh_send_config    KEYWORD2
 cnh_get_block_addresses    KEYWORD2
 cnh_get_ref_residual    KEYWORD2
+get_ranging_frequency_x256   KEYWORD2
+set_ranging_frequency_x256   KEYWORD2
+get_VHV_repeat_count   KEYWORD2
+set_VHV_repeat_count   KEYWORD2
 
 #######################################
 # Constants (LITERAL1)
@@ -184,3 +188,5 @@ VL53LMZ_CNH_MAX_DATA_WORDS LITERAL1
 VL53LMZ_CNH_MAX_DATA_BYTES LITERAL1
 VL53LMZ_CNH_DATA_IDX LITERAL1
 VL53LMZ_CNH_DATA_BH LITERAL1
+VL53LMZ_DCI_VHV_CONFIG LITERAL1
+VL53LMZ_STATUS_FW_CHECKSUM_FAIL LITERAL1
\ No newline at end of file
diff --git a/library.properties b/library.properties
index c2cc815..b45eadc 100644
--- a/library.properties
+++ b/library.properties
@@ -1,5 +1,5 @@
 name=STM32duino VL53L8CH
-version=1.0.0
+version=2.0.0
 author=STMicroelectronics
 maintainer=stm32duino
 sentence=Allows controlling the VL53L8CH (Time-of-Flight 8x8 multizone ranging sensor with wide field view)
diff --git a/src/vl53l8ch.cpp b/src/vl53l8ch.cpp
index ac932ad..9ea3bfa 100644
--- a/src/vl53l8ch.cpp
+++ b/src/vl53l8ch.cpp
@@ -770,6 +770,63 @@ uint32_t VL53L8CH::cnh_get_ref_residual(cnh_data_buffer_t mi_persistent_array)
   return vl53lmz_cnh_get_ref_residual(mi_persistent_array);
 }
 
+/**
+ * @brief This function gets the current ranging frequency in Hz scaled up by
+ * a factor of 256 to enable non-integer values to be returned.
+ * Ranging frequency corresponds to the time between each measurement.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint8_t) *p_frequency_x256: Contains the ranging frequency scaled
+ * to 256 x Hz.
+ * @return (uint8_t) status : 0 if ranging frequency is OK.
+ */
+uint8_t VL53L8CH::get_ranging_frequency_x256(VL53LMZ_Configuration *p_dev, uint16_t *p_frequency_x256)
+{
+  return vl53lmz_get_ranging_frequency_x256(p_dev, p_frequency_x256);
+}
+
+/**
+ * @brief This function sets a new ranging frequency in Hz scaled up by 256
+ * to enable non-integer values to be set.
+ * Ranging frequencycorresponds to the measurements frequency. This setting
+ * depends on the resolution, so please select your resolution before using
+ * this function.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint8_t) frequency_x256 : Contains the ranging frequency in Hz.
+ * - For 4x4, min and max allowed values are : [1*256;60*256]
+ * - For 8x8, min and max allowed values are : [1*256;15*256]
+ * @return (uint8_t) status : 0 if ranging frequency is OK, or 127 if the value
+ * is not correct.
+ */
+uint8_t VL53L8CH::set_ranging_frequency_x256(VL53LMZ_Configuration *p_dev, uint16_t frequency_x256)
+{
+  return vl53lmz_set_ranging_frequency_x256(p_dev, frequency_x256);
+}
+
+/**
+ * @brief This function is used to get the number of frames between 2 temperature
+ * compensation.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint32_t) *p_repeat_count : Number of frames before next temperature
+ * compensation. Set to 0 to disable the feature (default configuration).
+ */
+uint8_t VL53L8CH::get_VHV_repeat_count(VL53LMZ_Configuration *p_dev, uint32_t *p_repeat_count)
+{
+  return vl53lmz_get_VHV_repeat_count(p_dev, p_repeat_count);
+}
+
+/**
+ * @brief This function is used to set a periodic temperature compensation. By
+ * setting a repeat count different to 0 the firmware automatically runs a
+ * temperature calibration every N frames.
+ * default the repeat count is set to 0
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint32_t) repeat_count : Number of frames between temperature
+ * compensation. Set to 0 to disable the feature (default configuration).
+ */
+uint8_t VL53L8CH::set_VHV_repeat_count(VL53LMZ_Configuration *p_dev, uint32_t repeat_count)
+{
+  return vl53lmz_set_VHV_repeat_count(p_dev, repeat_count);
+}
 
 uint8_t VL53L8CH_io_write(void *handle, uint16_t RegisterAddress, uint8_t *p_values, uint32_t size)
 {
diff --git a/src/vl53l8ch.h b/src/vl53l8ch.h
index 16211b5..370eab7 100644
--- a/src/vl53l8ch.h
+++ b/src/vl53l8ch.h
@@ -117,6 +117,10 @@ class VL53L8CH {
     uint8_t cnh_send_config(VL53LMZ_Motion_Configuration *p_mi_config);
     uint8_t cnh_get_block_addresses(VL53LMZ_Motion_Configuration *p_mi_config, int32_t agg_id, cnh_data_buffer_t mi_persistent_array, int32_t **p_hist, int8_t  **p_hist_scaler, int32_t **p_ambient, int8_t **p_ambient_scaler);
     uint32_t cnh_get_ref_residual(cnh_data_buffer_t mi_persistent_array);
+    uint8_t get_ranging_frequency_x256(VL53LMZ_Configuration *p_dev, uint16_t *p_frequency_x256);
+    uint8_t set_ranging_frequency_x256(VL53LMZ_Configuration *p_dev, uint16_t p_frequency_x256);
+    uint8_t get_VHV_repeat_count(VL53LMZ_Configuration *p_dev, uint32_t *p_repeat_count);
+    uint8_t set_VHV_repeat_count(VL53LMZ_Configuration *p_dev, uint32_t p_repeat_count);
 
     /**
      * @brief Utility function to read data.
diff --git a/src/vl53lmz_api.h b/src/vl53lmz_api.h
index d27a4d7..55e087b 100644
--- a/src/vl53lmz_api.h
+++ b/src/vl53lmz_api.h
@@ -17,6 +17,7 @@
   #pragma anon_unions
 #endif
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -27,7 +28,7 @@ extern "C" {
  * @brief Current driver version.
  */
 
-#define VL53LMZ_API_REVISION      "VL53LMZ_2.0.10"
+#define VL53LMZ_API_REVISION      "VL53LMZ_2.0.16"
 
 
 /**
@@ -86,7 +87,7 @@ extern "C" {
  * - VL53LMZ_POWER_MODE_DEEP_SLEEP: This mode clears all memory, by consequence the firmware,
  * the configuration and the calibration are lost. It is recommended when the device sleeps during
  * a long time as it consumes a very low current consumption.
- * Both modes can be changed using function vl53l8ch_set_power_mode().
+ * Both modes can be changed using function vl53l8cx_set_power_mode().
  */
 
 #define VL53LMZ_POWER_MODE_SLEEP    ((uint8_t) 0U)
@@ -104,6 +105,7 @@ extern "C" {
 #define VL53LMZ_STATUS_CORRUPTED_FRAME    ((uint8_t) 2U)
 #define VL53LMZ_STATUS_LASER_SAFETY     ((uint8_t) 3U)
 #define VL53LMZ_STATUS_UNKNOWN_DEVICE   ((uint8_t) 4U)
+#define VL53LMZ_STATUS_FW_CHECKSUM_FAIL   ((uint8_t) 5U)
 #define VL53LMZ_MCU_ERROR         ((uint8_t) 66U)
 #define VL53LMZ_STATUS_INVALID_PARAM    ((uint8_t) 127U)
 #define VL53LMZ_STATUS_FUNC_NOT_AVAILABLE   ((uint8_t) 254U)
@@ -181,6 +183,7 @@ extern "C" {
 #define VL53LMZ_DCI_FW_NB_TARGET    ((uint16_t)0x5478U)
 #define VL53LMZ_DCI_RANGING_MODE    ((uint16_t)0xAD30U)
 #define VL53LMZ_DCI_DSS_CONFIG      ((uint16_t)0xAD38U)
+#define VL53LMZ_DCI_VHV_CONFIG      ((uint16_t)0xAD60U)
 #define VL53LMZ_DCI_TARGET_ORDER    ((uint16_t)0xAE64U)
 #define VL53LMZ_DCI_SHARPENER     ((uint16_t)0xAED8U)
 #define VL53LMZ_DCI_INTERNAL_CP     ((uint16_t)0xB39CU)
@@ -557,6 +560,36 @@ uint8_t vl53lmz_set_ranging_frequency_hz(
   VL53LMZ_Configuration *p_dev,
   uint8_t       frequency_hz);
 
+/**
+ * @brief This function gets the current ranging frequency in Hz scaled up by
+ * a factor of 256 to enable non-integer values to be returned.
+ * Ranging frequency corresponds to the time between each measurement.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint8_t) *p_frequency_x256: Contains the ranging frequency scaled
+ * to 256 x Hz.
+ * @return (uint8_t) status : 0 if ranging frequency is OK.
+ */
+uint8_t vl53lmz_get_ranging_frequency_x256(
+  VL53LMZ_Configuration       *p_dev,
+  uint16_t                    *p_frequency_x256);
+
+/**
+ * @brief This function sets a new ranging frequency in Hz scaled up by 256
+ * to enable non-integer values to be set.
+ * Ranging frequencycorresponds to the measurements frequency. This setting
+ * depends on the resolution, so please select your resolution before using
+ * this function.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint8_t) frequency_x256 : Contains the ranging frequency in Hz.
+ * - For 4x4, min and max allowed values are : [1*256;60*256]
+ * - For 8x8, min and max allowed values are : [1*256;15*256]
+ * @return (uint8_t) status : 0 if ranging frequency is OK, or 127 if the value
+ * is not correct.
+ */
+uint8_t vl53lmz_set_ranging_frequency_x256(
+  VL53LMZ_Configuration       *p_dev,
+  uint16_t                    frequency_x256);
+
 /**
  * @brief This function gets the current integration time in ms.
  * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
@@ -724,6 +757,29 @@ uint8_t vl53lmz_set_glare_filter_cfg(
   uint8_t         threshold_pc_x10,
   int16_t         max_range);
 
+/**
+ * @brief This function is used to get the number of frames between 2 temperature
+ * compensation.
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint32_t) *p_repeat_count : Number of frames before next temperature
+ * compensation. Set to 0 to disable the feature (default configuration).
+ */
+uint8_t vl53lmz_get_VHV_repeat_count(
+  VL53LMZ_Configuration *p_dev,
+  uint32_t *p_repeat_count);
+
+/**
+ * @brief This function is used to set a periodic temperature compensation. By
+ * setting a repeat count different to 0 the firmware automatically runs a
+ * temperature calibration every N frames.
+ * default the repeat count is set to 0
+ * @param (VL53LMZ_Configuration) *p_dev : VL53LMZ configuration structure.
+ * @param (uint32_t) repeat_count : Number of frames between temperature
+ * compensation. Set to 0 to disable the feature (default configuration).
+ */
+uint8_t vl53lmz_set_VHV_repeat_count(
+  VL53LMZ_Configuration *p_dev,
+  uint32_t repeat_count);
 
 /**
  * @brief This function can be used to read 'extra data' from DCI. Using a known
diff --git a/src/vl53lmz_buffers.h b/src/vl53lmz_buffers.h
index 0dad098..0576ce1 100644
--- a/src/vl53lmz_buffers.h
+++ b/src/vl53lmz_buffers.h
@@ -1,3 +1,4 @@
+
 /*
   ******************************************************************************
   *
@@ -15,6 +16,7 @@
 #ifndef VL53LMZ_BUFFERS_H_
 #define VL53LMZ_BUFFERS_H_
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -32,7 +34,7 @@ extern "C" {
 #endif
 
 /**
- * @brief This buffer contains the VL53LMZ firmware (MM1.7)
+ * @brief This buffer contains the VL53LMZ firmware (MM1.8)
  */
 
 const uint8_t VL53LMZ_FIRMWARE[] = {
@@ -40,21 +42,21 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x00, 0x03, 0x08,
   0xe0, 0x00, 0x0a, 0xc8,
   0xe0, 0x00, 0x05, 0x08,
-  0xe0, 0x64, 0x08, 0x68,
+  0xe0, 0x64, 0x08, 0x48,
   0xe0, 0x00, 0x0a, 0x88,
   0xe0, 0x00, 0x0a, 0x88,
   0xe0, 0x00, 0x0a, 0x88,
   0xe0, 0x00, 0x0a, 0x88,
-  0xe0, 0x64, 0x2e, 0x48,
-  0xe0, 0x64, 0x32, 0x08,
-  0xe0, 0x64, 0x35, 0x68,
-  0xe0, 0x64, 0x3b, 0xa8,
-  0xe0, 0x68, 0x04, 0x88,
-  0xe0, 0x68, 0x17, 0x88,
-  0xe0, 0x68, 0x1b, 0x68,
-  0xe0, 0x68, 0x1e, 0xe8,
-  0xe0, 0x68, 0x25, 0x48,
-  0xe0, 0x68, 0x28, 0x68,
+  0xe0, 0x64, 0x2e, 0x28,
+  0xe0, 0x64, 0x31, 0xe8,
+  0xe0, 0x64, 0x35, 0x48,
+  0xe0, 0x64, 0x3b, 0x88,
+  0xe0, 0x68, 0x04, 0x68,
+  0xe0, 0x68, 0x17, 0x68,
+  0xe0, 0x68, 0x1b, 0x48,
+  0xe0, 0x68, 0x1e, 0xc8,
+  0xe0, 0x68, 0x25, 0x28,
+  0xe0, 0x68, 0x28, 0x48,
   0xe0, 0x00, 0x09, 0xe8,
   0xe0, 0x00, 0x09, 0xc8,
   0xe0, 0x00, 0x09, 0xa8,
@@ -96,15 +98,15 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x1c, 0x8c, 0xd1, 0x67,
   0xe3, 0x6b, 0xe4, 0x04,
   0xe5, 0x6b, 0x8e, 0x05,
-  0x80, 0x64, 0x03, 0xa8,
-  0x04, 0xf8, 0xe7, 0x6b,
+  0x80, 0x64, 0x03, 0x88,
+  0x04, 0xd8, 0xe7, 0x6b,
   0xe9, 0x6b, 0x80, 0x64,
   0xeb, 0x6b, 0x8a, 0xc5,
-  0x80, 0x64, 0x06, 0x28,
-  0x0a, 0x78, 0xed, 0x6b,
+  0x80, 0x64, 0x06, 0x08,
+  0x0a, 0x58, 0xed, 0x6b,
   0xf1, 0x6b, 0x80, 0x64,
-  0x80, 0x64, 0x07, 0x48,
-  0x08, 0x98, 0xf3, 0x6b,
+  0x80, 0x64, 0x07, 0x28,
+  0x08, 0x78, 0xf3, 0x6b,
   0xf5, 0x6b, 0x80, 0x64,
   0xf7, 0x6b, 0x8a, 0xc5,
   0xf9, 0x6b, 0x8c, 0x05,
@@ -112,7 +114,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x0a, 0x8a, 0x45,
   0x8a, 0x65, 0xe4, 0xb4,
   0xe4, 0xb8, 0x0c, 0x0a,
-  0x0a, 0x98, 0x84, 0x45,
+  0x0a, 0x78, 0x84, 0x45,
   0x40, 0x06, 0xe0, 0x64,
   0x40, 0x4a, 0xfc, 0x12,
   0x80, 0xd5, 0xe0, 0xd0,
@@ -406,8 +408,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x68, 0x04, 0x57, 0xc8,
   0xc1, 0xc3, 0x8c, 0x0b,
   0xfa, 0x04, 0x04, 0x7c,
-  0x74, 0xa9, 0x46, 0x8e,
-  0x49, 0x4e, 0xc0, 0x10,
+  0x74, 0xa9, 0x46, 0x4e,
+  0x49, 0x0e, 0xc0, 0x10,
   0xc0, 0x10, 0x74, 0xa9,
   0x88, 0x25, 0x89, 0x3d,
   0xcd, 0x14, 0xcd, 0x04,
@@ -433,8 +435,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x31, 0x81, 0x21,
   0xe8, 0x04, 0x4a, 0x88,
   0x8c, 0x45, 0xa1, 0x0b,
-  0x74, 0xa9, 0x07, 0x0e,
-  0x48, 0x8e, 0xc0, 0x10,
+  0x74, 0xa9, 0x06, 0xce,
+  0x48, 0x4e, 0xc0, 0x10,
   0xc0, 0x10, 0x74, 0xa9,
   0x8a, 0x45, 0x89, 0x3d,
   0xcd, 0x14, 0xcd, 0x04,
@@ -472,7 +474,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x08, 0xe1, 0xa4,
   0x8b, 0x04, 0xdc, 0x38,
   0xfe, 0x24, 0x89, 0x14,
-  0xe8, 0x6c, 0x65, 0x88,
+  0xe8, 0x6c, 0x65, 0x68,
   0xe1, 0xa4, 0x0c, 0x46,
   0xe1, 0xa4, 0x0e, 0x46,
   0x82, 0x45, 0x8f, 0x6d,
@@ -9401,7 +9403,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x73, 0xd8, 0x81, 0x11,
   0x81, 0x81, 0x6f, 0xbc,
   0x60, 0x00, 0x42, 0x76,
-  0x62, 0xb8, 0x8c, 0x0b,
+  0x62, 0x98, 0x8c, 0x0b,
   0x7e, 0xd8, 0xe8, 0x24,
   0x8c, 0x0b, 0x68, 0x0c,
   0xe1, 0x3c, 0x00, 0x86,
@@ -9413,7 +9415,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x04, 0xe1, 0x44,
   0x40, 0x46, 0x00, 0x86,
   0x80, 0x04, 0xe1, 0x44,
-  0x40, 0xc6, 0x00, 0x86,
+  0x40, 0x46, 0x00, 0x86,
   0x0c, 0x2b, 0xef, 0xdc,
   0xc0, 0x15, 0x6e, 0x09,
   0x73, 0xf5, 0x42, 0x20,
@@ -9462,11 +9464,11 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x68, 0x00, 0x5f, 0xa8,
   0x42, 0x86, 0x8c, 0x0b,
   0x8c, 0x0b, 0x60, 0x00,
-  0xe8, 0x24, 0x5b, 0x28,
+  0xe8, 0x24, 0x5b, 0x08,
   0xef, 0xfc, 0x76, 0xe8,
   0xfa, 0x00, 0x04, 0x0c,
   0x8b, 0x11, 0x00, 0x6b,
-  0xe8, 0x28, 0x56, 0xa8,
+  0xe8, 0x28, 0x56, 0x88,
   0x61, 0x24, 0x00, 0xc6,
   0xe0, 0x00, 0x42, 0x06,
   0x4c, 0x11, 0x80, 0x04,
@@ -9475,7 +9477,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x3c, 0x00, 0x86,
   0x80, 0x18, 0x80, 0x04,
   0xf1, 0xfc, 0x42, 0x10,
-  0x40, 0x86, 0x00, 0x16,
+  0x40, 0x06, 0x00, 0x16,
   0x80, 0x08, 0xef, 0xdc,
   0xe0, 0x80, 0x40, 0x0a,
   0x0e, 0x09, 0x0c, 0x0b,
@@ -9503,15 +9505,15 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x86, 0x65, 0xb3, 0x0b,
   0x86, 0xb5, 0xb5, 0x0b,
   0x0c, 0x0c, 0x8c, 0x0b,
-  0x20, 0x78, 0xf2, 0x00,
+  0x20, 0x58, 0xf2, 0x00,
   0x8c, 0x0b, 0xe0, 0x58,
   0xf2, 0x00, 0x0c, 0x0c,
-  0xe0, 0x40, 0x35, 0x68,
+  0xe0, 0x40, 0x35, 0x48,
   0x0c, 0x0c, 0x8c, 0x0b,
-  0x08, 0x58, 0xf2, 0x00,
+  0x08, 0x38, 0xf2, 0x00,
   0x8c, 0x0b, 0xe0, 0x54,
   0xf2, 0x00, 0x0c, 0x0c,
-  0xe0, 0x4c, 0x10, 0xe8,
+  0xe0, 0x4c, 0x10, 0xc8,
   0x0c, 0x0c, 0x8c, 0x0b,
   0x85, 0xb5, 0xf2, 0x00,
   0x0c, 0x0c, 0x8c, 0x0b,
@@ -9520,7 +9522,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xdd, 0x93, 0xf2, 0x00,
   0xfa, 0x00, 0x04, 0x0c,
   0x81, 0x11, 0x01, 0x01,
-  0x68, 0x20, 0x7d, 0xc8,
+  0x68, 0x20, 0x7d, 0xa8,
   0x03, 0x46, 0x81, 0x61,
   0x83, 0x31, 0x61, 0x4c,
   0x08, 0x36, 0x84, 0x24,
@@ -9530,7 +9532,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x84, 0x14, 0x87, 0x21,
   0x83, 0x11, 0x04, 0x26,
   0xf2, 0x00, 0x0c, 0x0c,
-  0xe0, 0x20, 0x3c, 0x88,
+  0xe0, 0x20, 0x3c, 0x68,
   0x61, 0x14, 0x40, 0xc6,
   0x80, 0x04, 0x83, 0x11,
   0xc1, 0x83, 0x80, 0x16,
@@ -9544,8 +9546,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x66, 0x82, 0x25,
   0x4c, 0x01, 0xe0, 0x00,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x41, 0x98, 0x8c, 0x0b,
-  0x41, 0x18, 0xe8, 0x50,
+  0x41, 0x78, 0x8c, 0x0b,
+  0x40, 0xf8, 0xe8, 0x50,
   0x8c, 0x0b, 0x68, 0x18,
   0x61, 0xd1, 0x0c, 0x09,
   0x80, 0x7b, 0x40, 0x15,
@@ -9563,13 +9565,13 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8c, 0x0b, 0x40, 0x2b,
   0x68, 0x0c, 0x70, 0x48,
   0xa1, 0x0b, 0x8e, 0x1b,
-  0x47, 0xd8, 0x98, 0x75,
+  0x47, 0xb8, 0x98, 0x75,
   0x8c, 0x0b, 0x68, 0x44,
   0x6c, 0x21, 0x0c, 0x09,
   0x80, 0x7b, 0x40, 0x2b,
   0x88, 0x55, 0xb3, 0x0b,
   0x92, 0xd5, 0xa1, 0x7b,
-  0x68, 0x3c, 0x72, 0xe8,
+  0x68, 0x3c, 0x72, 0xc8,
   0x00, 0x7b, 0x8c, 0x0b,
   0xe1, 0x34, 0x41, 0x06,
   0x02, 0x96, 0x00, 0x04,
@@ -9716,7 +9718,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x26, 0x00, 0x6b,
   0x4c, 0x01, 0xe0, 0x0c,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x65, 0x38, 0x81, 0x01,
+  0x65, 0x18, 0x81, 0x01,
   0x81, 0x11, 0x68, 0x20,
   0x6f, 0xa9, 0x0c, 0x15,
   0x25, 0x1b, 0xc0, 0x0b,
@@ -9725,12 +9727,12 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x42, 0x4a, 0x88, 0x18,
   0x80, 0xc5, 0xe0, 0x80,
   0x0c, 0x0c, 0x83, 0x11,
-  0x24, 0x18, 0xf2, 0xfc,
+  0x23, 0xf8, 0xf2, 0xfc,
   0x3e, 0x0e, 0xe0, 0x20,
   0x88, 0x18, 0x8c, 0x0b,
   0xf3, 0xf8, 0x42, 0x10,
   0x02, 0x86, 0x08, 0x16,
-  0x75, 0x98, 0xe0, 0x0c,
+  0x75, 0x78, 0xe0, 0x0c,
   0x81, 0x21, 0x68, 0x50,
   0x61, 0x44, 0x10, 0xc6,
   0xe1, 0x48, 0x53, 0x86,
@@ -9756,12 +9758,12 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf8, 0x35, 0xa1, 0x0b,
   0x83, 0x11, 0x3e, 0x04,
   0xf2, 0xfc, 0x0c, 0x0c,
-  0xe0, 0x20, 0x20, 0x48,
+  0xe0, 0x20, 0x20, 0x28,
   0xfa, 0xfc, 0x04, 0x0c,
   0x00, 0x36, 0x00, 0x7b,
   0x4e, 0x01, 0xe0, 0x0c,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x5f, 0x98, 0x81, 0x01,
+  0x5f, 0x78, 0x81, 0x01,
   0x81, 0x11, 0x68, 0x20,
   0x3e, 0x0e, 0x81, 0x81,
   0xe1, 0x24, 0x01, 0xc6,
@@ -9769,10 +9771,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x86, 0xe1, 0x24,
   0x80, 0x64, 0xa8, 0x04,
   0x8e, 0x0b, 0x00, 0x14,
-  0xe8, 0x20, 0x74, 0xc8,
+  0xe8, 0x20, 0x74, 0xa8,
   0x43, 0xa6, 0x03, 0x91,
   0x03, 0x21, 0xe0, 0x0c,
-  0x70, 0x58, 0x8e, 0x0b,
+  0x70, 0x38, 0x8e, 0x0b,
   0x41, 0x86, 0xe8, 0x50,
   0x80, 0x14, 0xe1, 0x14,
   0x03, 0x46, 0x04, 0x8c,
@@ -9786,13 +9788,13 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x02, 0x86, 0x04, 0x96,
   0x80, 0x04, 0xe0, 0x0c,
   0x8e, 0x0b, 0x00, 0x9c,
-  0xe8, 0x50, 0x6e, 0xa8,
+  0xe8, 0x50, 0x6e, 0x88,
   0x61, 0x24, 0x01, 0xc6,
   0x80, 0x04, 0xa9, 0x11,
   0x8e, 0x0b, 0x00, 0x96,
-  0xe8, 0x20, 0x72, 0x28,
+  0xe8, 0x20, 0x72, 0x08,
   0x60, 0x0c, 0x02, 0x86,
-  0x6d, 0xd8, 0x81, 0x21,
+  0x6d, 0xb8, 0x81, 0x21,
   0x8e, 0x0b, 0x68, 0x50,
   0xe1, 0x44, 0x00, 0xc6,
   0x80, 0x08, 0x80, 0x04,
@@ -9822,9 +9824,9 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x04, 0xa8, 0x04,
   0xf4, 0x45, 0x81, 0x6b,
   0x8e, 0x0b, 0x2b, 0x11,
-  0xe8, 0x20, 0x6e, 0x28,
+  0xe8, 0x20, 0x6e, 0x08,
   0x00, 0x14, 0xa8, 0x04,
-  0x6d, 0xd8, 0x8e, 0x0b,
+  0x6d, 0xb8, 0x8e, 0x0b,
   0x01, 0xc6, 0xe8, 0x20,
   0x80, 0x04, 0xe1, 0x24,
   0x41, 0x46, 0x00, 0x86,
@@ -9837,7 +9839,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x16, 0xf3, 0xf4,
   0xbe, 0x04, 0x83, 0x11,
   0xf2, 0xfc, 0x0c, 0x0c,
-  0xe0, 0x20, 0x16, 0x28,
+  0xe0, 0x20, 0x16, 0x08,
   0x70, 0x01, 0x00, 0x06,
   0x02, 0x06, 0x40, 0x20,
   0xff, 0xc0, 0x60, 0x01,
@@ -9845,7 +9847,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xfa, 0x0c, 0x04, 0x0c,
   0x80, 0x8b, 0x02, 0x7b,
   0x81, 0x01, 0x04, 0x6b,
-  0x68, 0x20, 0x55, 0x28,
+  0x68, 0x20, 0x55, 0x08,
   0x43, 0x86, 0x81, 0x11,
   0x49, 0xc6, 0x61, 0x48,
   0x04, 0x24, 0xe1, 0x48,
@@ -9869,7 +9871,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa4, 0x3f, 0x88, 0x3f,
   0x83, 0x11, 0x04, 0x3e,
   0xf2, 0x0c, 0x0c, 0x0c,
-  0xe0, 0x20, 0x12, 0x28,
+  0xe0, 0x20, 0x12, 0x08,
   0xfa, 0xfc, 0x04, 0x0c,
   0x50, 0x06, 0x00, 0x6b,
   0x0c, 0x09, 0xe1, 0xa0,
@@ -9897,7 +9899,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x00, 0x13, 0x68,
   0xc1, 0x4c, 0x17, 0xc6,
   0x02, 0x56, 0x04, 0xab,
-  0x6e, 0xf8, 0xe0, 0x10,
+  0x6e, 0xd8, 0xe0, 0x10,
   0x8c, 0x0b, 0x68, 0x20,
   0x61, 0x98, 0x05, 0x46,
   0xfb, 0x80, 0x00, 0x74,
@@ -9931,7 +9933,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x1f, 0x15, 0xf6, 0x15,
   0x02, 0x56, 0x94, 0x2b,
   0x8c, 0x0b, 0x60, 0x80,
-  0x68, 0x20, 0x6a, 0xc8,
+  0x68, 0x20, 0x6a, 0xa8,
   0x0c, 0x0b, 0x84, 0x7b,
   0x40, 0x15, 0x6e, 0x09,
   0xe1, 0x4c, 0x17, 0xc6,
@@ -9942,7 +9944,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xef, 0xf8, 0x7c, 0x08,
   0x8e, 0x2b, 0x1b, 0xa5,
   0x02, 0x56, 0x3e, 0x2e,
-  0x69, 0x58, 0xe0, 0x20,
+  0x69, 0x38, 0xe0, 0x20,
   0x8c, 0x0b, 0x68, 0x20,
   0x7b, 0x80, 0x00, 0x74,
   0x72, 0xfc, 0x43, 0xc6,
@@ -9979,7 +9981,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf4, 0x95, 0xbf, 0x4b,
   0x91, 0xf5, 0xbe, 0x24,
   0x60, 0x40, 0x02, 0x56,
-  0x64, 0xb8, 0x8c, 0x0b,
+  0x64, 0x98, 0x8c, 0x0b,
   0x4c, 0x91, 0xe8, 0x20,
   0x40, 0x38, 0x64, 0xc5,
   0x4a, 0x58, 0x8c, 0x0b,
@@ -10207,7 +10209,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x73, 0xfd, 0x40, 0x00,
   0x4c, 0x03, 0xc0, 0xfd,
   0x40, 0x15, 0x6e, 0x09,
-  0x67, 0xd8, 0x81, 0x01,
+  0x67, 0xb8, 0x81, 0x01,
   0x7e, 0x0e, 0xe8, 0x1c,
   0xe1, 0x48, 0x41, 0x86,
   0x41, 0xc6, 0x00, 0x14,
@@ -10293,7 +10295,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa2, 0x0f, 0xa4, 0x0f,
   0x68, 0x01, 0x4c, 0x05,
   0x8c, 0x0b, 0x40, 0x02,
-  0xe8, 0x10, 0x4a, 0xe8,
+  0xe8, 0x10, 0x4a, 0xc8,
   0xe1, 0x48, 0x41, 0x86,
   0x80, 0x18, 0x80, 0x04,
   0xe0, 0x90, 0x42, 0x0a,
@@ -10303,7 +10305,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa2, 0x2f, 0xf3, 0x7c,
   0xf8, 0x80, 0x42, 0x20,
   0x7e, 0x04, 0x80, 0x16,
-  0x5b, 0xd8, 0x83, 0x11,
+  0x5b, 0xb8, 0x83, 0x11,
   0x01, 0x86, 0xe8, 0x1c,
   0x80, 0x04, 0xe1, 0x98,
   0x0c, 0x0b, 0xa3, 0x0b,
@@ -10391,7 +10393,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc1, 0xc3, 0xdd, 0x93,
   0xfa, 0x84, 0x04, 0x0c,
   0x81, 0x01, 0x00, 0x6b,
-  0x68, 0x1c, 0x50, 0xe8,
+  0x68, 0x1c, 0x50, 0xc8,
   0x0c, 0x1b, 0x81, 0x11,
   0x40, 0x0a, 0x68, 0x91,
   0x00, 0x60, 0x80, 0x7b,
@@ -10408,14 +10410,14 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x83, 0x01, 0x00, 0x16,
   0x6f, 0xf8, 0x79, 0x88,
   0x50, 0xd8, 0x81, 0x11,
-  0x7d, 0x38, 0xef, 0xf8,
+  0x7d, 0x18, 0xef, 0xf8,
   0x8c, 0x0b, 0x68, 0x0c,
   0x61, 0x8d, 0x0c, 0x0b,
   0x83, 0x11, 0x40, 0x1c,
   0x4c, 0x03, 0x82, 0x01,
   0x40, 0x1c, 0x61, 0x8d,
   0x0c, 0x0c, 0x8e, 0x0b,
-  0x0d, 0xd8, 0xf2, 0x84,
+  0x0d, 0xb8, 0xf2, 0x84,
   0xc1, 0xc3, 0xe0, 0x1c,
   0xfa, 0x00, 0x04, 0x0c,
   0x43, 0x86, 0x02, 0x6b,
@@ -10454,13 +10456,13 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8c, 0x0b, 0x03, 0x11,
   0xe8, 0x00, 0x4e, 0x28,
   0x80, 0xd5, 0xa1, 0x0b,
-  0x68, 0x48, 0x59, 0xa8,
+  0x68, 0x48, 0x59, 0x88,
   0xa1, 0x0b, 0x8c, 0x0b,
   0x0c, 0x0c, 0x80, 0x85,
   0xdd, 0x93, 0xf2, 0x0c,
   0x45, 0x76, 0x01, 0x11,
   0x09, 0x31, 0xe0, 0x00,
-  0x5d, 0x78, 0x8c, 0x0b,
+  0x5d, 0x58, 0x8c, 0x0b,
   0xa3, 0x8b, 0xe8, 0x48,
   0xa1, 0x0b, 0xfc, 0xb5,
   0x0c, 0x0b, 0xfc, 0x75,
@@ -10572,7 +10574,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x92, 0x95, 0xa3, 0x1b,
   0x65, 0x41, 0x02, 0x60,
   0x8c, 0x0b, 0x40, 0xb1,
-  0xe8, 0x48, 0x63, 0x08,
+  0xe8, 0x48, 0x62, 0xe8,
   0x90, 0x95, 0xa1, 0x0b,
   0x4c, 0x01, 0x83, 0x01,
   0xc0, 0x2c, 0x65, 0x39,
@@ -10603,7 +10605,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x84, 0x5e, 0x01,
   0x60, 0x8c, 0x5e, 0x01,
   0x5e, 0x21, 0x8c, 0x0b,
-  0x5f, 0x18, 0xe0, 0x88,
+  0x5e, 0xf8, 0xe0, 0x88,
   0xa1, 0x0b, 0xe8, 0x48,
   0x4c, 0x71, 0x80, 0xb5,
   0xc0, 0x2c, 0x65, 0x39,
@@ -10614,7 +10616,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x6b, 0x02, 0x7b,
   0x64, 0x90, 0x02, 0xf0,
   0xe4, 0x80, 0x04, 0xf0,
-  0xe8, 0x10, 0x49, 0x88,
+  0xe8, 0x10, 0x49, 0x68,
   0x60, 0x90, 0x1e, 0x89,
   0xe0, 0x04, 0x0e, 0x2a,
   0xe0, 0x80, 0x1e, 0x79,
@@ -10767,7 +10769,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x7a, 0x80, 0x02, 0x94,
   0xfa, 0x80, 0x04, 0x74,
   0x64, 0x20, 0x06, 0xf0,
-  0x49, 0xb8, 0x8c, 0x0b,
+  0x49, 0x98, 0x8c, 0x0b,
   0x80, 0xbb, 0xe8, 0x48,
   0x1e, 0xf0, 0x16, 0x0b,
   0x0c, 0x0c, 0xe6, 0x50,
@@ -10824,7 +10826,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x0b, 0xe0, 0x84,
   0x80, 0x13, 0x7c, 0x08,
   0xe5, 0x00, 0x02, 0x19,
-  0x68, 0x4c, 0x68, 0x48,
+  0x68, 0x4c, 0x68, 0x28,
   0xd0, 0x07, 0x82, 0x11,
   0xf2, 0x00, 0x08, 0x4c,
   0xc1, 0xc3, 0xdd, 0x93,
@@ -10959,7 +10961,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x45, 0x2a, 0x81, 0x55,
   0xec, 0x04, 0x10, 0x80,
   0xa1, 0x8b, 0xc1, 0x2c,
-  0x77, 0x78, 0xfe, 0x75,
+  0x77, 0x58, 0xfe, 0x75,
   0x94, 0x0b, 0x68, 0x44,
   0x0c, 0x0c, 0xb8, 0xf1,
   0xdd, 0x93, 0xf2, 0x7c,
@@ -10976,7 +10978,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xfa, 0x7c, 0x04, 0x0c,
   0xec, 0xd0, 0x1e, 0xf0,
   0x02, 0xf0, 0x00, 0x9b,
-  0x5c, 0x38, 0xe4, 0xc0,
+  0x5c, 0x18, 0xe4, 0xc0,
   0x04, 0xf0, 0x68, 0x0c,
   0x12, 0x39, 0xe4, 0xb0,
   0xc0, 0x2b, 0x6c, 0x49,
@@ -11005,7 +11007,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x26, 0x64, 0xd1,
   0xe4, 0xa0, 0x02, 0xf0,
   0x64, 0xf1, 0x52, 0xa1,
-  0x67, 0xf8, 0xc0, 0x26,
+  0x67, 0xd8, 0xc0, 0x26,
   0x80, 0x7b, 0xe8, 0x0c,
   0xa6, 0x55, 0xa1, 0x7b,
   0x06, 0x64, 0x45, 0xb7,
@@ -11094,9 +11096,9 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa3, 0x0b, 0xc0, 0x2b,
   0x02, 0xf0, 0x8a, 0x85,
   0x8c, 0x0b, 0x64, 0x20,
-  0xe8, 0x0c, 0x5d, 0xa8,
+  0xe8, 0x0c, 0x5d, 0x88,
   0x88, 0xd5, 0xa1, 0x0b,
-  0x6f, 0xdc, 0x40, 0x86,
+  0x6f, 0xdc, 0x40, 0x06,
   0x80, 0x08, 0x81, 0x91,
   0xe0, 0x80, 0x40, 0x4a,
   0x04, 0xf1, 0x00, 0x60,
@@ -11344,7 +11346,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8d, 0x2b, 0x82, 0x23,
   0x80, 0x00, 0x0e, 0x19,
   0x80, 0x00, 0x10, 0x0b,
-  0x08, 0x48, 0x67, 0x48,
+  0x08, 0x48, 0x67, 0x28,
   0x84, 0x04, 0x02, 0x10,
   0x6c, 0x04, 0x12, 0x90,
   0x84, 0x81, 0x82, 0x71,
@@ -11353,7 +11355,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xdd, 0x93, 0xf2, 0x3c,
   0xfa, 0x00, 0x04, 0x0c,
   0x02, 0x06, 0x00, 0x6b,
-  0x5e, 0x18, 0xe2, 0x80,
+  0x5d, 0xf8, 0xe2, 0x80,
   0x43, 0xf6, 0xe8, 0x48,
   0x05, 0x86, 0x60, 0x0c,
   0x7b, 0x98, 0xe0, 0x10,
@@ -11361,7 +11363,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x45, 0x76, 0x01, 0x11,
   0x0c, 0x0b, 0xe0, 0x00,
   0x0c, 0x0c, 0x8c, 0x3b,
-  0x3e, 0x58, 0xf2, 0x00,
+  0x3e, 0x38, 0xf2, 0x00,
   0xc1, 0xc3, 0xe0, 0x40,
   0xfa, 0x9c, 0x04, 0x0c,
   0x40, 0x96, 0x00, 0x6b,
@@ -11369,7 +11371,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0x02, 0x06, 0x82, 0x7b,
   0x8c, 0x0b, 0x62, 0x80,
-  0xe8, 0x48, 0x5c, 0x28,
+  0xe8, 0x48, 0x5c, 0x08,
   0xe4, 0x40, 0x0e, 0x8a,
   0x0c, 0x29, 0x82, 0xd5,
   0x40, 0x2b, 0x6c, 0x1d,
@@ -11392,7 +11394,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x40, 0x02, 0x0a,
   0x01, 0x11, 0xfc, 0xb5,
   0x0c, 0x0b, 0x9f, 0x21,
-  0x67, 0xd8, 0x8c, 0x3b,
+  0x67, 0xb8, 0x8c, 0x3b,
   0x80, 0x8b, 0xe8, 0x40,
   0x84, 0x55, 0xa1, 0x8b,
   0x6a, 0xa9, 0x0c, 0x09,
@@ -11407,7 +11409,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf2, 0x9c, 0x0c, 0x0c,
   0x0c, 0x0b, 0xdd, 0x93,
   0x0c, 0x0c, 0x8c, 0x1b,
-  0x1c, 0x98, 0xf2, 0x9c,
+  0x1c, 0x78, 0xf2, 0x9c,
   0xc1, 0xc3, 0xe0, 0x3c,
   0xfa, 0x00, 0x04, 0x0c,
   0x61, 0x00, 0x4c, 0x46,
@@ -11419,7 +11421,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x84, 0x28, 0x98, 0x14,
   0xf3, 0xf8, 0x44, 0x20,
   0x43, 0x46, 0x04, 0x26,
-  0x62, 0x78, 0xe0, 0x1c,
+  0x62, 0x58, 0xe0, 0x1c,
   0x83, 0x21, 0x68, 0x44,
   0x80, 0x18, 0x98, 0x04,
   0xf3, 0xf4, 0x42, 0x10,
@@ -11443,17 +11445,17 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc1, 0xc3, 0xff, 0xf0,
   0xfa, 0x3c, 0x04, 0x0c,
   0x81, 0x01, 0x00, 0x6b,
-  0x68, 0x14, 0x4d, 0x68,
+  0x68, 0x14, 0x4d, 0x48,
   0x81, 0x81, 0x81, 0x11,
-  0x68, 0x28, 0x6f, 0xe8,
+  0x68, 0x28, 0x6f, 0xc8,
   0x12, 0x86, 0x80, 0x7b,
   0xa4, 0x04, 0xe1, 0x3c,
   0x42, 0x10, 0x80, 0x18,
   0x80, 0x16, 0xf3, 0xbc,
-  0xe8, 0x30, 0x72, 0xe8,
+  0xe8, 0x30, 0x72, 0xc8,
   0x95, 0x11, 0x03, 0xa1,
   0x8c, 0x0b, 0x03, 0x21,
-  0xe8, 0x44, 0x5e, 0x48,
+  0xe8, 0x44, 0x5e, 0x28,
   0xe1, 0x10, 0x41, 0x46,
   0x84, 0x86, 0x80, 0x14,
   0x80, 0xa6, 0x80, 0x04,
@@ -11481,7 +11483,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x18, 0x00, 0xc6,
   0x00, 0x86, 0x80, 0x04,
   0x0c, 0x0c, 0x8e, 0x0b,
-  0x08, 0x98, 0xf2, 0x3c,
+  0x08, 0x78, 0xf2, 0x3c,
   0xc1, 0xc3, 0xe0, 0x14,
   0xfa, 0x3c, 0x04, 0x0c,
   0x81, 0x61, 0x02, 0xab,
@@ -11491,10 +11493,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6c, 0x1d, 0x4e, 0x01,
   0x84, 0x9b, 0x40, 0x2b,
   0x50, 0x04, 0x4c, 0x60,
-  0x47, 0x58, 0x81, 0x01,
+  0x47, 0x38, 0x81, 0x01,
   0x81, 0x11, 0x68, 0x14,
   0x42, 0x56, 0x00, 0x8b,
-  0x5d, 0x18, 0xe0, 0x00,
+  0x5c, 0xf8, 0xe0, 0x00,
   0x8e, 0x0b, 0x68, 0x14,
   0x01, 0x06, 0x21, 0x6b,
   0x4e, 0x01, 0xe0, 0x04,
@@ -11526,11 +11528,11 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x68, 0x00, 0x41, 0x68,
   0x42, 0x96, 0x8e, 0x0b,
   0x8e, 0x0b, 0x60, 0x00,
-  0xe8, 0x14, 0x59, 0x28,
+  0xe8, 0x14, 0x59, 0x08,
   0x60, 0x00, 0x42, 0x66,
-  0x58, 0xd8, 0x8e, 0x0b,
+  0x58, 0xb8, 0x8e, 0x0b,
   0x03, 0x11, 0xe8, 0x14,
-  0x42, 0x78, 0x90, 0x0b,
+  0x42, 0x58, 0x90, 0x0b,
   0x8c, 0x0b, 0xe8, 0x14,
   0xf2, 0x3c, 0x0c, 0x0c,
   0xc1, 0xc3, 0xdd, 0x93,
@@ -11542,16 +11544,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x15, 0x6e, 0x09,
   0x4c, 0x01, 0x81, 0x01,
   0xc0, 0x2b, 0x64, 0xd5,
-  0xe8, 0x00, 0x7d, 0x88,
+  0xe8, 0x00, 0x7d, 0x68,
   0x8c, 0x0b, 0x00, 0x7b,
-  0xe8, 0x18, 0x5e, 0x68,
-  0x68, 0x00, 0x7c, 0xa8,
-  0x48, 0x18, 0x8c, 0x0b,
+  0xe8, 0x18, 0x5e, 0x48,
+  0x68, 0x00, 0x7c, 0x88,
+  0x47, 0xf8, 0x8c, 0x0b,
   0xa1, 0x7b, 0xe8, 0x0c,
-  0x4a, 0x18, 0x86, 0x25,
+  0x49, 0xf8, 0x86, 0x25,
   0x8c, 0x0b, 0x68, 0x00,
   0x68, 0x00, 0x41, 0x88,
-  0x40, 0x46, 0x8c, 0x0b,
+  0x01, 0xc6, 0x8c, 0x0b,
   0x42, 0x46, 0x6f, 0xdc,
   0x42, 0x1e, 0xe0, 0x04,
   0x02, 0x16, 0x83, 0x11,
@@ -11559,76 +11561,75 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf8, 0x08, 0x40, 0x15,
   0xef, 0xf0, 0x69, 0x28,
   0x0c, 0x0c, 0x8c, 0x0b,
-  0x0a, 0x98, 0xf2, 0x84,
+  0x0a, 0x78, 0xf2, 0x84,
   0x0c, 0x0c, 0xe0, 0x0c,
   0xdd, 0x93, 0xf2, 0x84,
   0x63, 0x49, 0x00, 0x19,
-  0x81, 0x21, 0x40, 0x2d,
-  0x6e, 0x51, 0x40, 0x21,
-  0xa1, 0x31, 0x40, 0x2c,
-  0x68, 0x09, 0x40, 0x23,
-  0x40, 0x23, 0xc0, 0x0a,
-  0x40, 0x0a, 0x68, 0x0d,
-  0x40, 0x25, 0xe0, 0x19,
-  0x40, 0x0a, 0x61, 0x1d,
-  0x40, 0x21, 0xaf, 0x21,
-  0x40, 0x28, 0x64, 0x91,
-  0xe0, 0x0c, 0x45, 0xf6,
-  0x67, 0xc9, 0x40, 0x21,
-  0x04, 0x06, 0x40, 0x2d,
-  0x40, 0x23, 0xe0, 0x08,
-  0x40, 0x13, 0x69, 0x85,
-  0x40, 0x11, 0x91, 0x21,
+  0x06, 0x56, 0x40, 0x2d,
+  0xc0, 0x01, 0x60, 0x01,
+  0x64, 0x01, 0x40, 0x35,
+  0x83, 0x31, 0x40, 0x05,
+  0x68, 0x15, 0x40, 0x33,
+  0x81, 0x21, 0x40, 0x0a,
+  0x65, 0x45, 0x40, 0x31,
+  0x07, 0x06, 0x40, 0x22,
+  0x40, 0x31, 0xe0, 0x08,
+  0x40, 0x1b, 0x65, 0x6d,
+  0x40, 0x31, 0xe0, 0x19,
+  0x40, 0x22, 0x65, 0x4d,
+  0x40, 0x31, 0xa1, 0x41,
+  0x40, 0x28, 0x64, 0x89,
+  0x40, 0x11, 0xaf, 0x31,
   0x40, 0x2d, 0x63, 0x49,
   0x60, 0x11, 0x02, 0x26,
-  0x40, 0x21, 0xc0, 0xc0,
-  0x40, 0x27, 0x63, 0x15,
-  0xe0, 0x10, 0x05, 0x86,
-  0x65, 0x65, 0x40, 0x31,
-  0x40, 0x33, 0xc0, 0x1b,
-  0xc0, 0x14, 0x62, 0x41,
-  0x69, 0x81, 0x40, 0x33,
-  0x40, 0x31, 0xc0, 0x13,
-  0x40, 0x27, 0x63, 0x11,
-  0xe0, 0x8c, 0x06, 0x06,
+  0x40, 0x31, 0xc0, 0xc0,
+  0x40, 0x28, 0x64, 0x91,
+  0xe0, 0x0c, 0x47, 0xf6,
   0x63, 0x29, 0x40, 0x15,
-  0x02, 0x56, 0x40, 0x0b,
-  0xc0, 0x01, 0x60, 0x01,
-  0x69, 0x91, 0x40, 0x23,
-  0x45, 0x86, 0x40, 0x13,
+  0x91, 0x11, 0x40, 0x0b,
+  0x67, 0xc9, 0x40, 0x31,
+  0x06, 0x06, 0x40, 0x2d,
+  0x40, 0x33, 0xe0, 0x08,
+  0x40, 0x13, 0x69, 0x85,
+  0xe0, 0x8c, 0x06, 0x06,
+  0x68, 0x11, 0x40, 0x13,
+  0x40, 0x11, 0xc0, 0x0a,
+  0x40, 0x27, 0x63, 0x15,
+  0xe0, 0x10, 0x03, 0x86,
+  0x69, 0x91, 0x40, 0x13,
+  0x43, 0x86, 0x40, 0x13,
   0x40, 0x33, 0xe0, 0x00,
   0x40, 0x13, 0x69, 0x95,
   0xe0, 0x00, 0x46, 0x86,
-  0x64, 0x01, 0x40, 0x15,
-  0x8f, 0x11, 0x40, 0x05,
-  0x63, 0x31, 0x40, 0x21,
-  0x89, 0x21, 0x40, 0x27,
+  0x63, 0x31, 0x40, 0x11,
+  0x89, 0x11, 0x40, 0x27,
   0x63, 0x35, 0x40, 0x31,
   0x00, 0x3b, 0xc0, 0x27,
   0xc0, 0x0a, 0x69, 0x31,
-  0x68, 0x11, 0x40, 0x13,
-  0x83, 0x11, 0x40, 0x0a,
-  0x6c, 0x61, 0x40, 0x21,
-  0x85, 0x21, 0x40, 0x22,
-  0x6c, 0x65, 0x40, 0x21,
-  0x9d, 0x21, 0x40, 0x22,
-  0x68, 0x15, 0x40, 0x13,
-  0x40, 0x11, 0xc0, 0x0a,
-  0x40, 0x22, 0x65, 0x45,
-  0xe0, 0x08, 0x03, 0x06,
-  0x6f, 0xb1, 0x40, 0x21,
-  0x04, 0x34, 0x40, 0x22,
-  0x40, 0x11, 0xfc, 0xa8,
-  0xc0, 0x1b, 0x65, 0x6d,
-  0x65, 0x4d, 0x40, 0x11,
-  0x40, 0x11, 0xc0, 0x22,
-  0x40, 0x28, 0x64, 0x89,
-  0x40, 0x11, 0x95, 0x11,
-  0xc0, 0x28, 0x64, 0x8d,
-  0x6f, 0xb5, 0x40, 0x11,
-  0x40, 0x23, 0xc0, 0x22,
-  0xc0, 0x0a, 0x69, 0x31,
-  0xc1, 0xc3, 0xdd, 0x93,
+  0x6c, 0x61, 0x40, 0x11,
+  0x85, 0x11, 0x40, 0x22,
+  0x6c, 0x65, 0x40, 0x11,
+  0x9d, 0x11, 0x40, 0x22,
+  0x6f, 0xb1, 0x40, 0x11,
+  0x02, 0x34, 0x40, 0x22,
+  0x40, 0x21, 0xfc, 0xa8,
+  0xc0, 0x2c, 0x6e, 0x51,
+  0x68, 0x09, 0x40, 0x23,
+  0x40, 0x23, 0xc0, 0x0a,
+  0xc0, 0x0a, 0x68, 0x0d,
+  0x61, 0x1d, 0x40, 0x25,
+  0x95, 0x21, 0x40, 0x0a,
+  0x65, 0x65, 0x40, 0x41,
+  0x40, 0x43, 0xc0, 0x1b,
+  0xc0, 0x14, 0x62, 0x41,
+  0x64, 0x8d, 0x40, 0x21,
+  0x40, 0x43, 0xc0, 0x28,
+  0xc0, 0x13, 0x69, 0x81,
+  0x63, 0x11, 0x40, 0x41,
+  0x40, 0x21, 0xc0, 0x27,
+  0xc0, 0x22, 0x6f, 0xb5,
+  0x69, 0x31, 0x40, 0x13,
+  0xdd, 0x93, 0xc0, 0x0a,
   0xf8, 0x7c, 0x04, 0x0c,
   0x60, 0x0c, 0x14, 0x86,
   0x63, 0xc0, 0x04, 0x0e,
@@ -11699,7 +11700,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x69, 0xdd, 0x40, 0x21,
   0x40, 0x21, 0xc0, 0x2d,
   0xc0, 0x2d, 0x6a, 0x7d,
-  0x64, 0xe1, 0x40, 0x21,
+  0x64, 0xd5, 0x40, 0x21,
   0xa9, 0x21, 0x40, 0x38,
   0x6b, 0x1d, 0x40, 0x63,
   0x0c, 0x06, 0x40, 0x15,
@@ -12107,7 +12108,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa4, 0x04, 0x80, 0xa6,
   0x0c, 0x15, 0x80, 0x86,
   0xc0, 0x0b, 0x69, 0xf9,
-  0x41, 0x06, 0xa1, 0x1b,
+  0x40, 0x86, 0xa1, 0x1b,
   0x00, 0x15, 0x8f, 0xdc,
   0x8c, 0x0b, 0x00, 0x00,
   0xe8, 0x40, 0x4d, 0xc8,
@@ -12135,7 +12136,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xed, 0x50, 0x1e, 0xf0,
   0x97, 0x11, 0x00, 0x6b,
   0xe8, 0x10, 0x4d, 0x28,
-  0xef, 0xdc, 0x42, 0xc6,
+  0xef, 0xdc, 0x42, 0x46,
   0x40, 0x00, 0x84, 0x08,
   0x84, 0x06, 0xf3, 0xf8,
   0x62, 0x65, 0x0c, 0x09,
@@ -12407,7 +12408,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x43, 0x0d, 0xc0, 0x38,
   0x64, 0xc5, 0x00, 0x60,
   0x86, 0xf5, 0xc0, 0xe1,
-  0xef, 0xdc, 0x42, 0xc6,
+  0xef, 0xdc, 0x42, 0x46,
   0x88, 0x18, 0x82, 0x2b,
   0x88, 0x16, 0xc2, 0x19,
   0x6e, 0x0d, 0x0c, 0x19,
@@ -12417,7 +12418,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0xf5, 0x80, 0x38,
   0xc2, 0x09, 0x84, 0x08,
   0x83, 0x25, 0x84, 0x06,
-  0xef, 0xdc, 0x40, 0xc6,
+  0xef, 0xdc, 0x40, 0x46,
   0x84, 0x08, 0x80, 0x1b,
   0xf3, 0xf8, 0x40, 0x00,
   0x00, 0x60, 0x04, 0x06,
@@ -12428,13 +12429,13 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x1e, 0xf0, 0xc0, 0x00,
   0x0c, 0x0c, 0xe5, 0x50,
   0xdd, 0x93, 0xf2, 0x7c,
-  0xef, 0xdc, 0x40, 0xc6,
+  0xef, 0xdc, 0x40, 0x46,
   0x80, 0x28, 0x80, 0x18,
   0x04, 0x19, 0xc2, 0x17,
   0xf3, 0xf4, 0x44, 0x20,
   0x80, 0x26, 0xa2, 0x2f,
   0xc1, 0xc3, 0xdd, 0x93,
-  0xef, 0xdc, 0x03, 0x06,
+  0xef, 0xdc, 0x02, 0x86,
   0xe0, 0x70, 0x02, 0x29,
   0xe0, 0x84, 0x44, 0x0a,
   0x9a, 0x00, 0x5c, 0x08,
@@ -12461,7 +12462,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x29, 0xdd, 0x93,
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x42, 0x96,
-  0x6f, 0xf8, 0x45, 0xc8,
+  0x6f, 0xf8, 0x45, 0xe8,
   0xe0, 0x08, 0x4c, 0x96,
   0x0c, 0x06, 0xa3, 0x0b,
   0x8c, 0x0b, 0xc0, 0x00,
@@ -12484,7 +12485,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x29, 0xdd, 0x93,
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x42, 0x96,
-  0x6f, 0xf8, 0x42, 0xe8,
+  0x6f, 0xf8, 0x43, 0x08,
   0xe0, 0x08, 0x4c, 0x96,
   0x0c, 0x06, 0xa3, 0x0b,
   0x8c, 0x0b, 0xc0, 0x00,
@@ -12506,7 +12507,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0f, 0xf6, 0x40, 0x2b,
   0x03, 0xf6, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf8, 0x40, 0x28,
+  0xef, 0xf8, 0x40, 0x48,
   0x0d, 0x78, 0xa3, 0x0b,
   0x0c, 0x19, 0x80, 0x00,
   0xc0, 0x15, 0x61, 0x41,
@@ -12524,7 +12525,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x4e, 0x76,
   0x60, 0x08, 0x42, 0x76,
-  0x7d, 0xd8, 0x8c, 0x0b,
+  0x7d, 0xf8, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xf4,
   0x80, 0x00, 0x0b, 0x28,
   0x61, 0x41, 0x0c, 0x19,
@@ -12548,7 +12549,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4e, 0x76, 0x40, 0x2b,
   0x42, 0x76, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf4, 0x7a, 0xe8,
+  0xef, 0xf4, 0x7b, 0x08,
   0xa0, 0x65, 0xa3, 0x0b,
   0x61, 0x51, 0x0c, 0x09,
   0x00, 0x0a, 0xc0, 0x15,
@@ -12565,7 +12566,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x4e, 0x06,
   0x60, 0x08, 0x42, 0x06,
-  0x78, 0xb8, 0x8c, 0x0b,
+  0x78, 0xd8, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xf4,
   0x0c, 0x09, 0x98, 0x05,
   0xc0, 0x15, 0x61, 0x49,
@@ -12583,7 +12584,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x4e, 0x16,
   0x60, 0x08, 0x42, 0x16,
-  0x76, 0x78, 0x8c, 0x0b,
+  0x76, 0x98, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xf4,
   0x0c, 0x09, 0x8e, 0x85,
   0xc0, 0x15, 0x61, 0x41,
@@ -12603,7 +12604,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4e, 0x36, 0x40, 0x2b,
   0x42, 0x36, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf4, 0x74, 0x08,
+  0xef, 0xf4, 0x74, 0x28,
   0x03, 0x55, 0xa3, 0x0b,
   0xc0, 0x00, 0x0e, 0x06,
   0x61, 0x51, 0x0c, 0x09,
@@ -12621,7 +12622,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4e, 0x26, 0x40, 0x2b,
   0x42, 0x26, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf4, 0x71, 0xc8,
+  0xef, 0xf4, 0x71, 0xe8,
   0x0e, 0x06, 0xa3, 0x0b,
   0x8e, 0x0b, 0xc0, 0x00,
   0xf2, 0x04, 0x0c, 0x4c,
@@ -12727,7 +12728,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x44, 0x98, 0xc0, 0x16,
   0x8c, 0x0b, 0x68, 0x00,
   0x82, 0x95, 0xa1, 0x0b,
-  0x6f, 0xf0, 0x64, 0xc8,
+  0x6f, 0xf0, 0x64, 0xe8,
   0xa1, 0x0b, 0x8c, 0x0b,
   0x73, 0xb8, 0x80, 0xf5,
   0x8c, 0x0b, 0x68, 0x24,
@@ -12790,7 +12791,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4e, 0x56, 0x40, 0x2b,
   0x42, 0x56, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf4, 0x5c, 0xa8,
+  0xef, 0xf4, 0x5c, 0xc8,
   0x88, 0x05, 0xa3, 0x0b,
   0x6c, 0x51, 0x0c, 0x19,
   0x81, 0x21, 0x40, 0x2b,
@@ -12901,7 +12902,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x29, 0xdd, 0x93,
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x42, 0x56,
-  0x6f, 0xf4, 0x4e, 0xc8,
+  0x6f, 0xf4, 0x4e, 0xe8,
   0xe0, 0x08, 0x4c, 0x56,
   0x0c, 0x06, 0xa3, 0x0b,
   0x8c, 0x0b, 0xc0, 0x00,
@@ -12922,8 +12923,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x04, 0xe1, 0x48,
   0x02, 0x14, 0x80, 0x18,
   0x80, 0x16, 0xfc, 0x9c,
-  0xef, 0xe4, 0x56, 0x88,
-  0x6f, 0x9c, 0x62, 0x28,
+  0xef, 0xe4, 0x56, 0xa8,
+  0x6f, 0x9c, 0x62, 0x48,
   0xc1, 0xc3, 0x81, 0x01,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12934,8 +12935,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x54, 0xf8, 0x80, 0x16,
-  0x60, 0x98, 0xef, 0xe4,
+  0x55, 0x18, 0x80, 0x16,
+  0x60, 0xb8, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12946,8 +12947,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x53, 0x78, 0x80, 0x16,
-  0x5f, 0x18, 0xef, 0xe4,
+  0x53, 0x98, 0x80, 0x16,
+  0x5f, 0x38, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12958,8 +12959,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x51, 0xf8, 0x80, 0x16,
-  0x5d, 0x98, 0xef, 0xe4,
+  0x52, 0x18, 0x80, 0x16,
+  0x5d, 0xb8, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12970,8 +12971,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x50, 0x78, 0x80, 0x16,
-  0x5c, 0x18, 0xef, 0xe4,
+  0x50, 0x98, 0x80, 0x16,
+  0x5c, 0x38, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12982,8 +12983,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x4e, 0xf8, 0x80, 0x16,
-  0x5a, 0x98, 0xef, 0xe4,
+  0x4f, 0x18, 0x80, 0x16,
+  0x5a, 0xb8, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0x61, 0x48, 0x41, 0xc6,
@@ -12994,8 +12995,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x43, 0x86,
   0x80, 0x18, 0x84, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x4d, 0x78, 0x80, 0x16,
-  0x59, 0x18, 0xef, 0xe4,
+  0x4d, 0x98, 0x80, 0x16,
+  0x59, 0x38, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfa, 0x00, 0x00, 0x4c,
   0xe2, 0xc0, 0x00, 0x2c,
@@ -13005,8 +13006,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x48, 0x41, 0x86,
   0x80, 0x18, 0x80, 0x04,
   0xfc, 0x9c, 0x02, 0x14,
-  0x4c, 0x18, 0x80, 0x16,
-  0x57, 0xb8, 0xef, 0xe4,
+  0x4c, 0x38, 0x80, 0x16,
+  0x57, 0xd8, 0xef, 0xe4,
   0x81, 0x01, 0x6f, 0x9c,
   0xfe, 0x1c, 0x04, 0xcc,
   0x6f, 0xf8, 0x46, 0x28,
@@ -13019,18 +13020,18 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x94, 0x00, 0x06,
   0x10, 0x60, 0x00, 0x9e,
   0xc0, 0xaf, 0x64, 0x1d,
-  0xef, 0xe8, 0x7d, 0x48,
+  0xef, 0xe8, 0x7d, 0x68,
   0x82, 0x65, 0xa1, 0x0b,
   0xa0, 0x06, 0x87, 0x01,
   0xef, 0xf8, 0x45, 0x28,
   0xef, 0xf8, 0x45, 0x68,
-  0xef, 0xe4, 0x49, 0xc8,
-  0xef, 0xe8, 0x7c, 0xe8,
-  0x04, 0x06, 0x01, 0x11,
-  0x6a, 0xb8, 0xee, 0x14,
+  0xef, 0xe4, 0x49, 0xe8,
+  0xef, 0xe8, 0x7d, 0x08,
+  0x45, 0x86, 0x01, 0x11,
+  0x6a, 0xd8, 0xee, 0x10,
   0x8c, 0x0b, 0x6f, 0x9c,
-  0x6f, 0xdc, 0x01, 0x06,
-  0x6a, 0x58, 0x81, 0x11,
+  0x6f, 0xdc, 0x00, 0x86,
+  0x6a, 0x78, 0x81, 0x11,
   0x44, 0xc6, 0x6f, 0x9c,
   0x00, 0x86, 0xe0, 0x00,
   0x42, 0x86, 0x60, 0x0c,
@@ -13046,10 +13047,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x0e, 0x60, 0xdd,
   0x4c, 0x15, 0x83, 0x01,
   0x40, 0x0a, 0x6d, 0x49,
-  0xe0, 0x50, 0x03, 0xe6,
+  0xe0, 0x40, 0x43, 0x56,
   0x6e, 0x91, 0x4c, 0x01,
-  0x00, 0x06, 0x40, 0x2c,
-  0x4c, 0x13, 0xe4, 0x00,
+  0x01, 0xb6, 0x40, 0x2c,
+  0x4c, 0x13, 0xe3, 0x48,
   0x40, 0x16, 0x67, 0x39,
   0xe0, 0x00, 0x42, 0x16,
   0x67, 0x3d, 0x4c, 0x03,
@@ -13067,7 +13068,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xc0, 0x00, 0x02, 0x06,
   0xc0, 0x00, 0x40, 0x15,
-  0xef, 0xe4, 0x5a, 0x88,
+  0xef, 0xe4, 0x5a, 0xa8,
   0x64, 0x60, 0x18, 0xf0,
   0x60, 0x18, 0x8c, 0x0b,
   0x8d, 0x04, 0xe8, 0x10,
@@ -13081,16 +13082,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x10, 0xb6, 0x20, 0x28,
   0x02, 0xb6, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xf0, 0x78, 0x48,
+  0xef, 0xf0, 0x78, 0x68,
   0x68, 0x38, 0x4a, 0xc8,
   0x51, 0xf8, 0x8c, 0x0b,
   0x8c, 0x0b, 0x68, 0x04,
   0x7d, 0x38, 0xa1, 0x8b,
   0x50, 0x00, 0x6f, 0xf4,
   0x7d, 0x58, 0x9c, 0x00,
-  0x41, 0xb8, 0xef, 0xf4,
+  0x41, 0xd8, 0xef, 0xf4,
   0x01, 0x01, 0xef, 0xe4,
-  0x69, 0xf8, 0x83, 0x11,
+  0x6a, 0x18, 0x83, 0x11,
   0x8c, 0x2b, 0x6f, 0xe4,
   0x0c, 0xcc, 0x90, 0x0b,
   0xdd, 0x93, 0xf6, 0x1c,
@@ -13107,14 +13108,14 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x01, 0x04, 0x48,
   0x8c, 0x0b, 0x00, 0x00,
   0xef, 0xf4, 0x47, 0x68,
-  0x6f, 0xf0, 0x7e, 0xe8,
-  0x40, 0x46, 0x8c, 0x0b,
+  0x6f, 0xf0, 0x7f, 0x08,
+  0x01, 0xc6, 0x8c, 0x0b,
   0x42, 0x46, 0x6f, 0xdc,
   0x42, 0x1e, 0xe0, 0x04,
   0x02, 0x16, 0x83, 0x11,
   0xe0, 0x1c, 0x43, 0x46,
   0xf8, 0x08, 0x40, 0x15,
-  0xef, 0xe4, 0x66, 0x88,
+  0xef, 0xe4, 0x66, 0xa8,
   0x68, 0x00, 0x48, 0x28,
   0x00, 0xc6, 0x8c, 0x0b,
   0x97, 0x11, 0x61, 0x4c,
@@ -13140,7 +13141,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x35, 0xe4, 0xb5,
   0xe8, 0x38, 0x43, 0xc8,
   0x8e, 0x1b, 0x0c, 0x0b,
-  0x6f, 0xe8, 0x6e, 0xe8,
+  0x6f, 0xe8, 0x6f, 0x08,
   0x80, 0x8b, 0x8e, 0x2b,
   0xe2, 0x55, 0xa1, 0x8b,
   0x9f, 0x21, 0x01, 0x11,
@@ -13225,7 +13226,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x01, 0x61, 0xc1, 0x83,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0xa0, 0x55, 0x88,
+  0x6f, 0xa0, 0x55, 0xa8,
   0x01, 0x06, 0x81, 0x11,
   0x4f, 0x06, 0x61, 0x98,
   0x00, 0x1a, 0xe1, 0x4c,
@@ -13237,7 +13238,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x10, 0x16, 0x83, 0x11,
   0x88, 0x04, 0x83, 0x11,
   0x41, 0xf6, 0x00, 0x66,
-  0x53, 0xf8, 0xe0, 0x3c,
+  0x54, 0x18, 0xe0, 0x3c,
   0x7b, 0xd8, 0xef, 0xa0,
   0x1c, 0x04, 0xe8, 0x14,
   0x4d, 0x18, 0x81, 0x11,
@@ -13284,7 +13285,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x41, 0xf6, 0xc1, 0x83,
   0x81, 0x11, 0x60, 0x3c,
-  0xef, 0xa0, 0x4e, 0x28,
+  0xef, 0xa0, 0x4e, 0x48,
   0x61, 0x4c, 0x4d, 0x06,
   0x98, 0x04, 0xa5, 0x11,
   0x6c, 0x1d, 0x40, 0x11,
@@ -13320,7 +13321,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x43, 0x78, 0x98, 0x04,
   0x41, 0xf6, 0xe8, 0x08,
   0x83, 0x11, 0x60, 0x3c,
-  0xef, 0xa0, 0x49, 0xa8,
+  0xef, 0xa0, 0x49, 0xc8,
   0x1f, 0x0c, 0xa8, 0xf1,
   0x0f, 0xfc, 0xf0, 0x04,
   0xbc, 0xf4, 0xf6, 0x84,
@@ -13335,7 +13336,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x41, 0xf6, 0xc1, 0x83,
   0x81, 0x11, 0x60, 0x3c,
-  0xef, 0xa0, 0x47, 0xc8,
+  0xef, 0xa0, 0x47, 0xe8,
   0x61, 0x4c, 0x4d, 0x06,
   0x98, 0x04, 0xa7, 0x11,
   0x6c, 0x1d, 0x40, 0x11,
@@ -13389,10 +13390,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6e, 0x09, 0x40, 0x13,
   0x02, 0x36, 0x40, 0x15,
   0x7a, 0x98, 0xe0, 0x40,
-  0x4c, 0x18, 0xe8, 0x04,
+  0x4c, 0x38, 0xe8, 0x04,
   0x41, 0xf6, 0xef, 0xe0,
   0x83, 0x11, 0x60, 0x3c,
-  0xef, 0xa0, 0x40, 0xa8,
+  0xef, 0xa0, 0x40, 0xc8,
   0x1f, 0x0c, 0xa8, 0xf1,
   0x0f, 0xfc, 0xf0, 0x04,
   0xbc, 0xf4, 0xf6, 0x84,
@@ -13407,7 +13408,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x41, 0xf6, 0xc1, 0x83,
   0x81, 0x11, 0x60, 0x3c,
-  0xef, 0x9c, 0x7e, 0xc8,
+  0xef, 0x9c, 0x7e, 0xe8,
   0x61, 0x4c, 0x4d, 0x06,
   0x98, 0x04, 0xa9, 0x11,
   0x6c, 0x1d, 0x40, 0x11,
@@ -13545,7 +13546,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x7f, 0x98, 0xe0, 0x0c,
   0x41, 0xf6, 0xe8, 0x00,
   0x83, 0x11, 0x60, 0x3c,
-  0xef, 0x9c, 0x6d, 0x88,
+  0xef, 0x9c, 0x6d, 0xa8,
   0x1f, 0x0c, 0xa8, 0xf1,
   0x0f, 0xfc, 0xf0, 0x04,
   0xbc, 0xf4, 0xf6, 0x84,
@@ -13560,7 +13561,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x01, 0x61, 0xc1, 0x83,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0x9c, 0x6b, 0xa8,
+  0x6f, 0x9c, 0x6b, 0xc8,
   0x4f, 0x06, 0x81, 0x11,
   0x03, 0x06, 0x61, 0x4c,
   0x1c, 0x04, 0xe1, 0x98,
@@ -13574,9 +13575,9 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0x66, 0x8c, 0x04,
   0x63, 0x98, 0x9c, 0x04,
   0x9c, 0x04, 0xe8, 0x04,
-  0xef, 0xe0, 0x71, 0x08,
+  0xef, 0xe0, 0x71, 0x28,
   0x60, 0x3c, 0x41, 0xf6,
-  0x69, 0x98, 0x83, 0x11,
+  0x69, 0xb8, 0x83, 0x11,
   0xa8, 0xf1, 0xef, 0x9c,
   0xf0, 0x04, 0x1f, 0x0c,
   0xf6, 0x84, 0x0f, 0xfc,
@@ -13592,20 +13593,20 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x01, 0x61, 0xc1, 0x83,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0x9c, 0x67, 0xa8,
+  0x6f, 0x9c, 0x67, 0xc8,
   0x4f, 0x06, 0x81, 0x11,
   0xad, 0x01, 0x61, 0x4c,
   0x83, 0x81, 0x1c, 0x14,
   0x6c, 0x1d, 0x42, 0x01,
   0x83, 0x01, 0x40, 0x2b,
-  0xef, 0xe4, 0x72, 0x68,
+  0xef, 0xe4, 0x72, 0x88,
   0xe1, 0x3c, 0x41, 0xc6,
   0x04, 0x86, 0x80, 0x14,
   0x80, 0x04, 0x8d, 0x11,
   0x9c, 0x04, 0x80, 0x66,
   0xe8, 0x04, 0x5f, 0xc8,
   0x60, 0x3c, 0x41, 0xf6,
-  0x65, 0xf8, 0x83, 0x11,
+  0x66, 0x18, 0x83, 0x11,
   0xa0, 0xf1, 0xef, 0x9c,
   0xf0, 0x04, 0x1f, 0x0c,
   0xf6, 0x8c, 0x0f, 0xfc,
@@ -13621,15 +13622,15 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0x93, 0x81, 0x83,
   0x41, 0xf6, 0xc1, 0x83,
   0x81, 0x11, 0x60, 0x3c,
-  0x6f, 0x9c, 0x64, 0x08,
+  0x6f, 0x9c, 0x64, 0x28,
   0x4f, 0x06, 0x81, 0x61,
   0xaf, 0x01, 0x61, 0x4c,
   0x42, 0x01, 0x9c, 0x14,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x6e, 0xd8, 0x81, 0x01,
+  0x6e, 0xf8, 0x81, 0x01,
   0x1c, 0x04, 0xef, 0xe4,
   0x5c, 0x98, 0x8f, 0x11,
-  0x01, 0x06, 0xe8, 0x04,
+  0x00, 0x86, 0xe8, 0x04,
   0x80, 0x18, 0xef, 0xdc,
   0xf8, 0xc0, 0x02, 0x0a,
   0x80, 0x18, 0x80, 0xe5,
@@ -13647,7 +13648,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x84, 0x45, 0xe0, 0x84,
   0x68, 0x04, 0x5a, 0x88,
   0xe0, 0x10, 0x02, 0x76,
-  0x68, 0xb8, 0x9c, 0x04,
+  0x68, 0xd8, 0x9c, 0x04,
   0x9c, 0x04, 0xef, 0xe4,
   0x6e, 0x09, 0x00, 0x1b,
   0x42, 0x10, 0xc0, 0x15,
@@ -13658,7 +13659,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x16, 0x80, 0x04,
   0x00, 0x66, 0x83, 0x11,
   0xe0, 0x3c, 0x41, 0xf6,
-  0xef, 0x9c, 0x5f, 0x68,
+  0xef, 0x9c, 0x5f, 0x88,
   0x1f, 0x0c, 0xa8, 0xf1,
   0x0f, 0xfc, 0xf0, 0x04,
   0xbc, 0xf4, 0xf6, 0x84,
@@ -13744,113 +13745,113 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa1, 0x0b, 0x80, 0x6b,
   0xc0, 0x00, 0x1d, 0x48,
   0x63, 0x29, 0x0c, 0x39,
-  0x40, 0x8e, 0x40, 0x2d,
+  0x40, 0x4e, 0x40, 0x2d,
   0xc0, 0x10, 0x6c, 0xdd,
   0x63, 0x21, 0x0c, 0x19,
   0x0c, 0x29, 0xc0, 0x2d,
   0xc0, 0x2d, 0x63, 0x25,
   0x61, 0x84, 0x08, 0x34,
-  0x54, 0x58, 0x82, 0x39,
+  0x54, 0x78, 0x82, 0x39,
   0x82, 0x49, 0x6f, 0x9c,
   0x1b, 0xf8, 0xa1, 0x0b,
   0x0c, 0x39, 0xc0, 0x00,
   0x40, 0x2d, 0x63, 0x39,
-  0x6c, 0xe5, 0x40, 0x4e,
+  0x6c, 0xe5, 0x40, 0x0e,
   0x0c, 0x19, 0xc0, 0x10,
   0xc0, 0x2d, 0x63, 0x31,
   0x63, 0x35, 0x0c, 0x29,
   0x08, 0x34, 0xc0, 0x2d,
   0x82, 0x39, 0x61, 0x84,
-  0x6f, 0x9c, 0x53, 0x08,
+  0x6f, 0x9c, 0x53, 0x28,
   0xa1, 0x0b, 0x82, 0x49,
   0xc0, 0x00, 0x1a, 0xa8,
   0x63, 0x49, 0x0c, 0x39,
-  0x01, 0x4e, 0x40, 0x2d,
+  0x01, 0x0e, 0x40, 0x2d,
   0xc0, 0x10, 0x6c, 0xed,
   0x63, 0x41, 0x0c, 0x19,
   0x0c, 0x29, 0xc0, 0x2d,
   0xc0, 0x2d, 0x63, 0x45,
   0x61, 0x84, 0x08, 0x34,
-  0x51, 0xb8, 0x82, 0x39,
+  0x51, 0xd8, 0x82, 0x39,
   0x82, 0x49, 0x6f, 0x9c,
   0x19, 0x58, 0xa1, 0x0b,
   0x0c, 0x3b, 0xc0, 0x00,
   0x40, 0x16, 0x69, 0xa9,
-  0x6c, 0xf9, 0x40, 0x0e,
+  0x6c, 0xf9, 0x01, 0xce,
   0x0c, 0x19, 0xc0, 0x10,
   0xc0, 0x2d, 0x63, 0x59,
   0x63, 0x5d, 0x0c, 0x29,
   0x08, 0x34, 0xc0, 0x2d,
   0x82, 0x39, 0x61, 0x84,
-  0x6f, 0x9c, 0x50, 0x68,
+  0x6f, 0x9c, 0x50, 0x88,
   0xa1, 0x0b, 0x82, 0x49,
   0xc0, 0x00, 0x18, 0x08,
   0x63, 0x71, 0x0c, 0x39,
-  0x00, 0x0e, 0x40, 0x2d,
-  0xc0, 0x10, 0x6d, 0x0d,
+  0x41, 0xce, 0x40, 0x2d,
+  0xc0, 0x10, 0x6d, 0x09,
   0x63, 0x61, 0x0c, 0x19,
   0x0c, 0x29, 0xc0, 0x2d,
   0xc0, 0x2d, 0x63, 0x65,
   0x61, 0x84, 0x08, 0x34,
-  0x4f, 0x18, 0x82, 0x39,
+  0x4f, 0x38, 0x82, 0x39,
   0x82, 0x49, 0x6f, 0x9c,
   0x16, 0xb8, 0xa1, 0x0b,
   0x0c, 0x39, 0xc0, 0x00,
   0x40, 0x2d, 0x63, 0xa9,
-  0x6d, 0x31, 0x40, 0x4e,
+  0x6d, 0x31, 0x40, 0x0e,
   0x0c, 0x19, 0xc0, 0x10,
   0xc0, 0x2d, 0x63, 0xa1,
   0x63, 0xa5, 0x0c, 0x29,
   0x08, 0x34, 0xc0, 0x2d,
   0x82, 0x39, 0x61, 0x84,
-  0x6f, 0x9c, 0x4d, 0xc8,
+  0x6f, 0x9c, 0x4d, 0xe8,
   0xa1, 0x0b, 0x82, 0x49,
   0xc0, 0x00, 0x15, 0x68,
   0x63, 0xd9, 0x0c, 0x39,
-  0x40, 0x4e, 0x40, 0x2d,
+  0x40, 0x0e, 0x40, 0x2d,
   0xc0, 0x10, 0x6d, 0x39,
   0x63, 0xd1, 0x0c, 0x19,
   0x0c, 0x29, 0xc0, 0x2d,
   0xc0, 0x2d, 0x63, 0xd5,
   0x61, 0x84, 0x08, 0x34,
-  0x4c, 0x78, 0x82, 0x39,
+  0x4c, 0x98, 0x82, 0x39,
   0x82, 0x49, 0x6f, 0x9c,
   0x14, 0x18, 0xa1, 0x0b,
   0x0c, 0x39, 0xc0, 0x00,
   0x40, 0x2d, 0x64, 0x09,
-  0x6d, 0x41, 0x01, 0x8e,
+  0x6d, 0x41, 0x01, 0x4e,
   0x0c, 0x19, 0xc0, 0x10,
   0xc0, 0x2d, 0x64, 0x01,
   0x64, 0x05, 0x0c, 0x29,
   0x08, 0x34, 0xc0, 0x2d,
   0x82, 0x39, 0x61, 0x84,
-  0x6f, 0x9c, 0x4b, 0x28,
+  0x6f, 0x9c, 0x4b, 0x48,
   0xa1, 0x0b, 0x82, 0x49,
   0xc0, 0x00, 0x12, 0xc8,
   0x64, 0x39, 0x0c, 0x39,
-  0x40, 0x8e, 0x40, 0x2d,
+  0x40, 0x4e, 0x40, 0x2d,
   0xc0, 0x10, 0x6d, 0x4d,
   0x64, 0x31, 0x0c, 0x19,
   0x0c, 0x29, 0xc0, 0x2d,
   0xc0, 0x2d, 0x64, 0x35,
-  0x49, 0xf8, 0x82, 0x39,
+  0x4a, 0x18, 0x82, 0x39,
   0x86, 0x4b, 0x6f, 0x9c,
   0x11, 0x98, 0xa1, 0x0b,
   0x0c, 0x39, 0xc0, 0x00,
   0x40, 0x2d, 0x64, 0x69,
-  0x6d, 0x55, 0x01, 0x0e,
+  0x6d, 0x55, 0x00, 0xce,
   0x0c, 0x19, 0xc0, 0x10,
   0xc0, 0x2d, 0x64, 0x61,
   0x64, 0x65, 0x0c, 0x29,
   0x08, 0x34, 0xc0, 0x2d,
   0x82, 0x39, 0x61, 0x84,
-  0x6f, 0x9c, 0x48, 0xa8,
+  0x6f, 0x9c, 0x48, 0xc8,
   0xa1, 0x0b, 0x82, 0x49,
   0xc0, 0x00, 0x10, 0x48,
-  0x6f, 0x9c, 0x4f, 0x28,
+  0x6f, 0x9c, 0x4f, 0x48,
   0x41, 0xf6, 0x81, 0x01,
   0x83, 0x11, 0x60, 0x3c,
-  0xef, 0x9c, 0x47, 0x68,
+  0xef, 0x9c, 0x47, 0x88,
   0x63, 0x29, 0x0c, 0x09,
   0x03, 0xc6, 0x40, 0x2d,
   0x84, 0x14, 0xe1, 0x38,
@@ -13980,7 +13981,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0e, 0xa6, 0x40, 0x2b,
   0x02, 0xa6, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xec, 0x47, 0xe8,
+  0xef, 0xec, 0x48, 0x08,
   0x0e, 0x06, 0xa3, 0x0b,
   0x8e, 0x0b, 0xc0, 0x00,
   0xf2, 0x04, 0x0c, 0x4c,
@@ -13991,47 +13992,47 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x09, 0x80, 0x6b,
   0xc0, 0x2d, 0x63, 0x21,
   0x63, 0x25, 0x0c, 0x19,
-  0x7a, 0xb8, 0xc0, 0x2d,
+  0x7a, 0xd8, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x94, 0x35,
   0xc0, 0x2d, 0x63, 0x31,
   0x63, 0x35, 0x0c, 0x19,
-  0x7a, 0x18, 0xc0, 0x2d,
+  0x7a, 0x38, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x90, 0xf5,
   0xc0, 0x2d, 0x63, 0x41,
   0x63, 0x45, 0x0c, 0x19,
-  0x79, 0x78, 0xc0, 0x2d,
+  0x79, 0x98, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x8e, 0xb5,
   0xc0, 0x2d, 0x63, 0x59,
   0x63, 0x5d, 0x0c, 0x19,
-  0x78, 0xd8, 0xc0, 0x2d,
+  0x78, 0xf8, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x8c, 0x75,
   0xc0, 0x2d, 0x63, 0x61,
   0x63, 0x65, 0x0c, 0x19,
-  0x78, 0x38, 0xc0, 0x2d,
+  0x78, 0x58, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x8a, 0x35,
   0xc0, 0x2d, 0x63, 0xa1,
   0x63, 0xa5, 0x0c, 0x19,
-  0x77, 0x98, 0xc0, 0x2d,
+  0x77, 0xb8, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x86, 0xf5,
   0xc0, 0x2d, 0x63, 0xd1,
   0x63, 0xd5, 0x0c, 0x19,
-  0x76, 0xf8, 0xc0, 0x2d,
+  0x77, 0x18, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x84, 0xb5,
   0xc0, 0x2d, 0x64, 0x01,
   0x64, 0x05, 0x0c, 0x19,
-  0x76, 0x58, 0xc0, 0x2d,
+  0x76, 0x78, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x09, 0x82, 0x75,
   0xc0, 0x2d, 0x64, 0x31,
   0x64, 0x35, 0x0c, 0x19,
-  0x75, 0xb8, 0xc0, 0x2d,
+  0x75, 0xd8, 0xc0, 0x2d,
   0xa1, 0x0b, 0xef, 0x98,
   0x0c, 0x0c, 0x80, 0x85,
   0xdd, 0x93, 0xf2, 0x00,
@@ -14039,16 +14040,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x19, 0xc0, 0x2d,
   0xc0, 0x2d, 0x64, 0x65,
   0xf2, 0x00, 0x0c, 0x0c,
-  0xff, 0x98, 0x34, 0xc8,
+  0xff, 0x98, 0x34, 0xe8,
   0xfa, 0x80, 0x00, 0x0c,
   0x6c, 0x1d, 0x00, 0x29,
-  0x40, 0x18, 0xc0, 0x2b,
+  0x40, 0x38, 0xc0, 0x2b,
   0xa3, 0x0b, 0xef, 0xec,
   0x41, 0xf6, 0x82, 0x55,
   0x81, 0x11, 0x60, 0x3c,
-  0xef, 0x98, 0x6e, 0xe8,
+  0xef, 0x98, 0x6f, 0x08,
   0xf2, 0x80, 0x08, 0x0c,
-  0xff, 0xd8, 0x39, 0xc8,
+  0xff, 0xd8, 0x39, 0xe8,
   0xf2, 0x80, 0x08, 0x0c,
   0xc1, 0xc3, 0xdd, 0x93,
   0xfa, 0x0c, 0x04, 0x0c,
@@ -14058,8 +14059,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x29, 0x82, 0x35,
   0x40, 0x2b, 0x6c, 0x1d,
   0x0c, 0x0c, 0x8c, 0x0b,
-  0x3e, 0x18, 0xf2, 0x0c,
-  0x4e, 0xc6, 0xff, 0xe8,
+  0x3e, 0x38, 0xf2, 0x0c,
+  0x4e, 0x46, 0xff, 0xe8,
   0x0e, 0x09, 0xef, 0xdc,
   0xc2, 0x09, 0xf8, 0x10,
   0xf8, 0x10, 0x4e, 0x01,
@@ -14082,7 +14083,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x03, 0xc0, 0xfd,
   0x40, 0x15, 0x6e, 0x09,
   0x40, 0xf8, 0x8c, 0x0b,
-  0x75, 0xd8, 0xe8, 0x20,
+  0x75, 0xf8, 0xe8, 0x20,
   0x8c, 0x0b, 0x6f, 0xe8,
   0x61, 0x44, 0x00, 0xc6,
   0xe0, 0x00, 0x42, 0x46,
@@ -14091,7 +14092,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x86, 0x80, 0x04,
   0x58, 0xb8, 0x8c, 0x0b,
   0x0c, 0x0c, 0xe8, 0x00,
-  0x34, 0x58, 0xf2, 0x0c,
+  0x34, 0x78, 0xf2, 0x0c,
   0x42, 0x56, 0xff, 0xd8,
   0x8c, 0x0b, 0x60, 0x00,
   0xe8, 0x00, 0x58, 0x28,
@@ -14109,16 +14110,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x72, 0xc1, 0x02, 0x06,
   0x8c, 0x0b, 0xc0, 0x20,
   0xf2, 0x0c, 0x0c, 0x0c,
-  0xff, 0xd8, 0x32, 0xc8,
+  0xff, 0xd8, 0x32, 0xe8,
   0xfa, 0x00, 0x04, 0x0c,
   0x82, 0x25, 0xa1, 0x1b,
-  0x6f, 0x98, 0x66, 0xa8,
+  0x6f, 0x98, 0x66, 0xc8,
   0x40, 0x06, 0x83, 0x11,
   0x0c, 0x0c, 0xfa, 0x02,
   0xdd, 0x93, 0xf2, 0x00,
   0x7a, 0x02, 0x4c, 0x06,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0x98, 0x65, 0xe8,
+  0x6f, 0x98, 0x66, 0x08,
   0x8c, 0x0b, 0x81, 0x11,
   0xf2, 0x00, 0x0c, 0x0c,
   0xc1, 0xc3, 0xdd, 0x93,
@@ -14185,7 +14186,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xef, 0xec, 0x7a, 0x08,
   0x6c, 0x1d, 0x0c, 0x29,
   0x02, 0x16, 0x40, 0x2b,
-  0x6e, 0x38, 0xe0, 0x08,
+  0x6e, 0x58, 0xe0, 0x08,
   0x8c, 0x0b, 0x6f, 0xe8,
   0x80, 0x95, 0xa3, 0x0b,
   0xe8, 0x30, 0x4f, 0x48,
@@ -14200,7 +14201,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x0e, 0x26,
   0x60, 0x08, 0x02, 0x26,
-  0x6c, 0x58, 0x8c, 0x0b,
+  0x6c, 0x78, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xe8,
   0xc0, 0x00, 0x0e, 0x06,
   0x0c, 0x0c, 0x8e, 0x0b,
@@ -14225,7 +14226,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0e, 0x46, 0x40, 0x2b,
   0x02, 0x46, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xe8, 0x69, 0x48,
+  0xef, 0xe8, 0x69, 0x68,
   0x80, 0x95, 0xa3, 0x0b,
   0xe8, 0x30, 0x4a, 0x68,
   0x4a, 0x38, 0x83, 0x75,
@@ -14237,7 +14238,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0e, 0x56, 0x40, 0x2b,
   0x02, 0x56, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xe8, 0x67, 0xc8,
+  0xef, 0xe8, 0x67, 0xe8,
   0x80, 0x45, 0xa3, 0x0b,
   0x00, 0x86, 0x81, 0x71,
   0x80, 0x04, 0xe1, 0x3c,
@@ -14265,7 +14266,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x10, 0x66,
   0x60, 0x08, 0x02, 0x66,
-  0x64, 0x38, 0x8c, 0x0b,
+  0x64, 0x58, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xe8,
   0x45, 0x58, 0x80, 0x95,
   0x81, 0xe5, 0xe8, 0x30,
@@ -14282,7 +14283,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x0e, 0x76,
   0x60, 0x08, 0x02, 0x76,
-  0x62, 0x18, 0x8c, 0x0b,
+  0x62, 0x38, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xe8,
   0xc0, 0x00, 0x0e, 0x06,
   0x0c, 0x4c, 0x8e, 0x0b,
@@ -14520,7 +14521,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf0, 0x8c, 0x4e, 0x62,
   0x00, 0x20, 0x8c, 0x23,
   0x40, 0xbd, 0x67, 0xc1,
-  0x6a, 0x18, 0xa9, 0x21,
+  0x6a, 0x38, 0xa9, 0x21,
   0x40, 0x06, 0xef, 0x90,
   0x4e, 0x05, 0xfc, 0x06,
   0xc0, 0x0b, 0x6d, 0xc9,
@@ -14600,7 +14601,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x61, 0x4c, 0x4d, 0x06,
   0xe1, 0x98, 0x03, 0x46,
   0x81, 0x21, 0x18, 0x04,
-  0x6e, 0x14, 0x06, 0x06,
+  0x6e, 0x10, 0x47, 0x86,
   0xe1, 0x00, 0x0a, 0xc6,
   0x03, 0x86, 0x04, 0x0c,
   0x04, 0x2e, 0xe1, 0x98,
@@ -14630,16 +14631,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x42, 0x86, 0x82, 0x0b,
   0x04, 0x0e, 0xe1, 0x98,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0x94, 0x65, 0xe8,
+  0x6f, 0x94, 0x66, 0x08,
   0x00, 0x1c, 0x81, 0x11,
   0x50, 0x06, 0xe2, 0xc0,
   0xc0, 0x00, 0x61, 0x99,
   0x00, 0x46, 0x20, 0x0e,
-  0x55, 0xf8, 0xe1, 0x9c,
+  0x56, 0x18, 0xe1, 0x9c,
   0xa0, 0x04, 0xef, 0x94,
   0xe3, 0x40, 0x00, 0x1c,
   0x60, 0x3c, 0x41, 0xf6,
-  0x64, 0xb8, 0x83, 0x11,
+  0x64, 0xd8, 0x83, 0x11,
   0x83, 0x81, 0x6f, 0x94,
   0x43, 0x86, 0x18, 0x04,
   0xc4, 0x80, 0x60, 0x15,
@@ -14655,7 +14656,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc1, 0xc3, 0xff, 0xd5,
   0xfa, 0x0c, 0x04, 0x0c,
   0x41, 0xf6, 0x00, 0x7b,
-  0x62, 0xb8, 0xe0, 0x3c,
+  0x62, 0xd8, 0xe0, 0x3c,
   0x81, 0x11, 0x6f, 0x94,
   0x09, 0x01, 0x81, 0x61,
   0x4e, 0x01, 0xb7, 0x11,
@@ -14669,7 +14670,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0e, 0x19, 0x82, 0xe5,
   0xc0, 0x2b, 0x64, 0xc5,
   0x8a, 0xf5, 0xa7, 0x1b,
-  0xef, 0xdc, 0x03, 0x06,
+  0xef, 0xdc, 0x02, 0x86,
   0x42, 0x0a, 0x84, 0x18,
   0x8a, 0x25, 0xe0, 0x80,
   0xe0, 0x80, 0x40, 0x0a,
@@ -14685,18 +14686,18 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc0, 0xff, 0x72, 0xfd,
   0x6e, 0x09, 0x4e, 0x03,
   0x41, 0xf6, 0x40, 0x15,
-  0x5e, 0xf8, 0xe0, 0x3c,
+  0x5f, 0x18, 0xe0, 0x3c,
   0xa1, 0x6b, 0xef, 0x94,
   0x07, 0x11, 0xa4, 0xd5,
   0x4d, 0xd8, 0x8e, 0x0b,
-  0x72, 0xd8, 0xef, 0xfc,
+  0x72, 0xf8, 0xef, 0xfc,
   0x8e, 0x0b, 0x6f, 0xd4,
   0x80, 0x6b, 0x11, 0xe5,
   0x8e, 0x0b, 0x09, 0x11,
   0xef, 0xfc, 0x4d, 0x48,
   0x64, 0xd5, 0x0e, 0x09,
   0xa7, 0x0b, 0xc0, 0x2b,
-  0x11, 0x06, 0x92, 0xd5,
+  0x10, 0x86, 0x92, 0xd5,
   0xa0, 0x08, 0xef, 0xdc,
   0xf8, 0xc0, 0x00, 0x0a,
   0xa0, 0x08, 0x80, 0xe5,
@@ -14712,7 +14713,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8a, 0xe5, 0xe0, 0x8c,
   0x8e, 0x0b, 0x1b, 0x11,
   0xef, 0xfc, 0x4b, 0x08,
-  0x6f, 0xd8, 0x54, 0xa8,
+  0x6f, 0xd8, 0x54, 0xc8,
   0x1d, 0x11, 0x8e, 0x0b,
   0x4a, 0x98, 0x8e, 0x0b,
   0x7c, 0x18, 0xef, 0xfc,
@@ -14728,7 +14729,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xfc, 0x98, 0x00, 0x04,
   0x6e, 0x09, 0x4e, 0x03,
   0x41, 0xf6, 0x40, 0x15,
-  0x59, 0x98, 0xe0, 0x3c,
+  0x59, 0xb8, 0xe0, 0x3c,
   0x0b, 0x11, 0xef, 0x94,
   0x48, 0x98, 0x8e, 0x0b,
   0x41, 0x38, 0xef, 0xfc,
@@ -14736,7 +14737,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8e, 0x0b, 0x1f, 0x11,
   0xef, 0xfc, 0x48, 0x28,
   0x60, 0x3c, 0x41, 0xf6,
-  0x58, 0x98, 0x83, 0x11,
+  0x58, 0xb8, 0x83, 0x11,
   0x0e, 0x09, 0xef, 0x94,
   0xc0, 0x2b, 0x6c, 0x11,
   0xe0, 0x98, 0x40, 0x4a,
@@ -14763,7 +14764,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf8, 0x15, 0xa1, 0x0b,
   0xc3, 0x13, 0xc1, 0x83,
   0x60, 0x3c, 0x41, 0xf6,
-  0x55, 0x38, 0x83, 0x11,
+  0x55, 0x58, 0x83, 0x11,
   0x00, 0x64, 0xef, 0x94,
   0x0c, 0x0c, 0xfa, 0x80,
   0xdd, 0x93, 0xf2, 0x0c,
@@ -14780,7 +14781,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x44, 0x20, 0x84, 0x14,
   0xc0, 0xff, 0x72, 0xf1,
   0x6e, 0x09, 0x40, 0x23,
-  0x1e, 0xd8, 0xc0, 0x15,
+  0x1e, 0xf8, 0xc0, 0x15,
   0xdd, 0x93, 0xff, 0xd4,
   0xfa, 0x84, 0x04, 0x0c,
   0x41, 0x06, 0x00, 0x6b,
@@ -14826,7 +14827,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xfc, 0x95, 0xa5, 0x3b,
   0x6c, 0x1d, 0x10, 0x29,
   0x02, 0xc6, 0x40, 0x2b,
-  0x5e, 0x18, 0xe0, 0x08,
+  0x5e, 0x38, 0xe0, 0x08,
   0x90, 0x0b, 0x6f, 0xe4,
   0xe0, 0x08, 0x12, 0xc6,
   0x8c, 0xd5, 0xa1, 0x0b,
@@ -14850,7 +14851,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xfc, 0x95, 0xa7, 0x3b,
   0x6c, 0x1d, 0x10, 0x29,
   0x02, 0xc6, 0x40, 0x2b,
-  0x5b, 0x18, 0xe0, 0x08,
+  0x5b, 0x38, 0xe0, 0x08,
   0x90, 0x0b, 0x6f, 0xe4,
   0xe0, 0x08, 0x12, 0xc6,
   0x80, 0xd5, 0xa1, 0x0b,
@@ -15069,7 +15070,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf3, 0xf0, 0x46, 0x30,
   0x06, 0x36, 0xc4, 0x39,
   0xe0, 0x08, 0x02, 0xe6,
-  0xef, 0xe0, 0x7f, 0xc8,
+  0xef, 0xe0, 0x7f, 0xe8,
   0x82, 0x55, 0xa1, 0x0b,
   0x00, 0x56, 0x81, 0x85,
   0x80, 0x18, 0xe1, 0x94,
@@ -15345,7 +15346,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4e, 0x66, 0x40, 0x2b,
   0x42, 0x66, 0xe0, 0x0c,
   0x8c, 0x0b, 0x60, 0x0c,
-  0xef, 0xe0, 0x5d, 0x48,
+  0xef, 0xe0, 0x5d, 0x68,
   0x0c, 0x0c, 0x8e, 0x0b,
   0xdd, 0x93, 0xf2, 0x0c,
   0x69, 0x84, 0x08, 0x24,
@@ -15461,7 +15462,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x65, 0x41, 0x0a, 0x60,
   0x3e, 0x1e, 0xc0, 0x54,
   0x3c, 0x0e, 0x94, 0x1b,
-  0x55, 0x18, 0x92, 0x0b,
+  0x55, 0x38, 0x92, 0x0b,
   0x8e, 0x2b, 0x6f, 0xc4,
   0x63, 0x21, 0x0c, 0x09,
   0x4e, 0x0a, 0x40, 0x38,
@@ -15473,7 +15474,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x01, 0xc0, 0xd8,
   0x40, 0x2b, 0x6c, 0x1d,
   0x14, 0x1b, 0x92, 0x0b,
-  0x4d, 0x78, 0x8e, 0x2b,
+  0x4d, 0x98, 0x8e, 0x2b,
   0x96, 0x4b, 0x6f, 0xc0,
   0x4e, 0x0a, 0x0d, 0xa5,
   0x40, 0x46, 0xe1, 0x9c,
@@ -15508,7 +15509,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x96, 0x4b, 0x3e, 0x4e,
   0xbc, 0xce, 0x9b, 0x8e,
   0x9d, 0x2e, 0x95, 0x1e,
-  0xef, 0xb8, 0x49, 0x68,
+  0xef, 0xb8, 0x49, 0x88,
   0xa1, 0x8b, 0x80, 0x8b,
   0x40, 0x56, 0x88, 0x75,
   0x0a, 0x60, 0x60, 0x08,
@@ -15525,7 +15526,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x9b, 0x24, 0x9d, 0x14,
   0x86, 0x1b, 0x3e, 0x1e,
   0x92, 0x3b, 0x3c, 0xae,
-  0xef, 0xb4, 0x4e, 0xc8,
+  0xef, 0xb4, 0x4e, 0xe8,
   0xa1, 0x8b, 0x80, 0x8b,
   0xa1, 0x8b, 0x8a, 0x45,
   0x6e, 0x89, 0x0c, 0x05,
@@ -15544,7 +15545,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x33, 0xc0, 0x0a,
   0xc0, 0x0a, 0x69, 0x49,
   0x0c, 0x1d, 0x0c, 0x29,
-  0x44, 0x58, 0xc0, 0x2b,
+  0x44, 0x78, 0xc0, 0x2b,
   0x10, 0x0b, 0xcf, 0xe0,
   0x0c, 0x0c, 0xf8, 0xf1,
   0xdd, 0x93, 0xf2, 0x7c,
@@ -15559,7 +15560,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8e, 0x2b, 0x7c, 0x2e,
   0x95, 0x14, 0xbe, 0x1e,
   0xbc, 0x1e, 0x93, 0x44,
-  0x69, 0x38, 0x9d, 0x14,
+  0x69, 0x58, 0x9d, 0x14,
   0x17, 0xb4, 0xef, 0xb4,
   0xa1, 0x8b, 0x80, 0x8b,
   0x9f, 0xfc, 0x30, 0x18,
@@ -15664,17 +15665,17 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x67, 0x61, 0x0e, 0x60,
   0x10, 0x0b, 0xc0, 0xae,
   0x0c, 0x2b, 0x92, 0x1b,
-  0x6a, 0x18, 0x8e, 0x3b,
+  0x6a, 0x38, 0x8e, 0x3b,
   0xa1, 0x0b, 0xef, 0xcc,
   0x28, 0x24, 0x84, 0x55,
   0x12, 0x1b, 0x90, 0x0b,
-  0x6b, 0xf8, 0x8e, 0x3b,
+  0x6c, 0x18, 0x8e, 0x3b,
   0xa1, 0x0b, 0xef, 0xcc,
   0x00, 0x00, 0x14, 0x25,
   0x9c, 0x00, 0x40, 0x80,
   0x1c, 0x00, 0x42, 0x90,
   0x9c, 0x00, 0x46, 0x70,
-  0x8f, 0xcc, 0x68, 0xc8,
+  0x8f, 0xcc, 0x68, 0xe8,
   0x6e, 0x89, 0x0c, 0x15,
   0xa1, 0x0b, 0x40, 0x0a,
   0x6e, 0x8d, 0x0c, 0x25,
@@ -15693,7 +15694,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0e, 0x56, 0x40, 0x2b,
   0x02, 0x56, 0xe0, 0x0c,
   0x8c, 0x0b, 0x60, 0x0c,
-  0xef, 0xdc, 0x71, 0xc8,
+  0xef, 0xdc, 0x71, 0xe8,
   0x0c, 0x0c, 0x8e, 0x0b,
   0xdd, 0x93, 0xf2, 0x3c,
   0xf8, 0x7c, 0x04, 0x0c,
@@ -15844,7 +15845,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0xd5, 0x92, 0x8d,
   0x6a, 0x41, 0x0e, 0x89,
   0x00, 0x99, 0xc0, 0x1a,
-  0xc0, 0x38, 0x64, 0xe1,
+  0xc0, 0x38, 0x64, 0xd5,
   0xd2, 0x8d, 0xc3, 0x87,
   0x06, 0x41, 0x0e, 0x70,
   0x4e, 0x41, 0x80, 0x6b,
@@ -15918,7 +15919,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x10, 0x00, 0x06,
   0x5c, 0x00, 0x40, 0x60,
   0xdc, 0x00, 0x42, 0x70,
-  0xcf, 0xdc, 0x42, 0x88,
+  0xcf, 0xdc, 0x42, 0xa8,
   0x82, 0x71, 0x65, 0x0e,
   0xe2, 0x30, 0x0e, 0x0a,
   0x20, 0x14, 0xfa, 0xf5,
@@ -15940,14 +15941,14 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x65, 0x21, 0x08, 0x60,
   0x0a, 0x60, 0x40, 0xa2,
   0xc0, 0xa3, 0x66, 0xe1,
-  0x61, 0xf8, 0xbc, 0xce,
+  0x62, 0x18, 0xbc, 0xce,
   0xa1, 0x0b, 0xef, 0xc8,
   0x0e, 0x06, 0x02, 0xa5,
   0x0c, 0x29, 0x80, 0x00,
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x0c, 0x0e, 0x56,
   0x60, 0x0c, 0x02, 0x56,
-  0x51, 0xf8, 0x8c, 0x0b,
+  0x52, 0x18, 0x8c, 0x0b,
   0x0e, 0x0b, 0xef, 0xdc,
   0x0c, 0x0c, 0x98, 0xf1,
   0xdd, 0x93, 0xf2, 0x04,
@@ -15966,12 +15967,12 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x10, 0x15, 0xc0, 0xad,
   0xc0, 0x0a, 0x6d, 0x49,
   0x6c, 0x1d, 0x50, 0x31,
-  0x5c, 0x38, 0xc0, 0x2b,
+  0x5c, 0x58, 0xc0, 0x2b,
   0x80, 0x9b, 0xef, 0xc4,
   0x82, 0xc5, 0xa1, 0x9b,
   0x6c, 0x1d, 0x10, 0x29,
   0x90, 0x0b, 0x40, 0x2b,
-  0x6f, 0xdc, 0x4f, 0x08,
+  0x6f, 0xdc, 0x4f, 0x28,
   0x03, 0x11, 0x92, 0x1b,
   0x57, 0x18, 0x8c, 0x0b,
   0x15, 0x75, 0xef, 0xf0,
@@ -15982,17 +15983,17 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x10, 0x05, 0x80, 0x1e,
   0xc0, 0x0a, 0x6d, 0x59,
   0x6e, 0x0d, 0x10, 0x15,
-  0x5b, 0xd8, 0xc0, 0x09,
+  0x5b, 0xf8, 0xc0, 0x09,
   0x00, 0x00, 0xef, 0xc4,
   0xc0, 0x80, 0x64, 0x01,
   0xe1, 0xc0, 0x12, 0x04,
-  0x6f, 0xcc, 0x64, 0x68,
+  0x6f, 0xcc, 0x64, 0x88,
   0x10, 0x0b, 0x92, 0x0b,
-  0x6b, 0xb8, 0x92, 0x1b,
+  0x6b, 0xd8, 0x92, 0x1b,
   0x10, 0x0b, 0xef, 0xcc,
-  0x65, 0xb8, 0x92, 0x1b,
+  0x65, 0xd8, 0x92, 0x1b,
   0x10, 0x0b, 0xef, 0xcc,
-  0x68, 0x78, 0x92, 0x1b,
+  0x68, 0x98, 0x92, 0x1b,
   0x01, 0x46, 0xef, 0xcc,
   0x02, 0x86, 0x61, 0x18,
   0x80, 0x04, 0xe1, 0x18,
@@ -16055,7 +16056,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe1, 0x18, 0x00, 0xc6,
   0x80, 0xa6, 0x80, 0x04,
   0xe8, 0x20, 0x66, 0x08,
-  0xef, 0xcc, 0x4e, 0xe8,
+  0xef, 0xcc, 0x4f, 0x08,
   0x8c, 0x0b, 0x03, 0x11,
   0xef, 0xf0, 0x4c, 0xa8,
   0x98, 0xf1, 0x0e, 0x0b,
@@ -16107,7 +16108,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xee, 0xd5, 0xc1, 0x9d,
   0x6c, 0x1d, 0x10, 0x29,
   0x02, 0x36, 0x40, 0x2b,
-  0x7d, 0xf8, 0xe0, 0x08,
+  0x7e, 0x18, 0xe0, 0x08,
   0x90, 0x0b, 0x6f, 0xd8,
   0xe0, 0x08, 0x0e, 0x36,
   0x83, 0x11, 0x00, 0xab,
@@ -16118,7 +16119,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x10, 0x29, 0xef, 0x15,
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x02, 0x36,
-  0x6f, 0xd8, 0x7c, 0xa8,
+  0x6f, 0xd8, 0x7c, 0xc8,
   0x0e, 0x36, 0x90, 0x0b,
   0x00, 0xab, 0xe0, 0x08,
   0xfc, 0x04, 0x83, 0x11,
@@ -16188,7 +16189,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa4, 0x04, 0xef, 0xdc,
   0x02, 0x14, 0x80, 0x18,
   0x80, 0x16, 0xfc, 0x94,
-  0xef, 0xc8, 0x7e, 0x48,
+  0xef, 0xc8, 0x7e, 0x68,
   0x8e, 0x0b, 0x03, 0x11,
   0xef, 0xec, 0x7c, 0x08,
   0xe1, 0x18, 0x00, 0xc6,
@@ -16203,7 +16204,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x0a, 0xc0, 0x2b,
   0x0c, 0x09, 0xe0, 0x84,
   0xc0, 0x2b, 0x05, 0xa9,
-  0x43, 0x86, 0x8c, 0x95,
+  0x43, 0x06, 0x8c, 0x95,
   0x84, 0x18, 0xef, 0xdc,
   0x80, 0xb5, 0xa3, 0x1b,
   0x66, 0xe9, 0x0c, 0x09,
@@ -16271,7 +16272,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x0c, 0x86,
   0x60, 0x08, 0x02, 0x86,
-  0x69, 0x78, 0x8e, 0x0b,
+  0x69, 0x98, 0x8e, 0x0b,
   0xa3, 0x0b, 0xef, 0xd8,
   0xc0, 0x00, 0x0c, 0x06,
   0xe8, 0x20, 0x4a, 0x88,
@@ -16279,7 +16280,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xdd, 0x93, 0xf2, 0x04,
   0xfa, 0x00, 0x04, 0x0c,
   0x41, 0xf6, 0x01, 0x61,
-  0x57, 0xb8, 0xe0, 0x3c,
+  0x57, 0xd8, 0xe0, 0x3c,
   0x81, 0x11, 0x6f, 0x88,
   0xe1, 0x44, 0x41, 0xc6,
   0x80, 0x66, 0x80, 0x04,
@@ -16287,9 +16288,9 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xef, 0xdc, 0x71, 0x48,
   0xef, 0xdc, 0x73, 0x28,
   0x60, 0x3c, 0x41, 0xf6,
-  0x56, 0xb8, 0x83, 0x11,
+  0x56, 0xd8, 0x83, 0x11,
   0x0c, 0x0c, 0xef, 0x88,
-  0x33, 0x38, 0xf2, 0x00,
+  0x33, 0x58, 0xf2, 0x00,
   0xc1, 0xc3, 0xff, 0xc8,
   0xfa, 0x00, 0x04, 0x0c,
   0x40, 0xc6, 0x00, 0x6b,
@@ -16299,7 +16300,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x05, 0xc0, 0x06,
   0xc0, 0x0b, 0x66, 0x85,
   0x66, 0x85, 0x0c, 0x05,
-  0x77, 0x58, 0xc0, 0x0b,
+  0x77, 0x78, 0xc0, 0x0b,
   0x00, 0x04, 0xef, 0xc0,
   0x4c, 0x05, 0xfb, 0x80,
   0xc0, 0x0b, 0x66, 0x89,
@@ -16320,7 +16321,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x66, 0x79, 0x4c, 0x05,
   0x0c, 0x09, 0xc0, 0x0b,
   0xc0, 0x2b, 0x65, 0xcd,
-  0xef, 0xc0, 0x72, 0x88,
+  0xef, 0xc0, 0x72, 0xa8,
   0x6a, 0x05, 0x4c, 0x01,
   0x0c, 0x05, 0xc0, 0x2d,
   0xc0, 0x0b, 0x63, 0x7d,
@@ -16354,7 +16355,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x05, 0x41, 0x00, 0x60,
   0x80, 0x08, 0xc0, 0xad,
   0x91, 0x11, 0x04, 0x84,
-  0xef, 0xc0, 0x6e, 0x48,
+  0xef, 0xc0, 0x6e, 0x68,
   0x6a, 0x05, 0x4c, 0x01,
   0xa3, 0x7b, 0x40, 0x2d,
   0x03, 0x89, 0x0c, 0x85,
@@ -16513,7 +16514,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x04, 0x70, 0x00, 0x04,
   0xc0, 0xb6, 0x66, 0x41,
   0x64, 0xa0, 0x08, 0x60,
-  0x61, 0xf8, 0x8c, 0x3b,
+  0x62, 0x18, 0x8c, 0x3b,
   0x00, 0x8b, 0xef, 0x94,
   0xe0, 0x08, 0x41, 0x26,
   0x6c, 0x1d, 0x4e, 0x01,
@@ -16546,7 +16547,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x04, 0x80, 0x00, 0x04,
   0xc0, 0xb6, 0x66, 0x41,
   0x64, 0xa0, 0x08, 0x70,
-  0x5d, 0xd8, 0x8e, 0x3b,
+  0x5d, 0xf8, 0x8e, 0x3b,
   0x12, 0x29, 0xef, 0x94,
   0x40, 0x1b, 0x68, 0x81,
   0x10, 0x0b, 0x80, 0x6b,
@@ -16610,7 +16611,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x05, 0x82, 0x01,
   0xc0, 0x08, 0x69, 0x45,
   0x91, 0x11, 0x04, 0x08,
-  0xef, 0xc0, 0x4e, 0x48,
+  0xef, 0xc0, 0x4e, 0x68,
   0x65, 0x49, 0x4c, 0x01,
   0x0c, 0x0c, 0xc0, 0x22,
   0xdd, 0x93, 0xf2, 0x00,
@@ -16622,7 +16623,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x05, 0x82, 0x01,
   0xc0, 0x06, 0x6d, 0x4d,
   0x91, 0x11, 0x04, 0x08,
-  0xef, 0xc0, 0x4c, 0xc8,
+  0xef, 0xc0, 0x4c, 0xe8,
   0x6d, 0x01, 0x0c, 0x19,
   0x4c, 0x01, 0xc0, 0x2c,
   0xc0, 0x1b, 0x65, 0x69,
@@ -16637,7 +16638,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x19, 0xc0, 0x22,
   0xc0, 0x22, 0x65, 0x59,
   0x69, 0x5d, 0x4c, 0x05,
-  0x59, 0xd8, 0xc0, 0x08,
+  0x59, 0xf8, 0xc0, 0x08,
   0x4c, 0x05, 0xef, 0xc0,
   0x40, 0x08, 0x69, 0x61,
   0xe0, 0x0c, 0x43, 0xf6,
@@ -16660,7 +16661,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x29, 0x8b, 0x31,
   0xc0, 0x1b, 0x65, 0x69,
   0x65, 0x79, 0x0c, 0x19,
-  0x56, 0xf8, 0xc0, 0x1b,
+  0x57, 0x18, 0xc0, 0x1b,
   0x5d, 0x0e, 0xef, 0xc0,
   0xec, 0x04, 0x10, 0x80,
   0xfc, 0x35, 0xa1, 0x8b,
@@ -16673,7 +16674,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x6e, 0x64, 0x81,
   0x01, 0x95, 0xa1, 0x81,
   0x5d, 0x18, 0x8c, 0x9b,
-  0x5e, 0x58, 0x8c, 0x0b,
+  0x5e, 0x78, 0x8c, 0x0b,
   0x65, 0x0e, 0xef, 0xd4,
   0xec, 0x04, 0x10, 0x80,
   0xfe, 0x15, 0xa1, 0x8b,
@@ -16799,7 +16800,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x86, 0x40, 0x2b,
   0x02, 0x86, 0xe0, 0x08,
   0x90, 0x0b, 0x60, 0x08,
-  0xef, 0xd4, 0x67, 0x88,
+  0xef, 0xd4, 0x67, 0xa8,
   0x0b, 0x45, 0xa3, 0x0b,
   0xc0, 0x00, 0x0c, 0x06,
   0xef, 0xd8, 0x6e, 0x88,
@@ -17390,7 +17391,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x04, 0x02, 0x96,
   0x6c, 0x1d, 0x4c, 0x11,
   0x00, 0x16, 0xc0, 0x2b,
-  0x7b, 0xd8, 0x8c, 0x0b,
+  0x7b, 0xf8, 0x8c, 0x0b,
   0x0c, 0x09, 0xef, 0xc4,
   0xc0, 0x2c, 0x6d, 0x15,
   0x60, 0x88, 0x40, 0x0a,
@@ -17535,7 +17536,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0xc5, 0xa1, 0x0b,
   0xef, 0xd4, 0x57, 0x28,
   0x63, 0x29, 0x4c, 0x91,
-  0x55, 0xd8, 0xc0, 0x38,
+  0x55, 0xf8, 0xc0, 0x38,
   0x55, 0xb8, 0xef, 0xc0,
   0x00, 0x26, 0xef, 0xd4,
   0x42, 0x86, 0x60, 0x08,
@@ -17569,7 +17570,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x86, 0xc0, 0x38,
   0x80, 0x04, 0xe1, 0x3c,
   0xd0, 0x19, 0x80, 0x18,
-  0x51, 0x98, 0x80, 0x16,
+  0x51, 0xb8, 0x80, 0x16,
   0x0c, 0x09, 0xef, 0xc0,
   0xc0, 0x2c, 0x6e, 0xa9,
   0x01, 0x06, 0xa3, 0x0b,
@@ -17605,7 +17606,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc0, 0x38, 0x63, 0x29,
   0x92, 0x25, 0xa1, 0x0b,
   0xe9, 0x0d, 0xfc, 0x04,
-  0x4d, 0x18, 0x90, 0x25,
+  0x4d, 0x38, 0x90, 0x25,
   0x00, 0xc6, 0xef, 0xc0,
   0x57, 0x46, 0x61, 0x10,
   0x00, 0x04, 0xe1, 0x10,
@@ -17640,7 +17641,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4a, 0x18, 0x81, 0x85,
   0x4c, 0x91, 0xef, 0xd4,
   0xc0, 0x38, 0x63, 0x29,
-  0xef, 0xc0, 0x48, 0xc8,
+  0xef, 0xc0, 0x48, 0xe8,
   0x63, 0x15, 0x0c, 0x09,
   0x4f, 0x06, 0x40, 0x38,
   0xa5, 0x0b, 0xe1, 0x14,
@@ -17714,7 +17715,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2d, 0x67, 0xcd,
   0xe0, 0x0c, 0x0e, 0x36,
   0x60, 0x0c, 0x02, 0x36,
-  0x75, 0x18, 0x88, 0x0b,
+  0x75, 0x38, 0x88, 0x0b,
   0x23, 0x0b, 0xef, 0xcc,
   0x0e, 0x06, 0x98, 0xf1,
   0x8e, 0x0b, 0xc0, 0x00,
@@ -17820,7 +17821,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x16, 0x66, 0x35,
   0x0e, 0x29, 0x8e, 0x0b,
   0xc0, 0x2c, 0x6d, 0x09,
-  0x6f, 0xc8, 0x41, 0x68,
+  0x6f, 0xc8, 0x41, 0x88,
   0x80, 0x8b, 0x82, 0x19,
   0x6d, 0x41, 0x0e, 0x09,
   0x82, 0x01, 0xc0, 0x2c,
@@ -17922,7 +17923,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc0, 0x2c, 0x6c, 0xfd,
   0x88, 0xb5, 0xa1, 0x0b,
   0x60, 0x3c, 0x41, 0xf6,
-  0x4a, 0x58, 0x83, 0x11,
+  0x4a, 0x78, 0x83, 0x11,
   0x42, 0x06, 0xef, 0x7c,
   0x8c, 0x0b, 0x60, 0x00,
   0xef, 0xe0, 0x79, 0x48,
@@ -17954,7 +17955,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x98, 0xfe, 0x0e,
   0xc0, 0x00, 0x40, 0x01,
   0x64, 0x50, 0x02, 0xf0,
-  0x77, 0x78, 0x8c, 0x0b,
+  0x77, 0x98, 0x8c, 0x0b,
   0x80, 0xab, 0xef, 0xc8,
   0x60, 0x48, 0x02, 0x06,
   0x64, 0x98, 0x8c, 0x0b,
@@ -17986,7 +17987,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe4, 0x40, 0x0a, 0xf0,
   0x8c, 0x1b, 0x0c, 0x0b,
   0x96, 0x4b, 0x7c, 0x24,
-  0xef, 0xc8, 0x75, 0x68,
+  0xef, 0xc8, 0x75, 0x88,
   0xa1, 0xab, 0x80, 0xab,
   0x7e, 0x14, 0x84, 0xb5,
   0x91, 0x0a, 0x81, 0xa1,
@@ -18071,7 +18072,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xf2, 0x84, 0x0c, 0x0c,
   0xc1, 0xc3, 0xdd, 0x93,
   0xfa, 0x0c, 0x04, 0x0c,
-  0x0b, 0x06, 0x00, 0x6b,
+  0x0a, 0x86, 0x00, 0x6b,
   0x0c, 0x09, 0xef, 0xdc,
   0xc0, 0x2c, 0x6d, 0x0d,
   0x6d, 0x15, 0x0c, 0x19,
@@ -18132,7 +18133,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6c, 0x11, 0x0c, 0x09,
   0x40, 0x0a, 0xc0, 0x2b,
   0x84, 0x65, 0xe0, 0x94,
-  0xef, 0xdc, 0x40, 0x86,
+  0xef, 0xdc, 0x40, 0x06,
   0x40, 0x0a, 0x80, 0x08,
   0x82, 0xb5, 0xe0, 0x80,
   0x6c, 0x21, 0x0c, 0x09,
@@ -18164,7 +18165,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x85, 0x15, 0x80, 0x2b,
   0xe0, 0x00, 0x42, 0x46,
   0x6c, 0x1d, 0x40, 0x11,
-  0x03, 0x06, 0x40, 0x2b,
+  0x02, 0x86, 0x40, 0x2b,
   0x84, 0x28, 0xef, 0xdc,
   0xf0, 0xc0, 0x44, 0x20,
   0xe0, 0x40, 0x04, 0x0a,
@@ -18181,7 +18182,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6e, 0x09, 0x00, 0x1b,
   0xc4, 0x19, 0xc0, 0x15,
   0x6e, 0x09, 0x40, 0x13,
-  0x01, 0x06, 0x40, 0x15,
+  0x00, 0x86, 0x40, 0x15,
   0x80, 0x18, 0xef, 0xdc,
   0xf3, 0xf8, 0x42, 0x10,
   0xdd, 0x93, 0x80, 0x16,
@@ -18201,16 +18202,16 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x04, 0xc0, 0xff,
   0x4e, 0x03, 0xfc, 0x94,
   0x40, 0x15, 0x6e, 0x09,
-  0x60, 0x78, 0x8e, 0x0b,
+  0x60, 0x98, 0x8e, 0x0b,
   0x48, 0x38, 0xef, 0xbc,
   0x8e, 0x0b, 0x68, 0x00,
   0x64, 0xd5, 0x0e, 0x09,
   0xa7, 0x0b, 0xc0, 0x2b,
   0xa5, 0x0b, 0x86, 0x05,
-  0x01, 0x06, 0x08, 0xc5,
+  0x00, 0x86, 0x08, 0xc5,
   0xa3, 0x0b, 0x8f, 0xdc,
   0x03, 0xd5, 0x88, 0xf5,
-  0xef, 0xdc, 0x01, 0x06,
+  0xef, 0xdc, 0x00, 0x86,
   0x6e, 0x09, 0x0e, 0x0b,
   0x40, 0x00, 0xc0, 0x15,
   0xc0, 0xff, 0x73, 0x71,
@@ -18218,7 +18219,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6e, 0x09, 0x4e, 0x03,
   0x0c, 0x0c, 0xc0, 0x15,
   0xdd, 0x93, 0xf2, 0x9c,
-  0xef, 0xdc, 0x01, 0x06,
+  0xef, 0xdc, 0x00, 0x86,
   0x42, 0x4a, 0x80, 0x18,
   0x80, 0xe5, 0xe0, 0x8c,
   0x6c, 0x15, 0x0e, 0x19,
@@ -18227,10 +18228,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x01, 0x55, 0x80, 0x08,
   0xfc, 0x08, 0x00, 0x04,
   0xc8, 0x09, 0x80, 0x08,
-  0xef, 0xdc, 0x03, 0x06,
+  0xef, 0xdc, 0x02, 0x86,
   0x4f, 0x98, 0x84, 0x06,
   0x8e, 0x0b, 0x6f, 0xe4,
-  0xef, 0xdc, 0x13, 0x06,
+  0xef, 0xdc, 0x12, 0x86,
   0x40, 0x0a, 0xa4, 0x08,
   0x82, 0xb5, 0xe0, 0x80,
   0x40, 0x0a, 0xa4, 0x08,
@@ -18261,7 +18262,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x8e, 0x0b, 0x40, 0x15,
   0xef, 0xe0, 0x4f, 0x88,
   0x60, 0x3c, 0x41, 0xf6,
-  0x5f, 0xf8, 0x83, 0x11,
+  0x60, 0x18, 0x83, 0x11,
   0x47, 0xd8, 0xef, 0x78,
   0x52, 0x81, 0xef, 0xf0,
   0x03, 0x11, 0xe0, 0xa0,
@@ -18280,7 +18281,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x08, 0x34, 0xc5, 0x07,
   0xf0, 0x0c, 0x44, 0x00,
   0x68, 0x10, 0x79, 0xa8,
-  0x03, 0x06, 0x8c, 0x0b,
+  0x02, 0x86, 0x8c, 0x0b,
   0x48, 0x86, 0x6f, 0xdc,
   0x86, 0x0e, 0xe0, 0x3c,
   0xc4, 0x24, 0x86, 0x04,
@@ -18338,7 +18339,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xa1, 0xab, 0x80, 0xa8,
   0x0c, 0x29, 0x82, 0x65,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x67, 0x18, 0x8c, 0x0b,
+  0x67, 0x38, 0x8c, 0x0b,
   0x94, 0x1b, 0x6f, 0xc8,
   0x0e, 0x08, 0xa1, 0x0b,
   0x0e, 0x60, 0xc0, 0x00,
@@ -18409,7 +18410,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6c, 0x1d, 0x4c, 0x01,
   0x9e, 0x29, 0x40, 0x2b,
   0x8c, 0x0b, 0x02, 0x19,
-  0xef, 0xc0, 0x77, 0xc8,
+  0xef, 0xc0, 0x77, 0xe8,
   0xa1, 0xab, 0x80, 0xab,
   0x41, 0x76, 0x8e, 0x95,
   0x4c, 0x01, 0xe0, 0x00,
@@ -18451,7 +18452,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x00, 0x41, 0xa6,
   0x6c, 0x1d, 0x4c, 0x01,
   0x40, 0x60, 0x40, 0x2b,
-  0x53, 0xb8, 0x9c, 0x00,
+  0x53, 0xd8, 0x9c, 0x00,
   0x94, 0x0b, 0x8f, 0xc8,
   0xf2, 0x7c, 0x0c, 0x4c,
   0xc1, 0xc3, 0xdd, 0x93,
@@ -18520,7 +18521,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc0, 0x16, 0x66, 0x35,
   0xe0, 0xa4, 0x42, 0x0a,
   0x03, 0x11, 0x82, 0x85,
-  0x4e, 0x58, 0x81, 0x21,
+  0x4e, 0x78, 0x81, 0x21,
   0x8c, 0x0b, 0x6f, 0xc0,
   0xa1, 0x7b, 0x80, 0x7b,
   0x0c, 0x1b, 0x9c, 0x35,
@@ -18558,7 +18559,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0xa2, 0x66, 0x71,
   0xe4, 0x30, 0x00, 0xf0,
   0x06, 0xf0, 0x21, 0x56,
-  0x7f, 0x38, 0xe4, 0x10,
+  0x7f, 0x58, 0xe4, 0x10,
   0xa1, 0x0b, 0xef, 0x80,
   0x0c, 0x1d, 0x0c, 0x29,
   0x02, 0x06, 0x40, 0x2b,
@@ -18568,7 +18569,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x21, 0xc0, 0x9e,
   0x40, 0x2b, 0x6c, 0x1d,
   0x64, 0xa1, 0x02, 0x60,
-  0x77, 0xf8, 0xc0, 0xa3,
+  0x78, 0x18, 0xc0, 0xa3,
   0xa1, 0x0b, 0xef, 0x80,
   0x0c, 0x29, 0x86, 0x05,
   0x40, 0x2b, 0x6c, 0x1d,
@@ -18578,7 +18579,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x4c, 0x05, 0xe0, 0x0c,
   0x40, 0x0a, 0x6e, 0x89,
   0xe0, 0x0c, 0x02, 0x56,
-  0x6f, 0xc8, 0x49, 0x28,
+  0x6f, 0xc8, 0x49, 0x48,
   0x0e, 0x0b, 0x8c, 0x0b,
   0x0c, 0x0c, 0xa8, 0xf1,
   0xdd, 0x93, 0xf2, 0x04,
@@ -18597,7 +18598,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x19, 0xc0, 0xa3,
   0xc0, 0x15, 0x63, 0x09,
   0x6c, 0x1d, 0x4c, 0x51,
-  0x62, 0x58, 0xc0, 0x2b,
+  0x62, 0x78, 0xc0, 0x2b,
   0x0c, 0x09, 0xef, 0xa0,
   0xc0, 0x2b, 0x6c, 0x11,
   0x60, 0x94, 0x40, 0x4a,
@@ -18610,11 +18611,11 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x64, 0xc1, 0x04, 0x60,
   0x06, 0x60, 0x40, 0xad,
   0xc0, 0xad, 0x65, 0x21,
-  0x6f, 0xac, 0x72, 0x68,
+  0x6f, 0xac, 0x72, 0x88,
   0x66, 0x20, 0x08, 0x60,
   0x00, 0x60, 0xc0, 0xae,
   0x40, 0xd8, 0x65, 0x61,
-  0x70, 0x58, 0x81, 0x11,
+  0x70, 0x78, 0x81, 0x11,
   0x04, 0xc6, 0x6f, 0x70,
   0x77, 0x65, 0xe0, 0x10,
   0xc1, 0xc3, 0x81, 0x71,
@@ -18623,7 +18624,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x03, 0x16, 0x40, 0x2c,
   0x40, 0x11, 0xe0, 0x08,
   0x40, 0x2b, 0x6c, 0x1d,
-  0xef, 0xdc, 0x48, 0x86,
+  0xef, 0xdc, 0x48, 0x06,
   0x6c, 0x79, 0x00, 0x19,
   0x00, 0x79, 0xc0, 0x2c,
   0x40, 0x2c, 0x6c, 0x75,
@@ -18681,7 +18682,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x58, 0x80, 0x01, 0x55,
   0x58, 0xc0, 0xfc, 0x18,
   0x08, 0xbb, 0xf3, 0xe0,
-  0xef, 0xdc, 0x48, 0x86,
+  0xef, 0xdc, 0x48, 0x06,
   0x6d, 0x0d, 0x40, 0xc1,
   0x58, 0x0a, 0x40, 0x2c,
   0x82, 0xc5, 0xe0, 0x84,
@@ -18775,7 +18776,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x46, 0x40, 0x2b,
   0x02, 0x46, 0xe0, 0x0c,
   0x8e, 0x0b, 0x60, 0x0c,
-  0xef, 0xc4, 0x70, 0x88,
+  0xef, 0xc4, 0x70, 0xa8,
   0x0c, 0x06, 0xa1, 0x0b,
   0x8c, 0x0b, 0x80, 0x00,
   0xf2, 0x04, 0x0c, 0x4c,
@@ -18827,7 +18828,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x84, 0x85, 0xa5, 0x3b,
   0x84, 0x85, 0xa7, 0x3b,
   0x5c, 0x08, 0xa1, 0x3b,
-  0x0f, 0xb8, 0xda, 0x00,
+  0x0f, 0xd8, 0xda, 0x00,
   0x89, 0x75, 0xff, 0x70,
   0x5c, 0x08, 0xa1, 0x2b,
   0x45, 0x34, 0x9a, 0x00,
@@ -19081,7 +19082,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x92, 0x83, 0x07, 0x65,
   0x6c, 0x1d, 0x0c, 0x29,
   0x43, 0x76, 0x40, 0x2b,
-  0x4a, 0x38, 0xe0, 0x00,
+  0x4a, 0x58, 0xe0, 0x00,
   0x8c, 0x0b, 0x6f, 0xc4,
   0x5e, 0xb1, 0xa1, 0x0b,
   0x5e, 0xa1, 0xc1, 0x30,
@@ -19131,7 +19132,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x83, 0x85, 0x80, 0xd0,
   0x6c, 0x1d, 0x0c, 0x29,
   0x43, 0x76, 0x40, 0x2b,
-  0x43, 0xf8, 0xe0, 0x00,
+  0x44, 0x18, 0xe0, 0x00,
   0x8c, 0x0b, 0x6f, 0xc4,
   0xe0, 0x00, 0x4f, 0x76,
   0x0f, 0x48, 0xa1, 0x0b,
@@ -19310,7 +19311,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x81, 0xc5, 0xea, 0x15,
   0x6c, 0x1d, 0x00, 0x29,
   0x43, 0x66, 0x40, 0x2b,
-  0x6d, 0x98, 0xe0, 0x08,
+  0x6d, 0xb8, 0xe0, 0x08,
   0x4d, 0x66, 0x6f, 0xc0,
   0xa1, 0x0b, 0xe0, 0x08,
   0x81, 0x61, 0x80, 0x55,
@@ -19386,7 +19387,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xe0, 0x80, 0x40, 0x0a,
   0x05, 0x01, 0x00, 0x60,
   0x02, 0x06, 0x40, 0x9b,
-  0x4f, 0xd8, 0xc0, 0x00,
+  0x4f, 0xf8, 0xc0, 0x00,
   0x04, 0x06, 0x4f, 0x6c,
   0x0c, 0x09, 0xc0, 0x18,
   0xc0, 0x2b, 0x6c, 0x21,
@@ -19399,7 +19400,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xef, 0xf4, 0x7a, 0xc8,
   0x6d, 0x21, 0x0c, 0x09,
   0x80, 0x7b, 0x40, 0x2c,
-  0x43, 0x86, 0x21, 0x7b,
+  0x43, 0x06, 0x21, 0x7b,
   0x83, 0x21, 0xef, 0xdc,
   0x40, 0x00, 0x04, 0x26,
   0xc4, 0x09, 0xf3, 0xf0,
@@ -19407,7 +19408,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0x65, 0xc0, 0x2c,
   0x6c, 0x1d, 0x0c, 0x29,
   0x8c, 0x0b, 0x40, 0x2b,
-  0x6f, 0xc0, 0x61, 0x88,
+  0x6f, 0xc0, 0x61, 0xa8,
   0xa1, 0x0b, 0x8e, 0x1b,
   0xc0, 0x00, 0x0c, 0x38,
   0x81, 0x11, 0x01, 0x71,
@@ -19437,7 +19438,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0x45, 0xa1, 0x7b,
   0x6c, 0x1d, 0x0c, 0x29,
   0x8c, 0x0b, 0x40, 0x2b,
-  0x6f, 0xc0, 0x5d, 0xc8,
+  0x6f, 0xc0, 0x5d, 0xe8,
   0xa1, 0x0b, 0x8e, 0x1b,
   0x02, 0xf0, 0xa0, 0xf5,
   0x8c, 0x0b, 0x64, 0x20,
@@ -19503,8 +19504,8 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x67, 0xf5, 0x4c, 0x01,
   0x4c, 0xa1, 0xc0, 0x27,
   0x40, 0x26, 0x6c, 0xf1,
-  0x73, 0xb8, 0x8c, 0x0b,
-  0x41, 0x86, 0xef, 0xb4,
+  0x73, 0xd8, 0x8c, 0x0b,
+  0x41, 0x06, 0xef, 0xb4,
   0x81, 0x11, 0x6f, 0xdc,
   0x0e, 0x0b, 0x80, 0x16,
   0x0c, 0x0c, 0x98, 0xf1,
@@ -19562,7 +19563,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6d, 0x59, 0x0c, 0x05,
   0x91, 0x21, 0x40, 0x0a,
   0x6e, 0x0d, 0x0c, 0x15,
-  0x5e, 0x98, 0xc0, 0x09,
+  0x5e, 0xb8, 0xc0, 0x09,
   0x0c, 0x29, 0xef, 0xa8,
   0x40, 0x2b, 0x65, 0x51,
   0xe1, 0x18, 0x43, 0x46,
@@ -19572,17 +19573,17 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x9e, 0x49, 0xc0, 0x0b,
   0x8e, 0x19, 0xc9, 0x17,
   0x02, 0x24, 0x23, 0x5f,
-  0x63, 0xd8, 0xe0, 0x90,
+  0x63, 0xf8, 0xe0, 0x90,
   0x04, 0x54, 0x6f, 0xa8,
   0x46, 0x78, 0xe8, 0x90,
   0x80, 0x8b, 0x6f, 0xe8,
   0x60, 0x10, 0x02, 0x06,
-  0x65, 0x78, 0x90, 0x2b,
+  0x65, 0x98, 0x90, 0x2b,
   0x8e, 0x3b, 0x6f, 0xa8,
   0xa1, 0x7b, 0x80, 0x7b,
   0x0c, 0x29, 0x82, 0xe5,
   0x40, 0x2b, 0x6c, 0x1d,
-  0x4b, 0x98, 0x8c, 0x0b,
+  0x4b, 0xb8, 0x8c, 0x0b,
   0x8e, 0x1b, 0x6f, 0xc0,
   0x0e, 0x06, 0xa3, 0x0b,
   0x8e, 0x0b, 0xc0, 0x00,
@@ -19633,7 +19634,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x0b, 0x63, 0x15,
   0x40, 0x33, 0xa4, 0x3f,
   0x40, 0x16, 0x66, 0x35,
-  0xef, 0xdc, 0x09, 0x06,
+  0xef, 0xdc, 0x08, 0x86,
   0x60, 0x24, 0x02, 0x29,
   0xfc, 0x0c, 0x06, 0x34,
   0xc2, 0x27, 0x90, 0x58,
@@ -19984,7 +19985,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x11, 0xa6, 0x40, 0x2b,
   0x03, 0xa6, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xbc, 0x59, 0x68,
+  0xef, 0xbc, 0x59, 0x88,
   0x9a, 0x85, 0xa3, 0x0b,
   0xe1, 0x2c, 0x54, 0xc6,
   0x80, 0x08, 0xa8, 0x04,
@@ -19996,7 +19997,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x11, 0xa6, 0x40, 0x2b,
   0x03, 0xa6, 0xe0, 0x08,
   0x8c, 0x0b, 0x60, 0x08,
-  0xef, 0xbc, 0x57, 0xe8,
+  0xef, 0xbc, 0x58, 0x08,
   0x94, 0x85, 0xa3, 0x0b,
   0xe4, 0x7d, 0x24, 0x04,
   0x88, 0xd5, 0x80, 0x18,
@@ -20036,7 +20037,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x6c, 0x1d, 0x0c, 0x29,
   0x11, 0xc6, 0x40, 0x2b,
   0x03, 0xc6, 0xe0, 0x08,
-  0x52, 0xd8, 0xe0, 0x08,
+  0x52, 0xf8, 0xe0, 0x08,
   0x8c, 0x0b, 0x6f, 0xbc,
   0x80, 0x45, 0xa3, 0x0b,
   0x73, 0xd8, 0x81, 0x81,
@@ -20134,7 +20135,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x0f, 0xa6,
   0x60, 0x08, 0x03, 0xa6,
-  0x46, 0x98, 0x8c, 0x0b,
+  0x46, 0xb8, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xbc,
   0x28, 0x04, 0x8a, 0x45,
   0xe0, 0x3c, 0x42, 0x86,
@@ -20154,7 +20155,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x40, 0x2b, 0x6c, 0x1d,
   0xe0, 0x08, 0x0f, 0xc6,
   0x60, 0x08, 0x03, 0xc6,
-  0x44, 0x18, 0x8c, 0x0b,
+  0x44, 0x38, 0x8c, 0x0b,
   0xa3, 0x0b, 0xef, 0xbc,
   0x81, 0x71, 0x80, 0x45,
   0xe8, 0x00, 0x65, 0x28,
@@ -20554,7 +20555,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x19, 0xc0, 0x2b,
   0xc0, 0x2b, 0x65, 0x39,
   0x65, 0x35, 0x0c, 0x09,
-  0x64, 0x98, 0xc0, 0x2b,
+  0x64, 0xb8, 0xc0, 0x2b,
   0x00, 0x8b, 0xef, 0xa0,
   0xe1, 0x04, 0x01, 0x46,
   0x90, 0x2b, 0x00, 0x04,
@@ -20562,29 +20563,29 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0xc0, 0x09, 0x6e, 0x0d,
   0x65, 0x41, 0x0c, 0x39,
   0x92, 0x0b, 0xc0, 0x2b,
-  0x6f, 0xa0, 0x64, 0x68,
+  0x6f, 0xa0, 0x64, 0x88,
   0x4c, 0x05, 0x94, 0x1b,
   0x40, 0x0b, 0x63, 0x6d,
   0x0c, 0x39, 0x92, 0x0b,
   0x40, 0x2b, 0x65, 0x49,
-  0x63, 0xb8, 0x94, 0x1b,
+  0x63, 0xd8, 0x94, 0x1b,
   0x90, 0x2b, 0x6f, 0xa0,
   0x63, 0x65, 0x4c, 0x05,
   0x92, 0x0b, 0x40, 0x0b,
   0x65, 0x45, 0x0c, 0x39,
   0x94, 0x1b, 0x40, 0x2b,
-  0x6f, 0xa0, 0x63, 0x08,
+  0x6f, 0xa0, 0x63, 0x28,
   0x4c, 0x05, 0x90, 0x2b,
   0x40, 0x0b, 0x63, 0x71,
   0x0c, 0x39, 0x92, 0x0b,
   0x40, 0x2b, 0x65, 0x4d,
-  0x62, 0x58, 0x94, 0x1b,
+  0x62, 0x78, 0x94, 0x1b,
   0x90, 0x2b, 0x6f, 0xa0,
   0x6d, 0x59, 0x0c, 0x15,
   0x91, 0x21, 0x40, 0x0a,
   0x63, 0x69, 0x4c, 0x05,
   0x02, 0x0b, 0xc0, 0x0b,
-  0x5e, 0xd8, 0x94, 0x1b,
+  0x5e, 0xf8, 0x94, 0x1b,
   0x4c, 0x05, 0xef, 0xa0,
   0x40, 0x06, 0x6d, 0x49,
   0xe1, 0x1c, 0x02, 0x86,
@@ -20670,7 +20671,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x80, 0xad, 0x05, 0x45,
   0x05, 0x41, 0x00, 0x60,
   0x80, 0x88, 0xc0, 0xad,
-  0x6f, 0xa0, 0x4d, 0xe8,
+  0x6f, 0xa0, 0x4e, 0x08,
   0x02, 0x94, 0x90, 0x0b,
   0x81, 0x41, 0x7a, 0x80,
   0x61, 0x02, 0x46, 0x1a,
@@ -20755,9 +20756,9 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x50, 0x01, 0xe0, 0x08,
   0x40, 0x2b, 0x6c, 0x1d,
   0x06, 0x7b, 0x88, 0xab,
-  0x4d, 0xf8, 0x84, 0x9b,
+  0x4e, 0x18, 0x84, 0x9b,
   0x82, 0x0b, 0x6f, 0xa0,
-  0x6f, 0xa0, 0x4f, 0x48,
+  0x6f, 0xa0, 0x4f, 0x68,
   0x21, 0x0b, 0x80, 0x6b,
   0x02, 0x06, 0xff, 0x11,
   0xa3, 0xab, 0x00, 0x00,
@@ -20797,7 +20798,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x29, 0xc6, 0x2d,
   0x40, 0x2b, 0x0c, 0x1d,
   0xc0, 0x08, 0x42, 0x96,
-  0xcf, 0xb4, 0x73, 0xc8,
+  0xcf, 0xb4, 0x73, 0xe8,
   0x60, 0x01, 0x00, 0x06,
   0x81, 0x31, 0x7d, 0x09,
   0xe0, 0x1e, 0x40, 0x0a,
@@ -20807,13 +20808,13 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x42, 0x22, 0xc7, 0xa1,
   0x04, 0x0e, 0x72, 0x8c,
   0xc0, 0x03, 0x74, 0x24,
-  0x6f, 0x5c, 0x74, 0x68,
+  0x6f, 0x5c, 0x74, 0x88,
   0x0c, 0x4c, 0x81, 0x31,
   0xdd, 0x93, 0xf2, 0x04,
   0xfa, 0x00, 0x04, 0x0c,
   0x6c, 0x01, 0x0c, 0x12,
   0x81, 0x11, 0x40, 0x28,
-  0x6f, 0x60, 0x5d, 0x88,
+  0x6f, 0x60, 0x5d, 0xa8,
   0x8c, 0x0b, 0x8c, 0x2b,
   0xf2, 0x00, 0x0c, 0x0c,
   0xc1, 0xc3, 0xdd, 0x93,
@@ -20826,7 +20827,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0x45, 0x87, 0x1b,
   0x60, 0x08, 0x03, 0x66,
   0xe0, 0x08, 0x0d, 0x66,
-  0xef, 0xb4, 0x70, 0x28,
+  0xef, 0xb4, 0x70, 0x48,
   0x0c, 0x06, 0xa1, 0x0b,
   0x8c, 0x0b, 0x80, 0x00,
   0xf2, 0x00, 0x0c, 0x0c,
@@ -20840,7 +20841,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0x45, 0x87, 0x1b,
   0x60, 0x08, 0x03, 0x76,
   0xe0, 0x08, 0x0d, 0x76,
-  0xef, 0xb4, 0x6e, 0x68,
+  0xef, 0xb4, 0x6e, 0x88,
   0x0c, 0x06, 0xa1, 0x0b,
   0x8c, 0x0b, 0x80, 0x00,
   0xf2, 0x00, 0x0c, 0x0c,
@@ -20855,7 +20856,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x82, 0x45, 0x87, 0x1b,
   0x60, 0x08, 0x03, 0x86,
   0xe0, 0x08, 0x0d, 0x86,
-  0xef, 0xb4, 0x6c, 0x88,
+  0xef, 0xb4, 0x6c, 0xa8,
   0x0c, 0x06, 0xa1, 0x0b,
   0x8c, 0x0b, 0x80, 0x00,
   0xf2, 0x00, 0x0c, 0x0c,
@@ -20869,7 +20870,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x87, 0x1b, 0x9e, 0x39,
   0x03, 0x96, 0x82, 0x45,
   0x0d, 0x96, 0x60, 0x08,
-  0x6a, 0xb8, 0xe0, 0x08,
+  0x6a, 0xd8, 0xe0, 0x08,
   0xa1, 0x0b, 0xef, 0xb4,
   0x80, 0x00, 0x0c, 0x06,
   0x0c, 0x0c, 0x8c, 0x0b,
@@ -20935,7 +20936,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x60, 0xe0, 0x90,
   0x40, 0x99, 0x06, 0xf1,
   0xc0, 0x00, 0x02, 0x06,
-  0x4f, 0x60, 0x4e, 0x48,
+  0x4f, 0x60, 0x4e, 0x68,
   0xc0, 0x18, 0x04, 0x06,
   0x15, 0x86, 0x0f, 0xbe,
   0x01, 0x01, 0xe1, 0x00,
@@ -20957,7 +20958,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x84, 0x08, 0xc0, 0x26,
   0x41, 0xf6, 0x82, 0x65,
   0x81, 0x11, 0x60, 0x3c,
-  0xef, 0x64, 0x4f, 0x08,
+  0xef, 0x64, 0x4f, 0x28,
   0x60, 0x0c, 0x43, 0x06,
   0x60, 0x78, 0x8c, 0x0b,
   0x59, 0x38, 0xef, 0xc8,
@@ -20991,7 +20992,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x66, 0xed, 0x4c, 0x21,
   0x04, 0x06, 0xc0, 0x26,
   0xe0, 0x3c, 0x41, 0xf6,
-  0x6f, 0x64, 0x4a, 0xc8,
+  0x6f, 0x64, 0x4a, 0xe8,
   0x43, 0x06, 0x81, 0x11,
   0x8c, 0x0b, 0x60, 0x0c,
   0xef, 0xc8, 0x5c, 0x28,
@@ -21088,7 +21089,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x83, 0x45, 0xfc, 0x15,
   0x6c, 0x1d, 0x0c, 0x29,
   0x42, 0x96, 0x40, 0x2b,
-  0x4f, 0x58, 0xe0, 0x08,
+  0x4f, 0x78, 0xe0, 0x08,
   0x8c, 0x0b, 0x6f, 0xb4,
   0xe0, 0x08, 0x4e, 0x96,
   0x66, 0x71, 0x0c, 0x1b,
@@ -21194,10 +21195,10 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x0c, 0x0c, 0xb0, 0xf1,
   0xdd, 0x93, 0xf0, 0x7c,
   0x00, 0x00, 0x10, 0x14,
-  0x00, 0x43, 0x4a, 0xb4,
+  0x00, 0x43, 0x4a, 0xb0,
   0x00, 0x00, 0x09, 0x2c,
   0x00, 0x00, 0x1a, 0x24,
-  0x00, 0x43, 0x54, 0xc4,
+  0x00, 0x43, 0x54, 0xc0,
   0x00, 0x00, 0x00, 0x20,
   0x00, 0x00, 0x19, 0x44,
   0x00, 0x00, 0x00, 0x00,
@@ -21514,7 +21515,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x00, 0x00, 0x64,
   0x00, 0x00, 0xbb, 0x80,
   0x00, 0x00, 0x1a, 0x48,
-  0x00, 0x00, 0xfb, 0x88,
+  0x00, 0x00, 0xfb, 0x80,
   0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00,
@@ -21541,6 +21542,7 @@ const uint8_t VL53LMZ_FIRMWARE[] = {
   0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00,
 
 };
 
@@ -21721,7 +21723,7 @@ const uint8_t VL53L8_DEFAULT_CONFIGURATION[] = {
   0xB5, 0xF0, 0x00, 0x40,
   0x00, 0xFF, 0x00, 0x00,
   0xB3, 0x9C, 0x01, 0x00,
-  0x40, 0x00, 0x05, 0x1E,
+  0x34, 0x9B, 0x04, 0x35,
   0x02, 0x1B, 0x08, 0x7C,
   0x80, 0x00, 0x12, 0x01,
   0x00, 0x01, 0x08, 0x00,
diff --git a/src/vl53lmz_plugin_cnh.h b/src/vl53lmz_plugin_cnh.h
index cac2eda..7e83346 100644
--- a/src/vl53lmz_plugin_cnh.h
+++ b/src/vl53lmz_plugin_cnh.h
@@ -58,7 +58,7 @@ extern "C" {
  */
 typedef uint32_t cnh_data_buffer_t[VL53LMZ_CNH_MAX_DATA_WORDS];
 
-#define VL53LMZ_CNH_DATA_IDX      ((uint32_t)0xC048U)
+#define VL53LMZ_CNH_DATA_IDX      ((uint16_t)0xC048U)
 #define VL53LMZ_CNH_DATA_BH       ((uint32_t)((VL53LMZ_CNH_DATA_IDX<<16)+((sizeof(cnh_data_buffer_t)<<4)))