koffi 1.1.0-beta.0 → 1.1.0-beta.3

package/CMakeLists.txt

@@ -18,7 +18,11 @@ find_package(CNoke)
 
 set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
+    add_compile_options(/W4 /wd4200 /wd4458 /wd4706 /wd4100 /wd4127 /wd4702)
     enable_language(ASM_MASM)
+else()
+    add_compile_options(-Wall -Wextra -Wno-missing-field-initializers
+                        -Wno-unused-parameter -Wno-class-memaccess)
 endif()
 
 # ---- Koffi ----

package/README.md

@@ -2,6 +2,11 @@
 
 - [Introduction](#introduction)
 - [Get started](#get-started)
+- [Extra features](#extra-features)
+  * [C arrays](#c-arrays)
+  * [Variadic functions](#variadic-functions)
+  * [Asynchronous calls](#asynchronous-calls)
+  * [Callbacks](#callbacks)
 - [Benchmarks](#benchmarks)
   * [atoi results](#atoi-results)
   * [Raylib results](#raylib-results)
@@ -16,9 +21,8 @@ Koffi is a fast and easy-to-use FFI module for Node.js, with support for primiti
 
 After the release of version 1.0, the following features are planned:
 
-* 1.1: Asynchronous calls
-* 1.2: Fixed-size array types
-* 1.3: C to JS callbacks
+* 1.1: Asynchronous calls and fixed-size array types
+* 1.2: C to JS callbacks
 
 The following platforms __are officially supported and tested__ at the moment:
 
@@ -214,12 +218,16 @@ while (!WindowShouldClose()) {
 
 # Extra features
 
+## C arrays
+
+Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed
+as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
+
 ## Variadic functions
 
 Variadic functions are declared with an ellipsis as the last argument.
 
-In order to call a variadic function, you must provide two Javascript arguments for each C parameter,
-the first one is the expected type and the second one is the value.
+In order to call a variadic function, you must provide two Javascript arguments for each C parameter, the first one is the expected type and the second one is the value.
 
 ```js
 const printf = lib.func('printf', 'int', ['string', '...']);
@@ -229,9 +237,7 @@ printf('Integer %d, double %g, string %s', 'int', 6, 'double', 8.5, 'string', 'T
 
 ## Asynchronous calls
 
-You can issue asynchronous calls by calling the function through its async member.
-In this case, you need to provide a callback function as the last argument, with
-`(err, res)` parameters.
+You can issue asynchronous calls by calling the function through its async member. In this case, you need to provide a callback function as the last argument, with `(err, res)` parameters.
 
 ```js
 const koffi = require('koffi');
@@ -247,14 +253,13 @@ console.log('Hello World!');
 // This program will print "Hello World!", and then "Result: 1257"
 ```
 
-You can easily convert this callback-style async function with `util.promisify()` from the
-Node.js standard library.
+You can easily convert this callback-style async function to a promise-based version with `util.promisify()` from the Node.js standard library.
 
 Variadic functions do not support async.
 
 ## Callbacks
 
-Koffi does not yet support passing JS functions as callbacks. This is planned for version 1.1.
+Koffi does not yet support passing JS functions as callbacks. This is planned for version 1.2.
 
 # Benchmarks
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.0-beta.0",
+  "version": "1.1.0-beta.3",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

package/qemu/qemu.js

@@ -275,6 +275,7 @@ async function pack() {
     let json = fs.readFileSync(root_dir + '/koffi/package.json', { encoding: 'utf-8' });
     let version = JSON.parse(json).version;
 
+    console.log('>> Version:', version);
     console.log('>> Checking build archives...');
     for (let machine of machines) {
         let needed = false;

package/src/abi_arm32.cc

@@ -37,28 +37,9 @@ extern "C" uint64_t ForwardCallXGG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
-static bool IsHFA(const TypeInfo *type)
-{
-    if (type->primitive != PrimitiveKind::Record)
-        return false;
-
-    if (type->members.len < 1 || type->members.len > 4)
-        return false;
-    if (type->members[0].type->primitive != PrimitiveKind::Float32 &&
-            type->members[0].type->primitive != PrimitiveKind::Float64)
-        return false;
-
-    for (Size i = 1; i < type->members.len; i++) {
-        if (type->members[i].type != type->members[0].type)
-            return false;
-    }
-
-    return true;
-}
-
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
-    if (IsHFA(func->ret.type)) {
+    if (IsHFA(func->ret.type, 1, 4)) {
         func->ret.vec_count = func->ret.type->members.len *
                               (func->ret.type->members[0].type->size / 4);
     } else if (func->ret.type->primitive != PrimitiveKind::Record ||
@@ -93,7 +74,6 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     started_stack = true;
                 }
             } break;
-
             case PrimitiveKind::Int64:
             case PrimitiveKind::UInt64: {
                 if (gpr_avail >= 2) {
@@ -103,31 +83,8 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     started_stack = true;
                 }
             } break;
-
-            case PrimitiveKind::Float32:
-            case PrimitiveKind::Float64: {
-                Size need = param.type->size / 4;
-                bool vfp = !param.variadic;
-
-                if (vfp) {
-                    if (need <= vec_avail) {
-                        param.vec_count = need;
-                        vec_avail -= need;
-                    } else {
-                        started_stack = true;
-                    }
-                } else {
-                    if (need <= gpr_avail) {
-                        param.gpr_count = need;
-                        gpr_avail -= need;
-                    } else {
-                        started_stack = true;
-                    }
-                }
-            } break;
-
             case PrimitiveKind::Record: {
-                if (IsHFA(param.type)) {
+                if (IsHFA(param.type, 1, 4)) {
                     int vec_count = (int)(param.type->members.len *
                                           param.type->members[0].type->size / 4);
 
@@ -152,6 +109,28 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     }
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32:
+            case PrimitiveKind::Float64: {
+                Size need = param.type->size / 4;
+                bool vfp = !param.variadic;
+
+                if (vfp) {
+                    if (need <= vec_avail) {
+                        param.vec_count = need;
+                        vec_avail -= need;
+                    } else {
+                        started_stack = true;
+                    }
+                } else {
+                    if (need <= gpr_avail) {
+                        param.gpr_count = need;
+                        gpr_avail -= need;
+                    } else {
+                        started_stack = true;
+                    }
+                }
+            } break;
         }
 
         func->args_size += AlignLen(param.type->size, 16);
@@ -354,6 +333,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr += AlignLen(param.type->size, 4);
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -432,6 +412,7 @@ void CallData::Execute()
                 result.u64 = PERFORM_CALL(GG);
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(DDDD).d0; } break;
     }
@@ -472,6 +453,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_arm64.cc

@@ -41,28 +41,9 @@ extern "C" X0X1Ret ForwardCallXGG(const void *func, uint8_t *sp);
 extern "C" float ForwardCallXF(const void *func, uint8_t *sp);
 extern "C" HfaRet ForwardCallXDDDD(const void *func, uint8_t *sp);
 
-static bool IsHFA(const TypeInfo *type)
-{
-    if (type->primitive != PrimitiveKind::Record)
-        return false;
-
-    if (type->members.len < 1 || type->members.len > 4)
-        return false;
-    if (type->members[0].type->primitive != PrimitiveKind::Float32 &&
-            type->members[0].type->primitive != PrimitiveKind::Float64)
-        return false;
-
-    for (Size i = 1; i < type->members.len; i++) {
-        if (type->members[i].type != type->members[0].type)
-            return false;
-    }
-
-    return true;
-}
-
 bool AnalyseFunction(InstanceData *, FunctionInfo *func)
 {
-    if (IsHFA(func->ret.type)) {
+    if (IsHFA(func->ret.type, 1, 4)) {
         func->ret.vec_count = func->ret.type->members.len;
     } else if (func->ret.type->size <= 16) {
         func->ret.gpr_count = (func->ret.type->size + 7) / 8;
@@ -99,20 +80,6 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     gpr_avail--;
                 }
             } break;
-
-            case PrimitiveKind::Float32:
-            case PrimitiveKind::Float64: {
-#ifdef __APPLE__
-                if (param.variadic)
-                    break;
-#endif
-
-                if (vec_avail) {
-                    param.vec_count = 1;
-                    vec_avail--;
-                }
-            } break;
-
             case PrimitiveKind::Record: {
 #ifdef __APPLE__
                 if (param.variadic) {
@@ -121,7 +88,7 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                 }
 #endif
 
-                if (IsHFA(param.type)) {
+                if (IsHFA(param.type, 1, 4)) {
                     int vec_count = (int)param.type->members.len;
 
                     if (vec_count <= vec_avail) {
@@ -148,6 +115,19 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
                     param.use_memory = true;
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32:
+            case PrimitiveKind::Float64: {
+#ifdef __APPLE__
+                if (param.variadic)
+                    break;
+#endif
+
+                if (vec_avail) {
+                    param.vec_count = 1;
+                    vec_avail--;
+                }
+            } break;
         }
     }
 
@@ -157,62 +137,6 @@ bool AnalyseFunction(InstanceData *, FunctionInfo *func)
     return true;
 }
 
-static bool PushHFA(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest)
-{
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    RG_ASSERT(IsObject(obj));
-    RG_ASSERT(IsHFA(type));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-    RG_ASSERT(AlignUp(dest, type->members[0].type->size) == dest);
-
-    bool float32 = (type->members[0].type->primitive == PrimitiveKind::Float32);
-
-    for (const RecordMember &member: type->members) {
-        Napi::Value value = obj.Get(member.name);
-
-        if (!value.IsNumber() && !value.IsBigInt()) {
-            ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-            return false;
-        }
-
-        if (float32) {
-            *(float *)dest = CopyNumber<float>(value);
-        } else {
-            *(double *)dest = CopyNumber<double>(value);
-        }
-
-        dest += 8;
-    }
-
-    return true;
-}
-
-static Napi::Object PopHFA(napi_env env, const uint8_t *ptr, const TypeInfo *type)
-{
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-    RG_ASSERT(IsHFA(type));
-
-    Napi::Object obj = Napi::Object::New(env);
-
-    bool float32 = (type->members[0].type->primitive == PrimitiveKind::Float32);
-
-    for (const RecordMember &member: type->members) {
-        if (float32) {
-            float f = *(float *)ptr;
-            obj.Set(member.name, Napi::Number::New(env, (double)f));
-        } else {
-            double d = *(double *)ptr;
-            obj.Set(member.name, Napi::Number::New(env, d));
-        }
-
-        ptr += 8;
-    }
-
-    return obj;
-}
-
 bool CallData::Prepare(const Napi::CallbackInfo &info)
 {
     uint8_t *args_ptr = nullptr;
@@ -288,42 +212,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 #endif
                 }
             } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return false;
-                }
-
-                float f = CopyNumber<float>(value);
-
-                if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr++, &f, 4);
-                } else {
-                    args_ptr = AlignUp(args_ptr, 4);
-                    memcpy(args_ptr, &f, 4);
-#ifdef __APPLE__
-                    args_ptr += 4;
-#else
-                    args_ptr += 8;
-#endif
-                }
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return false;
-                }
-
-                double d = CopyNumber<double>(value);
-
-                if (RG_LIKELY(param.vec_count)) {
-                    memcpy(vec_ptr++, &d, 8);
-                } else {
-                    args_ptr = AlignUp(args_ptr, 8);
-                    memcpy(args_ptr, &d, 8);
-                    args_ptr += 8;
-                }
-            } break;
             case PrimitiveKind::String: {
                 const char *str;
                 if (RG_LIKELY(value.IsString())) {
@@ -405,7 +293,6 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr += 8;
                 }
             } break;
-
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
@@ -414,8 +301,8 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
                 Napi::Object obj = value.As<Napi::Object>();
 
-                if (param.vec_count) {
-                    if (!PushHFA(obj, param.type, (uint8_t *)vec_ptr))
+                if (param.vec_count) { // HFA
+                    if (!PushObject(obj, param.type, (uint8_t *)vec_ptr, 8))
                         return false;
                     vec_ptr += param.vec_count;
                 } else if (!param.use_memory) {
@@ -451,6 +338,43 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                         return false;
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+
+                if (RG_LIKELY(param.vec_count)) {
+                    memcpy(vec_ptr++, &f, 4);
+                } else {
+                    args_ptr = AlignUp(args_ptr, 4);
+                    memcpy(args_ptr, &f, 4);
+#ifdef __APPLE__
+                    args_ptr += 4;
+#else
+                    args_ptr += 8;
+#endif
+                }
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+
+                if (RG_LIKELY(param.vec_count)) {
+                    memcpy(vec_ptr++, &d, 8);
+                } else {
+                    args_ptr = AlignUp(args_ptr, 8);
+                    memcpy(args_ptr, &d, 8);
+                    args_ptr += 8;
+                }
+            } break;
         }
     }
 
@@ -495,6 +419,7 @@ void CallData::Execute()
                 PERFORM_CALL(GG);
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(DDDD).d0; } break;
     }
@@ -529,8 +454,8 @@ Napi::Value CallData::Complete()
             return external;
         } break;
         case PrimitiveKind::Record: {
-            if (func->ret.vec_count) {
-                Napi::Object obj = PopHFA(env, (const uint8_t *)&result.buf, func->ret.type);
+            if (func->ret.vec_count) { // HFA
+                Napi::Object obj = PopObject((const uint8_t *)&result.buf, func->ret.type, 8);
                 return obj;
             } else {
                 const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
@@ -540,6 +465,7 @@ Napi::Value CallData::Complete()
                 return obj;
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x64_sysv.cc

@@ -98,13 +98,6 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
             classes[0] = MergeClasses(classes[0], RegisterClass::Integer);
             return 1;
         } break;
-
-        case PrimitiveKind::Float32:
-        case PrimitiveKind::Float64: {
-            classes[0] = MergeClasses(classes[0], RegisterClass::SSE);
-            return 1;
-        } break;
-
         case PrimitiveKind::Record: {
             if (type->size > 64) {
                 classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
@@ -119,6 +112,27 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
 
             return (offset + 7) / 8;
         } break;
+        case PrimitiveKind::Array: {
+            if (type->size > 64) {
+                classes[0] = MergeClasses(classes[0], RegisterClass::Memory);
+                return 1;
+            }
+
+            Size len = type->size / type->ref->size;
+
+            for (Size i = 0; i < len; i++) {
+                Size start = offset / 8;
+                ClassifyType(type->ref, offset % 8, classes.Take(start, classes.len - start));
+                offset += type->ref->size;
+            }
+
+            return (offset + 7) / 8;
+        } break;
+        case PrimitiveKind::Float32:
+        case PrimitiveKind::Float64: {
+            classes[0] = MergeClasses(classes[0], RegisterClass::SSE);
+            return 1;
+        } break;
     }
 
     RG_UNREACHABLE();
@@ -370,6 +384,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr += AlignLen(param.type->size, 8);
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -450,6 +465,7 @@ void CallData::Execute()
                 memcpy_safe(&result.buf, &ret, RG_SIZE(ret));
             }
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(DG).xmm0; } break;
     }
@@ -490,6 +506,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x64_win.cc

@@ -182,6 +182,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 if (!PushObject(obj, param.type, ptr))
                     return false;
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -233,6 +234,7 @@ void CallData::Execute()
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
     }
@@ -273,6 +275,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }

package/src/abi_x86.cc

@@ -226,6 +226,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                     args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
                 }
             } break;
+            case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
@@ -279,6 +280,7 @@ void CallData::Execute()
         case PrimitiveKind::String16:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
         case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
     }
@@ -319,6 +321,7 @@ Napi::Value CallData::Complete()
             Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
         case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
         case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }