public sqlite3_mutex(sqlite3_mutex mutex, int id, int nRef, int owner
#if DEBUG
, int trace
#endif
)
        {
            this.mutex = mutex;
            this.id = id;
            this.nRef = nRef;
            this.owner = owner;
#if DEBUG
            this.trace = 0;
#endif
        }

 static int debugMutexTry( sqlite3_mutex pX )
 {
     sqlite3_debug_mutex p = (sqlite3_debug_mutex)pX;
       Debug.Assert( p.id == SQLITE_MUTEX_RECURSIVE || debugMutexNotheld( p ) );
       p.cnt++;
       return SQLITE_OK;
 }

 static bool debugMutexNotheld( sqlite3_mutex pX )
 {
     sqlite3_debug_mutex p = (sqlite3_debug_mutex)pX;
       return p == null || p.cnt == 0;
 }

 public static void sqlite3_mutex_enter(sqlite3_mutex sqlite3_mutex)
 {
 }

		}   //#define sqlite3_mutex_try(X)      SQLITE_OK
		static void sqlite3_mutex_leave(sqlite3_mutex m)
		{
		}            //#define sqlite3_mutex_leave(X)

		}//#define sqlite3_mutex_alloc(X)    ((sqlite3_mutex*)8)
		static void sqlite3_mutex_free(sqlite3_mutex m)
		{
		}          //#define sqlite3_mutex_free(X)

 static int noopMutexNotheld(sqlite3_mutex p)
 {
     return 1;
 }

/*
** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
*/
static int sqlite3_mutex_try(sqlite3_mutex p){
  int rc = SQLITE_OK;
  if( p!=null ){
    return sqlite3GlobalConfig.mutex.xMutexTry(p);
  }
  return rc;
}

/*
** The sqlite3_mutex_leave() routine exits a mutex that was previously
** entered by the same thread.  The behavior is undefined if the mutex 
** is not currently entered. If a NULL pointer is passed as an argument
** this function is a no-op.
*/
static void sqlite3_mutex_leave(sqlite3_mutex p){
  if( p !=null){
    sqlite3GlobalConfig.mutex.xMutexLeave(p);
  }
}

/*
** Free a dynamic mutex.
*/
static void sqlite3_mutex_free( sqlite3_mutex p){
  if( p!=null ){
    sqlite3GlobalConfig.mutex.xMutexFree( p);
  }
}

/*
** Obtain the mutex p. If some other thread already has the mutex, block
** until it can be obtained.
*/
static void sqlite3_mutex_enter(sqlite3_mutex p){
  if( p !=null){
    sqlite3GlobalConfig.mutex.xMutexEnter(p);
  }
}

 public static bool sqlite3_mutex_notheld(sqlite3_mutex sqlite3_mutex)
 {
     return true;
 }

 public static void sqlite3_mutex_leave(sqlite3_mutex sqlite3_mutex)
 {
 }

 public static void sqlite3_mutex_free(sqlite3_mutex mutex)
 {
 }

 static void noopMutexFree(sqlite3_mutex p)
 {
 }

    static bool sqlite3_mutex_notheld(sqlite3_mutex p){
  return p == null || sqlite3GlobalConfig.mutex.xMutexNotheld( p );
}

 static void noopMutexLeave(sqlite3_mutex p)
 {
 }

 /*
 ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
 ** to enter a mutex.  If another thread is already within the mutex,
 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
 ** SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
 ** upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
 ** be entered multiple times by the same thread.  In such cases the,
 ** mutex must be exited an equal number of times before another thread
 ** can enter.  If the same thread tries to enter any other kind of mutex
 ** more than once, the behavior is undefined.
 */
 static void debugMutexEnter( sqlite3_mutex pX )
 {
     sqlite3_debug_mutex p = (sqlite3_debug_mutex)pX;
       Debug.Assert( p.id == SQLITE_MUTEX_RECURSIVE || debugMutexNotheld( p ) );
       p.cnt++;
 }

 static int noopMutexTry(sqlite3_mutex p)
 {
     return SQLITE_OK;
 }

 /*
 ** This routine deallocates a previously allocated mutex.
 */
 static void debugMutexFree( sqlite3_mutex pX )
 {
     sqlite3_debug_mutex p = (sqlite3_debug_mutex)pX;
       Debug.Assert( p.cnt == 0 );
       Debug.Assert( p.id == SQLITE_MUTEX_FAST || p.id == SQLITE_MUTEX_RECURSIVE );
       //sqlite3_free(ref p);
 }