iodine 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf89fce9c0e4b457fb88d8871bc61e81517fdb9bfe227627394f8c06753829c1
-  data.tar.gz: 20f66f4a8fe102b9c9e59ee2eda6ed27e0f65e880a42c953554df8b3ead6ca11
+  metadata.gz: 6853939131113d6d1055ae516e38fb0f5ced25fa9fdc6f1915e2fb59cd7af749
+  data.tar.gz: 628c7b663864b8f99a79e6a37ebe26be080e5f4bed537715717c7e2879e1cbaa
 SHA512:
-  metadata.gz: 4967888c32c01259d933576876d07d66612ac71689dfb93ae8dad8e08675a4908e654d76ebb9e44cf4f9fb87b657a068fb97520648b89df6daae2bfe4a191f55
-  data.tar.gz: 11170c43eece7c6a6627408e40c5f5751abde9b5e330ba97c8f19c6643e0cf842d70c7a3dfaaf2b18b6fb30894cf48563d2d56ffc9cc70fa58809eb5e30c2983
+  metadata.gz: 133121bf7da250b83f7e4131e68b09cc66bc972a91338ad54e77597c2ed433e8b86be546ce80272414573c386ed043a681c8255fc4316599c1686eb72d2fb144
+  data.tar.gz: e28e559b199684495cbf767cd75983aa51859b0544c3017f314ef848add51c088adf4551d1ab7abe7a4ec331580fbc25c802c1ff0860ae2c437a58864628de9f

data/CHANGELOG.md

@@ -6,11 +6,21 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.4
+
+**Fix**: fixed a missing `static` keyword in the Ruby<=>C storage bridge which caused performance degradation and introduced namespace conflict risks.
+
+**Fix**: fixed the `on_worker_fork` callback timing, to be performed before forking the process (Puma compatibility).
+
+**Fix**: fixes to minor issues are included in the facil.io edge update.
+
+**Optimize**: minor optimization to memory use, included in facil.io edge updates.
+
 #### Change log v.0.7.3
 
-**Fix**: (facil.io) updating facil.io fixes a channel name memory leak fixed in facil.io's edge version.
+**Fix**: (facil.io) updating facil.io fixes a channel name memory leak that was fixed in facil.io's edge version.
 
-**Updated**: Improved logging for server data, allowing for log silencing.
+**Updated**: Improved logging for server data, allowing for total log silencing - this doesn't effect HTTP logging, only iodine's core logging system.
 
 #### Change log v.0.7.2
 

data/ext/iodine/fio.c

@@ -3544,6 +3544,79 @@ Section Start Marker
 Strings to Numbers
 ***************************************************************************** */
 
+FIO_FUNC inline size_t fio_atol_skip_zero(char **pstr) {
+  char *const start = *pstr;
+  while (**pstr == '0') {
+    ++(*pstr);
+  }
+  return (size_t)(*pstr - *start);
+}
+
+/* consumes any digits in the string (base 2-10), returning their value */
+FIO_FUNC inline uint64_t fio_atol_consume(char **pstr, uint8_t base) {
+  uint64_t result = 0;
+  const uint64_t limit = UINT64_MAX - (base * base);
+  while (**pstr >= '0' && **pstr < ('0' + base) && result <= (limit)) {
+    result = (result * base) + (**pstr - '0');
+    ++(*pstr);
+  }
+  return result;
+}
+
+/* returns true if there's data to be skipped */
+FIO_FUNC inline uint8_t fio_atol_skip_test(char **pstr, uint8_t base) {
+  return (**pstr >= '0' && **pstr < ('0' + base));
+}
+
+/* consumes any digits in the string (base 2-10), returning the count skipped */
+FIO_FUNC inline uint64_t fio_atol_skip(char **pstr, uint8_t base) {
+  uint64_t result = 0;
+  while (fio_atol_skip_test(pstr, base)) {
+    ++result;
+    ++(*pstr);
+  }
+  return result;
+}
+
+/* consumes any hex data in the string, returning their value */
+FIO_FUNC inline uint64_t fio_atol_consume_hex(char **pstr) {
+  uint64_t result = 0;
+  const uint64_t limit = UINT64_MAX - (16 * 16);
+  for (; result <= limit;) {
+    uint8_t tmp;
+    if (**pstr >= '0' && **pstr <= '9')
+      tmp = **pstr - '0';
+    else if (**pstr >= 'A' && **pstr <= 'F')
+      tmp = **pstr - ('A' - 10);
+    else if (**pstr >= 'a' && **pstr <= 'f')
+      tmp = **pstr - ('a' - 10);
+    else
+      return result;
+    result = (result << 4) | tmp;
+    ++(*pstr);
+  }
+  return result;
+}
+
+/* returns true if there's data to be skipped */
+FIO_FUNC inline uint8_t fio_atol_skip_hex_test(char **pstr) {
+  return (**pstr >= '0' && **pstr <= '9') || (**pstr >= 'A' && **pstr <= 'F') ||
+         (**pstr >= 'a' && **pstr <= 'f');
+}
+
+/* consumes any digits in the string (base 2-10), returning the count skipped */
+FIO_FUNC inline uint64_t fio_atol_skip_hex(char **pstr) {
+  uint64_t result = 0;
+  while (fio_atol_skip_hex_test(pstr)) {
+    ++result;
+    ++(*pstr);
+  }
+  return result;
+}
+
+/* caches a up to 8*8 */
+// static inline fio_atol_pow_10_cache(size_t ex) {}
+
 /**
  * A helper function that converts between String data to a signed int64_t.
  *
@@ -3559,66 +3632,54 @@ int64_t fio_atol(char **pstr) {
   char *str = *pstr;
   uint64_t result = 0;
   uint8_t invert = 0;
-  while (str[0] == '-') {
+  while (isspace(*str))
+    ++(str);
+  if (str[0] == '-') {
     invert ^= 1;
     ++str;
+  } else if (*str == '+') {
+    ++(str);
   }
+
   if (str[0] == 'B' || str[0] == 'b' ||
       (str[0] == '0' && (str[1] == 'b' || str[1] == 'B'))) {
     /* base 2 */
     if (str[0] == '0')
       str++;
     str++;
+    fio_atol_skip_zero(&str);
     while (str[0] == '0' || str[0] == '1') {
-      result = (result << 1) | (str[0] == '1');
+      result = (result << 1) | (str[0] - '0');
       str++;
     }
+    goto sign; /* no overlow protection, since sign might be embedded */
+
   } else if (str[0] == 'x' || str[0] == 'X' ||
              (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))) {
     /* base 16 */
-    uint8_t tmp;
     if (str[0] == '0')
       str++;
     str++;
-    for (;;) {
-      if (str[0] >= '0' && str[0] <= '9')
-        tmp = str[0] - '0';
-      else if (str[0] >= 'A' && str[0] <= 'F')
-        tmp = str[0] - ('A' - 10);
-      else if (str[0] >= 'a' && str[0] <= 'f')
-        tmp = str[0] - ('a' - 10);
-      else
-        goto finish;
-      result = (result << 4) | tmp;
-      str++;
-    }
+    fio_atol_skip_zero(&str);
+    result = fio_atol_consume_hex(&str);
+    if (fio_atol_skip_hex_test(&str)) /* too large for a number */
+      return 0;
+    goto sign; /* no overlow protection, since sign might be embedded */
   } else if (str[0] == '0') {
-    ++str;
+    fio_atol_skip_zero(&str);
     /* base 8 */
-    const char *end = str;
-    while (end[0] >= '0' && end[0] <= '7' && (uintptr_t)(end - str) < 22)
-      end++;
-    if ((uintptr_t)(end - str) > 21) /* TODO: fix too large for a number */
+    result = fio_atol_consume(&str, 8);
+    if (fio_atol_skip_test(&str, 8)) /* too large for a number */
       return 0;
-
-    while (str < end) {
-      result = (result * 8) + (str[0] - '0');
-      str++;
-    }
   } else {
     /* base 10 */
-    const char *end = str;
-    while (end[0] >= '0' && end[0] <= '9' && (uintptr_t)(end - str) < 22)
-      end++;
-    if ((uintptr_t)(end - str) > 21) /* too large for a number */
+    result = fio_atol_consume(&str, 10);
+    if (fio_atol_skip_test(&str, 10)) /* too large for a number */
       return 0;
-
-    while (str < end) {
-      result = (result * 10) + (str[0] - '0');
-      str++;
-    }
   }
-finish:
+  if (result & ((uint64_t)1 << 63))
+    result = INT64_MAX; /* signed overflow protection */
+sign:
   if (invert)
     result = 0 - result;
   *pstr = str;
@@ -3715,12 +3776,12 @@ size_t fio_ltoa(char *dest, int64_t num, uint8_t base) {
         n = n << 8;
         i++;
       }
-      /* make sure the Hex representation doesn't appear signed. */
+      /* make sure the Hex representation doesn't appear misleadingly signed. */
       if (i && (n & 0x8000000000000000)) {
         dest[len++] = '0';
         dest[len++] = '0';
       }
-      /* write the damn thing */
+      /* write the damn thing, high to low */
       while (i < 8) {
         uint8_t tmp = (n & 0xF000000000000000) >> 60;
         dest[len++] = notation[tmp];
@@ -3785,6 +3846,9 @@ zero:
     dest[len++] = '0';
     dest[len++] = 'b';
     break;
+  case 8:
+    dest[len++] = '0';
+    break;
   case 16:
     dest[len++] = '0';
     dest[len++] = 'x';
@@ -5724,6 +5788,27 @@ Section Start Marker
 ***************************************************************************** */
 
 #if FIO_FORCE_MALLOC
+
+void *fio_malloc(size_t size) { return calloc(size, 1); }
+
+void *fio_calloc(size_t size_per_unit, size_t unit_count) {
+  return calloc(size_per_unit, unit_count);
+}
+
+void fio_free(void *ptr) { free(ptr); }
+
+void *fio_realloc(void *ptr, size_t new_size) {
+  return realloc((ptr), (new_size));
+}
+
+void *fio_realloc2(void *ptr, size_t new_size, size_t copy_length) {
+  return realloc((ptr), (new_size));
+  (void)copy_length;
+}
+
+void *fio_mmap(size_t size) { return calloc(size, 1); }
+
+void fio_malloc_after_fork(void) {}
 void fio_mem_destroy(void) {}
 void fio_mem_init(void) {}
 
@@ -7950,10 +8035,11 @@ Testing Memory Allocator
 ***************************************************************************** */
 
 #if FIO_FORCE_MALLOC
-#define fio_malloc_test()
+#define fio_malloc_test()                                                      \
+  fprintf(stderr, "\n=== SKIPPED facil.io memory allocator (bypassed)\n");
 #else
 void fio_malloc_test(void) {
-  fprintf(stderr, "=== Testing facil.io memory allocator's system calls\n");
+  fprintf(stderr, "\n=== Testing facil.io memory allocator's system calls\n");
   char *mem = sys_alloc(FIO_MEMORY_BLOCK_SIZE, 0);
   FIO_ASSERT(mem, "sys_alloc failed to allocate memory!\n");
   FIO_ASSERT(!((uintptr_t)mem & FIO_MEMORY_BLOCK_MASK),
@@ -8407,6 +8493,40 @@ static void fio_defer_test(void) {
   fprintf(stderr, "\n* passed.\n");
 }
 
+/* *****************************************************************************
+Array data-structure Testing
+***************************************************************************** */
+
+typedef struct {
+  int i;
+  char c;
+} fio_ary_test_type_s;
+
+#define FIO_ARY_NAME fio_i_ary
+#define FIO_ARY_TYPE uintptr_t
+#include "fio.h"
+
+static intptr_t ary_alloc_counter = 0;
+static void copy_s(fio_ary_test_type_s *d, fio_ary_test_type_s *s) {
+  ++ary_alloc_counter;
+  *d = *s;
+}
+
+#define FIO_ARY_NAME fio_s_ary
+#define FIO_ARY_TYPE fio_ary_test_type_s
+#define FIO_ARY_COPY(dest, src) copy_s(&(dest), &(src))
+#define FIO_ARY_COMPARE(dest, src) ((dest).i == (src).i && (dest).c == (src).c)
+#define FIO_ARY_DESTROY(obj) (--ary_alloc_counter)
+#include "fio.h"
+
+void fio_ary_test(void) {
+  /* code */
+  fio_i_ary__test();
+  fio_s_ary__test();
+  FIO_ASSERT(!ary_alloc_counter, "array object deallocation error, %ld != 0",
+             ary_alloc_counter);
+}
+
 /* *****************************************************************************
 Set data-structure Testing
 ***************************************************************************** */
@@ -9291,6 +9411,7 @@ static void fio_str2u_test(void) {
                "fio_u2str16 / fio_str2u16  mismatch %zd != %zd",
                (ssize_t)(fio_str2u16(buffer)), (ssize_t)i);
   }
+  fprintf(stderr, "* passed.\n");
 }
 
 /* *****************************************************************************
@@ -9359,6 +9480,7 @@ static void fio_pubsub_test(void) {
   fio_data->workers = 0;
   (void)fio_pubsub_test_on_message;
   (void)fio_pubsub_test_on_unsubscribe;
+  fprintf(stderr, "* passed.\n");
 }
 #else
 #define fio_pubsub_test()
@@ -9383,6 +9505,59 @@ static void fio_atol_test(void) {
           "      Test with make test/optimized for realistic results.\n");
   time_t start, end;
 
+#define TEST_ATOL(s, n)                                                        \
+  do {                                                                         \
+    char *p = (char *)(s);                                                     \
+    int64_t r = fio_atol(&p);                                                  \
+    FIO_ASSERT(r == (n), "fio_atol test error! %s => %zd (not %zd)",           \
+               ((char *)(s)), (size_t)r, (size_t)n);                           \
+    FIO_ASSERT((s) + strlen((s)) == p,                                         \
+               "fio_atol test error! %s reading position not at end (%zu)",    \
+               (s), (size_t)(p - (s)));                                        \
+    char buf[72];                                                              \
+    buf[fio_ltoa(buf, n, 2)] = 0;                                              \
+    p = buf;                                                                   \
+    FIO_ASSERT(fio_atol(&p) == (n),                                            \
+               "fio_ltoa base 2 test error! "                                  \
+               "%s != %s (%zd)",                                               \
+               buf, ((char *)(s)), (size_t)((p = buf), fio_atol(&p)));         \
+    buf[fio_ltoa(buf, n, 8)] = 0;                                              \
+    p = buf;                                                                   \
+    FIO_ASSERT(fio_atol(&p) == (n),                                            \
+               "fio_ltoa base 8 test error! "                                  \
+               "%s != %s (%zd)",                                               \
+               buf, ((char *)(s)), (size_t)((p = buf), fio_atol(&p)));         \
+    buf[fio_ltoa(buf, n, 10)] = 0;                                             \
+    p = buf;                                                                   \
+    FIO_ASSERT(fio_atol(&p) == (n),                                            \
+               "fio_ltoa base 10 test error! "                                 \
+               "%s != %s (%zd)",                                               \
+               buf, ((char *)(s)), (size_t)((p = buf), fio_atol(&p)));         \
+    buf[fio_ltoa(buf, n, 16)] = 0;                                             \
+    p = buf;                                                                   \
+    FIO_ASSERT(fio_atol(&p) == (n),                                            \
+               "fio_ltoa base 16 test error! "                                 \
+               "%s != %s (%zd)",                                               \
+               buf, ((char *)(s)), (size_t)((p = buf), fio_atol(&p)));         \
+  } while (0)
+  TEST_ATOL("0x1", 1);
+  TEST_ATOL("-0x1", -1);
+  TEST_ATOL("-0xa", -10);                                /* sign before hex */
+  TEST_ATOL("0xe5d4c3b2a1908770", -1885667171979196560); /* sign within hex */
+  TEST_ATOL("0b00000000000011", 3);
+  TEST_ATOL("-0b00000000000011", -3);
+  TEST_ATOL("0b0000000000000000000000000000000000000000000000000", 0);
+  TEST_ATOL("0", 0);
+  TEST_ATOL("1", 1);
+  TEST_ATOL("2", 2);
+  TEST_ATOL("-2", -2);
+  TEST_ATOL("0000000000000000000000000000000000000000000000042", 34); /* oct */
+  TEST_ATOL("9223372036854775807", 9223372036854775807LL); /* INT64_MAX */
+  TEST_ATOL("9223372036854775808",
+            9223372036854775807LL); /* INT64_MAX overflow protection */
+  TEST_ATOL("9223372036854775999",
+            9223372036854775807LL); /* INT64_MAX overflow protection */
+
   char number_hex[128] = "0xe5d4c3b2a1908770"; /* hex with embedded sign */
   // char number_hex[128] = "-0x1a2b3c4d5e6f7890";
   char number[128] = "-1885667171979196560";
@@ -9399,9 +9574,6 @@ static void fio_atol_test(void) {
     __asm__ volatile("" ::: "memory");
   }
   end = clock();
-  FIO_ASSERT(result == expect,
-             "fio_atol with base 10 returned wrong result (%ld != %ld)", expect,
-             result);
   fprintf(stderr, "fio_atol base 10 (%ld): %zd CPU cycles\n", result,
           end - start);
 
@@ -9425,9 +9597,6 @@ static void fio_atol_test(void) {
     __asm__ volatile("" ::: "memory");
   }
   end = clock();
-  FIO_ASSERT(result == expect,
-             "fio_atol with base 16 returned wrong result (%ld != %ld)", expect,
-             result);
   fprintf(stderr, "fio_atol base 16 (%ld): %zd CPU cycles\n", result,
           end - start);
 
@@ -9473,8 +9642,110 @@ static void fio_atol_test(void) {
              "base 10 zero should be single char.");
   FIO_ASSERT(memcmp(number, "0", 2) == 0, "base 10 zero should be \"0\" (%s).",
              number);
+  fprintf(stderr, "* passed.\n");
+#undef TEST_ATOL
 }
 
+/* *****************************************************************************
+String 2 Float and Float 2 String (partial) testing
+***************************************************************************** */
+
+static void fio_atof_test(void) {
+  fprintf(stderr, "=== Testing fio_ftoa and fio_ftoa (partial)\n");
+#define TEST_DOUBLE(s, d, must)                                                \
+  do {                                                                         \
+    char *p = (char *)(s);                                                     \
+    double r = fio_atof(&p);                                                   \
+    if (r != (d)) {                                                            \
+      FIO_LOG_DEBUG("Double Test Error! %s => %.19g (not %.19g)",              \
+                    ((char *)(s)), r, d);                                      \
+      if (must) {                                                              \
+        FIO_ASSERT(0, "double test failed on %s", ((char *)(s)));              \
+        exit(-1);                                                              \
+      }                                                                        \
+    }                                                                          \
+  } while (0)
+  /* The numbers were copied from https://github.com/miloyip/rapidjson */
+  TEST_DOUBLE("0.0", 0.0, 1);
+  TEST_DOUBLE("-0.0", -0.0, 1);
+  TEST_DOUBLE("1.0", 1.0, 1);
+  TEST_DOUBLE("-1.0", -1.0, 1);
+  TEST_DOUBLE("1.5", 1.5, 1);
+  TEST_DOUBLE("-1.5", -1.5, 1);
+  TEST_DOUBLE("3.1416", 3.1416, 1);
+  TEST_DOUBLE("1E10", 1E10, 1);
+  TEST_DOUBLE("1e10", 1e10, 1);
+  TEST_DOUBLE("1E+10", 1E+10, 1);
+  TEST_DOUBLE("1E-10", 1E-10, 1);
+  TEST_DOUBLE("-1E10", -1E10, 1);
+  TEST_DOUBLE("-1e10", -1e10, 1);
+  TEST_DOUBLE("-1E+10", -1E+10, 1);
+  TEST_DOUBLE("-1E-10", -1E-10, 1);
+  TEST_DOUBLE("1.234E+10", 1.234E+10, 1);
+  TEST_DOUBLE("1.234E-10", 1.234E-10, 1);
+  TEST_DOUBLE("1.79769e+308", 1.79769e+308, 1);
+  TEST_DOUBLE("2.22507e-308", 2.22507e-308, 1);
+  TEST_DOUBLE("-1.79769e+308", -1.79769e+308, 1);
+  TEST_DOUBLE("-2.22507e-308", -2.22507e-308, 1);
+  TEST_DOUBLE("4.9406564584124654e-324", 4.9406564584124654e-324, 0);
+  TEST_DOUBLE("2.2250738585072009e-308", 2.2250738585072009e-308, 0);
+  TEST_DOUBLE("2.2250738585072014e-308", 2.2250738585072014e-308, 1);
+  TEST_DOUBLE("1.7976931348623157e+308", 1.7976931348623157e+308, 1);
+  TEST_DOUBLE("1e-10000", 0.0, 0);
+  TEST_DOUBLE("18446744073709551616", 18446744073709551616.0, 0);
+
+  TEST_DOUBLE("-9223372036854775809", -9223372036854775809.0, 0);
+
+  TEST_DOUBLE("0.9868011474609375", 0.9868011474609375, 0);
+  TEST_DOUBLE("123e34", 123e34, 1);
+  TEST_DOUBLE("45913141877270640000.0", 45913141877270640000.0, 1);
+  TEST_DOUBLE("2.2250738585072011e-308", 2.2250738585072011e-308, 0);
+  TEST_DOUBLE("1e-214748363", 0.0, 1);
+  TEST_DOUBLE("1e-214748364", 0.0, 1);
+  TEST_DOUBLE("0.017976931348623157e+310, 1", 1.7976931348623157e+308, 0);
+
+  TEST_DOUBLE("2.2250738585072012e-308", 2.2250738585072014e-308, 0);
+  TEST_DOUBLE("2.22507385850720113605740979670913197593481954635164565e-308",
+              2.2250738585072014e-308, 0);
+
+  TEST_DOUBLE("0.999999999999999944488848768742172978818416595458984375", 1.0,
+              0);
+  TEST_DOUBLE("0.999999999999999944488848768742172978818416595458984376", 1.0,
+              0);
+  TEST_DOUBLE("1.00000000000000011102230246251565404236316680908203125", 1.0,
+              0);
+  TEST_DOUBLE("1.00000000000000011102230246251565404236316680908203124", 1.0,
+              0);
+
+  TEST_DOUBLE("72057594037927928.0", 72057594037927928.0, 0);
+  TEST_DOUBLE("72057594037927936.0", 72057594037927936.0, 0);
+  TEST_DOUBLE("72057594037927932.0", 72057594037927936.0, 0);
+  TEST_DOUBLE("7205759403792793200001e-5", 72057594037927936.0, 0);
+
+  TEST_DOUBLE("9223372036854774784.0", 9223372036854774784.0, 0);
+  TEST_DOUBLE("9223372036854775808.0", 9223372036854775808.0, 0);
+  TEST_DOUBLE("9223372036854775296.0", 9223372036854775808.0, 0);
+  TEST_DOUBLE("922337203685477529600001e-5", 9223372036854775808.0, 0);
+
+  TEST_DOUBLE("10141204801825834086073718800384",
+              10141204801825834086073718800384.0, 0);
+  TEST_DOUBLE("10141204801825835211973625643008",
+              10141204801825835211973625643008.0, 0);
+  TEST_DOUBLE("10141204801825834649023672221696",
+              10141204801825835211973625643008.0, 0);
+  TEST_DOUBLE("1014120480182583464902367222169600001e-5",
+              10141204801825835211973625643008.0, 0);
+
+  TEST_DOUBLE("5708990770823838890407843763683279797179383808",
+              5708990770823838890407843763683279797179383808.0, 0);
+  TEST_DOUBLE("5708990770823839524233143877797980545530986496",
+              5708990770823839524233143877797980545530986496.0, 0);
+  TEST_DOUBLE("5708990770823839207320493820740630171355185152",
+              5708990770823839524233143877797980545530986496.0, 0);
+  TEST_DOUBLE("5708990770823839207320493820740630171355185152001e-3",
+              5708990770823839524233143877797980545530986496.0, 0);
+  fprintf(stderr, "\n* passed.\n");
+}
 /* *****************************************************************************
 Run all tests
 ***************************************************************************** */
@@ -9485,15 +9756,17 @@ void fio_test(void) {
   fio_state_callback_test();
   fio_str_test();
   fio_atol_test();
+  fio_atof_test();
   fio_str2u_test();
   fio_llist_test();
+  fio_ary_test();
+  fio_set_test();
   fio_defer_test();
   fio_timer_test();
   fio_poll_test();
   fio_socket_test();
   fio_uuid_link_test();
   fio_cycle_test();
-  fio_set_test();
   fio_siphash_test();
   fio_sha1_test();
   fio_sha2_test();