react-native-update 10.34.3 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/C/Threads.h

@@ -1,163 +1,40 @@
 /* Threads.h -- multithreading library
-: Igor Pavlov : Public domain */
+2017-06-18 : Igor Pavlov : Public domain */
 
-#ifndef ZIP7_INC_THREADS_H
-#define ZIP7_INC_THREADS_H
+#ifndef __7Z_THREADS_H
+#define __7Z_THREADS_H
 
-#ifdef _WIN32
-#include "7zWindows.h"
-
-#else
-
-#include "Compiler.h"
-
-// #define Z7_AFFINITY_DISABLE
-#if defined(__linux__)
-#if !defined(__APPLE__) && !defined(_AIX) && !defined(__ANDROID__)
-#ifndef Z7_AFFINITY_DISABLE
-#define Z7_AFFINITY_SUPPORTED
-// #pragma message(" ==== Z7_AFFINITY_SUPPORTED")
-#if !defined(_GNU_SOURCE)
-// #pragma message(" ==== _GNU_SOURCE set")
-// we need _GNU_SOURCE for cpu_set_t, if we compile for MUSL
-Z7_DIAGNOSTIC_IGNORE_BEGIN_RESERVED_MACRO_IDENTIFIER
-#define _GNU_SOURCE
-Z7_DIAGNOSTIC_IGNORE_END_RESERVED_MACRO_IDENTIFIER
-#endif
-#endif
-#endif
-#endif
-
-#include <pthread.h>
+#include "ThreadsP.h"  //for not _WIN32
 
+#ifdef _WIN32
+#include <windows.h>
 #endif
 
 #include "7zTypes.h"
 
 EXTERN_C_BEGIN
 
-#ifdef _WIN32
-
 WRes HandlePtr_Close(HANDLE *h);
 WRes Handle_WaitObject(HANDLE h);
 
 typedef HANDLE CThread;
-
-#define Thread_CONSTRUCT(p) { *(p) = NULL; }
+#define Thread_Construct(p) *(p) = NULL
 #define Thread_WasCreated(p) (*(p) != NULL)
 #define Thread_Close(p) HandlePtr_Close(p)
-// #define Thread_Wait(p) Handle_WaitObject(*(p))
-
-#ifdef UNDER_CE
-  // if (USE_THREADS_CreateThread is      defined), we use _beginthreadex()
-  // if (USE_THREADS_CreateThread is not definned), we use CreateThread()
-  #define USE_THREADS_CreateThread
-#endif
+#define Thread_Wait(p) Handle_WaitObject(*(p))
 
 typedef
-    #ifdef USE_THREADS_CreateThread
-      DWORD
-    #else
-      unsigned
-    #endif
-    THREAD_FUNC_RET_TYPE;
-
-#define THREAD_FUNC_RET_ZERO  0
-
-typedef DWORD_PTR CAffinityMask;
-typedef DWORD_PTR CCpuSet;
-
-#define CpuSet_Zero(p)        *(p) = (0)
-#define CpuSet_Set(p, cpu)    *(p) |= ((DWORD_PTR)1 << (cpu))
-
-#else //  _WIN32
-
-typedef struct
-{
-  pthread_t _tid;
-  int _created;
-} CThread;
-
-#define Thread_CONSTRUCT(p)   { (p)->_tid = 0;  (p)->_created = 0; }
-#define Thread_WasCreated(p)  ((p)->_created != 0)
-WRes Thread_Close(CThread *p);
-// #define Thread_Wait Thread_Wait_Close
-
-typedef void * THREAD_FUNC_RET_TYPE;
-#define THREAD_FUNC_RET_ZERO  NULL
-
-
-typedef UInt64 CAffinityMask;
-
-#ifdef Z7_AFFINITY_SUPPORTED
-
-typedef cpu_set_t CCpuSet;
-#define CpuSet_Zero(p)        CPU_ZERO(p)
-#define CpuSet_Set(p, cpu)    CPU_SET(cpu, p)
-#define CpuSet_IsSet(p, cpu)  CPU_ISSET(cpu, p)
-
-#else
-
-typedef UInt64 CCpuSet;
-#define CpuSet_Zero(p)        *(p) = (0)
-#define CpuSet_Set(p, cpu)    *(p) |= ((UInt64)1 << (cpu))
-#define CpuSet_IsSet(p, cpu)  ((*(p) & ((UInt64)1 << (cpu))) != 0)
-
-#endif
-
-
-#endif //  _WIN32
-
-
-#define THREAD_FUNC_CALL_TYPE Z7_STDCALL
-
-#if defined(_WIN32) && defined(__GNUC__)
-/* GCC compiler for x86 32-bit uses the rule:
-   the stack is 16-byte aligned before CALL instruction for function calling.
-   But only root function main() contains instructions that
-   set 16-byte alignment for stack pointer. And another functions
-   just keep alignment, if it was set in some parent function.
-   
-   The problem:
-    if we create new thread in MinGW (GCC) 32-bit x86 via _beginthreadex() or CreateThread(),
-       the root function of thread doesn't set 16-byte alignment.
-       And stack frames in all child functions also will be unaligned in that case.
-   
-   Here we set (force_align_arg_pointer) attribute for root function of new thread.
-   Do we need (force_align_arg_pointer) also for another systems?  */
-  
-  #define THREAD_FUNC_ATTRIB_ALIGN_ARG __attribute__((force_align_arg_pointer))
-  // #define THREAD_FUNC_ATTRIB_ALIGN_ARG // for debug : bad alignment in SSE functions
+#ifdef UNDER_CE
+  DWORD
 #else
-  #define THREAD_FUNC_ATTRIB_ALIGN_ARG
+  unsigned
 #endif
+  THREAD_FUNC_RET_TYPE;
 
-#define THREAD_FUNC_DECL  THREAD_FUNC_ATTRIB_ALIGN_ARG THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
-
+#define THREAD_FUNC_CALL_TYPE MY_STD_CALL
+#define THREAD_FUNC_DECL THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE
 typedef THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE * THREAD_FUNC_TYPE)(void *);
 WRes Thread_Create(CThread *p, THREAD_FUNC_TYPE func, LPVOID param);
-WRes Thread_Create_With_Affinity(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, CAffinityMask affinity);
-WRes Thread_Wait_Close(CThread *p);
-
-#ifdef _WIN32
-WRes Thread_Create_With_Group(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, unsigned group, CAffinityMask affinityMask);
-#define Thread_Create_With_CpuSet(p, func, param, cs) \
-  Thread_Create_With_Affinity(p, func, param, *cs)
-#else
-WRes Thread_Create_With_CpuSet(CThread *p, THREAD_FUNC_TYPE func, LPVOID param, const CCpuSet *cpuSet);
-#endif
-
-typedef struct
-{
-  unsigned NumGroups;
-  unsigned NextGroup;
-} CThreadNextGroup;
-
-void ThreadNextGroup_Init(CThreadNextGroup *p, unsigned numGroups, unsigned startGroup);
-unsigned ThreadNextGroup_GetNext(CThreadNextGroup *p);
-
-
-#ifdef _WIN32
 
 typedef HANDLE CEvent;
 typedef CEvent CAutoResetEvent;
@@ -179,7 +56,6 @@ typedef HANDLE CSemaphore;
 #define Semaphore_Close(p) HandlePtr_Close(p)
 #define Semaphore_Wait(p) Handle_WaitObject(*(p))
 WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
-WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
 WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
 WRes Semaphore_Release1(CSemaphore *p);
 
@@ -189,72 +65,6 @@ WRes CriticalSection_Init(CCriticalSection *p);
 #define CriticalSection_Enter(p) EnterCriticalSection(p)
 #define CriticalSection_Leave(p) LeaveCriticalSection(p)
 
-
-#else // _WIN32
-
-typedef struct
-{
-  int _created;
-  int _manual_reset;
-  int _state;
-  pthread_mutex_t _mutex;
-  pthread_cond_t _cond;
-} CEvent;
-
-typedef CEvent CAutoResetEvent;
-typedef CEvent CManualResetEvent;
-
-#define Event_Construct(p) (p)->_created = 0
-#define Event_IsCreated(p) ((p)->_created)
-
-WRes ManualResetEvent_Create(CManualResetEvent *p, int signaled);
-WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent *p);
-WRes AutoResetEvent_Create(CAutoResetEvent *p, int signaled);
-WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent *p);
-
-WRes Event_Set(CEvent *p);
-WRes Event_Reset(CEvent *p);
-WRes Event_Wait(CEvent *p);
-WRes Event_Close(CEvent *p);
-
-
-typedef struct
-{
-  int _created;
-  UInt32 _count;
-  UInt32 _maxCount;
-  pthread_mutex_t _mutex;
-  pthread_cond_t _cond;
-} CSemaphore;
-
-#define Semaphore_Construct(p) (p)->_created = 0
-#define Semaphore_IsCreated(p) ((p)->_created)
-
-WRes Semaphore_Create(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
-WRes Semaphore_OptCreateInit(CSemaphore *p, UInt32 initCount, UInt32 maxCount);
-WRes Semaphore_ReleaseN(CSemaphore *p, UInt32 num);
-#define Semaphore_Release1(p) Semaphore_ReleaseN(p, 1)
-WRes Semaphore_Wait(CSemaphore *p);
-WRes Semaphore_Close(CSemaphore *p);
-
-
-typedef struct
-{
-  pthread_mutex_t _mutex;
-} CCriticalSection;
-
-WRes CriticalSection_Init(CCriticalSection *p);
-void CriticalSection_Delete(CCriticalSection *cs);
-void CriticalSection_Enter(CCriticalSection *cs);
-void CriticalSection_Leave(CCriticalSection *cs);
-
-LONG InterlockedIncrement(LONG volatile *addend);
-LONG InterlockedDecrement(LONG volatile *addend);
-
-#endif  // _WIN32
-
-WRes AutoResetEvent_OptCreate_And_Reset(CAutoResetEvent *p);
-
 EXTERN_C_END
 
 #endif

package/harmony/pushy/src/main/cpp/lzma/C/ThreadsP.c

@@ -0,0 +1,396 @@
+// ThreadsP.c
+//   for not _WIN32 ,used pthread
+//   2019-02-05 : by housisong : for HDiffPatch
+#include "ThreadsP.h"
+#include "Threads.h"
+#ifndef _WIN32
+
+#include <pthread.h>
+#include <assert.h>
+#include <stdlib.h> // malloc free
+#include <string.h> // memset
+
+typedef struct CObject_t{
+    WRes  (*wait)(HANDLE h);
+    WRes (*close)(HANDLE* h);
+} CObject_t;
+
+WRes HandlePtr_Close(HANDLE* h){
+    CObject_t* pobj=0;
+    if ((0==h)||(0==*h)) return SZ_OK;
+    pobj=(CObject_t*)(*h);
+    return pobj->close(h);
+}
+
+WRes Handle_WaitObject(HANDLE h){
+    CObject_t* pobj=0;
+    assert(h!=0);
+    pobj=(CObject_t*)h;
+    return pobj->wait(h);
+}
+
+
+typedef struct CThread_t{
+    CObject_t   base;
+    pthread_t   tid;
+} CThread_t;
+
+static WRes _Thread_wait(HANDLE h){
+    CThread_t*      self=(CThread_t*)h;
+    void *          join_return=0;
+    int             rt;
+    assert(self!=0);
+    assert(self->tid!=0);
+    assert(self->base.wait==_Thread_wait);
+    
+    rt = pthread_join(self->tid,&join_return);
+    if (rt==0)
+        self->tid=0;
+    return rt;
+}
+
+static WRes _Thread_close(HANDLE* h){
+    CThread_t*      self=0;
+    int             rt;
+    assert(h!=0);
+    self=(CThread_t*)(*h);
+    assert(self!=0);
+    assert(self->base.close==_Thread_close);
+    
+    rt=SZ_OK;
+    if (self->tid!=0){
+        rt=pthread_detach(self->tid);
+        self->tid=0;
+    }
+    free(self);
+    *h=0;
+    return rt;
+}
+
+WRes Thread_Create(CThread* p,THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE* func)(void *),LPVOID param){
+    int             rt,rt2;
+    pthread_t       tid=0;
+    pthread_attr_t  attr;
+    assert(p!=0);
+    assert((*p)==0);
+    {//set attr
+        rt=pthread_attr_init(&attr);
+        if (rt!=0) return rt;
+        rt=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_JOINABLE);
+        if (rt!=0) return rt;
+    }
+    rt=pthread_create(&tid,&attr,(void * (*)(void *))func,param);
+    rt2=pthread_attr_destroy(&attr);
+    if (rt!=0) return rt;
+    if (rt2!=0){
+        pthread_detach(tid);
+        return rt2;
+    }
+    
+    {
+        CThread_t* self=(CThread_t*)malloc(sizeof(*self));
+        if (self==0) return SZ_ERROR_MEM;
+        self->base.wait =_Thread_wait;
+        self->base.close=_Thread_close;
+        self->tid = tid;
+        *p=self;
+        return SZ_OK;
+    }
+}
+
+
+typedef struct CEvent_t{
+    CObject_t       base;
+    pthread_mutex_t mutex;
+    pthread_cond_t  cond;
+    int             isManualReset;
+    volatile int    isState;
+} CEvent_t;
+
+static WRes _Event_wait(HANDLE h) {
+    CEvent_t*   self=(CEvent_t*)h;
+    int         rt;
+    int         rt2;
+    assert(self!=0);
+    assert(self->base.wait==_Event_wait);
+    
+    rt=pthread_mutex_lock(&self->mutex);
+    if (rt!=0) return rt;
+    rt2=SZ_OK;
+    while (!self->isState){
+        rt2=pthread_cond_wait(&self->cond,&self->mutex);
+        if (rt2!=0) break;
+    }
+    if (!self->isManualReset)
+        self->isState=0;
+    rt=pthread_mutex_unlock(&self->mutex);
+    if (rt2!=0) return rt2;
+    return rt;
+}
+
+static WRes _Event_close(HANDLE* h) {
+    CEvent_t*   self=0;
+    int         rt,rt2;
+    assert(h!=0);
+    self=(CEvent_t*)(*h);
+    assert(self!=0);
+    assert(self->base.close==_Event_close);
+    
+    rt2=pthread_cond_destroy(&self->cond);
+    rt=pthread_mutex_destroy(&self->mutex);
+    free(self);
+    *h=0;
+    if (rt2!=0) return rt2;
+    return rt;
+}
+
+static WRes _Event_Create(CEvent* p,int signaled,int isManualReset){
+    pthread_mutex_t mutex;
+    pthread_cond_t  cond;
+    int             rt;
+    assert(p!=0);
+    assert((*p)==0);
+    rt=pthread_mutex_init(&mutex,0);
+    if (rt!=0) return rt;
+    rt=pthread_cond_init(&cond,0);
+    if (rt!=0){
+        pthread_mutex_destroy(&mutex);
+        return rt;
+    }
+    {
+        CEvent_t* self=(CEvent_t*)malloc(sizeof(*self));
+        if (self==0){
+            pthread_cond_destroy(&cond);
+            pthread_mutex_destroy(&mutex);
+            return SZ_ERROR_MEM;
+        }
+        self->base.wait =_Event_wait;
+        self->base.close=_Event_close;
+        self->mutex =mutex;
+        self->cond  =cond;
+        self->isManualReset= isManualReset?1:0;
+        self->isState      = signaled?1:0;
+        *p=self;
+        return SZ_OK;
+    }
+}
+
+WRes Event_Set(CEvent* p) {
+    CEvent_t*       self=0;
+    int             rt,rt2;
+    assert(p!=0);
+    self=(CEvent_t*)(*p);
+    assert(self!=0);
+    
+    rt=pthread_mutex_lock(&self->mutex);
+    if (rt!=0) return rt;
+    self->isState = 1;
+    rt=pthread_cond_broadcast(&self->cond);
+    rt2=pthread_mutex_unlock(&self->mutex);
+    if (rt!=0) return rt;
+    return rt2;
+}
+
+WRes Event_Reset(CEvent* p) {
+    CEvent_t*       self=0;
+    int             rt;
+    assert(p!=0);
+    self=(CEvent_t*)(*p);
+    assert(self!=0);
+    
+    rt=pthread_mutex_lock(&self->mutex);
+    if (rt!=0) return rt;
+    self->isState = 0;
+    return pthread_mutex_unlock(&self->mutex);
+}
+
+WRes ManualResetEvent_Create(CManualResetEvent* p, int signaled){
+    return _Event_Create(p,signaled,1);
+}
+
+WRes ManualResetEvent_CreateNotSignaled(CManualResetEvent* p){
+    return ManualResetEvent_Create(p,0);
+}
+
+WRes AutoResetEvent_Create(CAutoResetEvent* p, int signaled){
+    return _Event_Create(p,signaled,0);
+}
+
+WRes AutoResetEvent_CreateNotSignaled(CAutoResetEvent* p){
+    return AutoResetEvent_Create(p,0);
+}
+
+
+typedef struct CSemaphore_t{
+    CObject_t       base;
+    pthread_mutex_t mutex;
+    pthread_cond_t  cond;
+    UInt32          maxCount;
+    volatile UInt32 count;
+} CSemaphore_t;
+
+static WRes _Semaphore_wait(HANDLE h){
+    CSemaphore_t*   self=(CSemaphore_t*)h;
+    int             rt,rt2;
+    assert(self!=0);
+    assert(self->base.wait=_Semaphore_wait);
+    
+    rt=pthread_mutex_lock(&self->mutex);
+    if (rt!=0) return rt;
+    rt2=SZ_OK;
+    while(self->count==0){
+        rt2=pthread_cond_wait(&self->cond,&self->mutex);
+        if (rt2!=0) break;
+    }
+    --self->count;
+    rt=pthread_mutex_unlock(&self->mutex);
+    if (rt2!=0) return rt2;
+    return rt;
+}
+
+static WRes _Semaphore_close(HANDLE* h){
+    CSemaphore_t*   self=0;
+    int             rt,rt2;
+    assert(h!=0);
+    self=(CSemaphore_t*)(*h);
+    assert(self!=0);
+    assert(self->base.close=_Semaphore_close);
+    
+    rt2=pthread_cond_destroy(&self->cond);
+    rt=pthread_mutex_destroy(&self->mutex);
+    free(self);
+    *h=0;
+    return SZ_OK;
+}
+
+WRes Semaphore_Create(CSemaphore* p, UInt32 initCount, UInt32 maxCount){
+    pthread_mutex_t mutex;
+    pthread_cond_t  cond;
+    int             rt;
+    assert(p!=0);
+    assert((*p)==0);
+    rt=pthread_mutex_init(&mutex,0);
+    if (rt!=0) return rt;
+    rt=pthread_cond_init(&cond,0);
+    if (rt!=0){
+        pthread_mutex_destroy(&mutex);
+        return rt;
+    }
+    
+    {
+        CSemaphore_t*   self=(CSemaphore_t*)malloc(sizeof(*self));
+        if (self==0){
+            pthread_cond_destroy(&cond);
+            pthread_mutex_destroy(&mutex);
+            return SZ_ERROR_MEM;
+        }
+        self->base.wait =_Semaphore_wait;
+        self->base.close=_Semaphore_close;
+        self->mutex   =mutex;
+        self->cond    =cond;
+        self->maxCount=maxCount;
+        self->count   =initCount;
+        *p=self;
+        return SZ_OK;
+    }
+}
+
+WRes Semaphore_ReleaseN(CSemaphore* p, UInt32 num){
+    CSemaphore_t*   self=0;
+    int             rt,rt2;
+    UInt32          newCount;
+    if (num==0) return SZ_ERROR_PARAM;
+    assert(p!=0);
+    self=(CSemaphore_t*)(*p);
+    assert(self!=0);
+    
+    rt=pthread_mutex_lock(&self->mutex);
+    if (rt!=0) return rt;
+    newCount = self->count + num;
+    if (newCount>self->maxCount){
+        pthread_mutex_unlock(&self->mutex);
+        return SZ_ERROR_PARAM;
+    }
+    self->count = newCount;
+    rt2=pthread_cond_broadcast(&self->cond);
+    rt=pthread_mutex_unlock(&self->mutex);
+    if (rt2!=0) return rt2;
+    return rt;
+}
+
+WRes Semaphore_Release1(CSemaphore* p){
+    return Semaphore_ReleaseN(p,1);
+}
+
+
+typedef struct CCriticalSection_t{
+    pthread_mutex_t     mutex;
+} CCriticalSection_t;
+
+
+WRes CriticalSection_Init(CCriticalSection* p){
+    pthread_mutex_t mutex;
+    int             rt;
+    assert(p!=0);
+    // assert((*p)==0); //allow *p not init to zero :(
+    rt=pthread_mutex_init(&mutex,0);
+    if (rt!=0) return rt;
+    
+    {
+        CCriticalSection_t* self=malloc(sizeof(*self));
+        if (self==0){
+            pthread_mutex_destroy(&mutex);
+            return SZ_ERROR_MEM;
+        }
+        self->mutex=mutex;
+        *p=self;
+        return SZ_OK;
+    }
+}
+
+void _def_DeleteCriticalSection(CCriticalSection* p){
+    CCriticalSection_t* self=0;
+    int                 rt;
+    if ((p==0)||(*p)==0) return;
+    self=(CCriticalSection_t*)(*p);
+    rt=pthread_mutex_destroy(&self->mutex);
+    *p=0;
+    assert(rt==0);
+}
+
+void _def_EnterCriticalSection(CCriticalSection* p){
+    CCriticalSection_t* self=0;
+    int                 rt;
+    assert(p!=0);
+    self=(CCriticalSection_t*)(*p);
+    assert(self!=0);
+    rt=pthread_mutex_lock(&self->mutex);
+    assert(rt==0);
+}
+
+void _def_LeaveCriticalSection(CCriticalSection* p){
+    CCriticalSection_t* self=0;
+    int                 rt;
+    assert(p!=0);
+    self=(CCriticalSection_t*)(*p);
+    assert(self!=0);
+    rt=pthread_mutex_unlock(&self->mutex);
+    assert(rt==0);
+}
+
+
+//#ifdef MTCODER__USE_WRITE_THREAD
+static pthread_mutex_t _g_inc_lock = PTHREAD_MUTEX_INITIALIZER;
+LONG _def_InterlockedIncrement(LONG* lpAddend){
+    //very slow , todo: changed to use __sync_fetch_and_add or atomic_inc_return ...
+    LONG result;
+    pthread_mutex_lock(&_g_inc_lock);
+    result=*lpAddend;
+    ++result;
+    *lpAddend=result;
+    pthread_mutex_unlock(&_g_inc_lock);
+    return result;
+}
+//#endif
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/C/ThreadsP.h

@@ -0,0 +1,31 @@
+// ThreadsP.h
+//   for not _WIN32 ,used pthread
+//   2019-02-05 : by housisong : for HDiffPatch
+
+#ifndef __7Z_THRESDS_P_H
+#define __7Z_THRESDS_P_H
+#ifndef _WIN32
+#include "7zTypes.h"
+#include <string.h> //memcpy
+
+typedef void*   HANDLE;
+typedef void*   LPVOID;
+#define LONG    Int32
+#define HRESULT UInt32
+
+typedef void*   CRITICAL_SECTION;
+void _def_DeleteCriticalSection(CRITICAL_SECTION* p);
+void _def_EnterCriticalSection (CRITICAL_SECTION* p);
+void _def_LeaveCriticalSection (CRITICAL_SECTION* p);
+#define  DeleteCriticalSection  _def_DeleteCriticalSection
+#define  EnterCriticalSection   _def_EnterCriticalSection
+#define  LeaveCriticalSection   _def_LeaveCriticalSection
+
+//#ifdef MTCODER__USE_WRITE_THREAD
+LONG _def_InterlockedIncrement(LONG* lpAddend);
+#define  InterlockedIncrement   _def_InterlockedIncrement
+//#endif
+
+#endif
+#endif
+